/* Options:
Date: 2025-06-13 07:52:59
Version: 6.40
Tip: To override a DTO option, remove "//" prefix before updating
BaseUrl: https://ws.jimsnwa.com

//GlobalNamespace: 
//AddServiceStackTypes: True
//AddResponseStatus: False
//AddImplicitVersion: 
//AddDescriptionAsComments: True
IncludeTypes: DefinicionCuboRQ.*
//ExcludeTypes: 
//DefaultImports: package:servicestack/servicestack.dart,dart:typed_data
*/

import 'package:servicestack/servicestack.dart';
import 'dart:typed_data';

enum Lenguajes
{
    ES,
    PT,
    EN,
}

class VersionLookup implements IConvertible
{
    double? CodLookup;
    String? Version;

    VersionLookup({this.CodLookup,this.Version});
    VersionLookup.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        CodLookup = JsonConverters.toDouble(json['CodLookup']);
        Version = json['Version'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'CodLookup': CodLookup,
        'Version': Version
    };

    getTypeName() => "VersionLookup";
    TypeContext? context = _ctx;
}

// @DataContract
class Vista implements IConvertible
{
    // @DataMember
    double? Codigo;

    // @DataMember
    double? CodigoBlob;

    // @DataMember
    String? Nombre;

    // @DataMember
    String? Descripcion;

    // @DataMember
    String? SQL;

    // @DataMember
    double? CodigoTabla;

    // @DataMember
    String? GuardarBinario;

    // @DataMember
    String? TipoConsulta;

    // @DataMember
    String? ExportacionDefault;

    // @DataMember
    String? TipoExportacion;

    // @DataMember
    int? ParametrosExportacion;

    // @DataMember
    String? CodigoAyuda;

    // @DataMember
    String? EjecutarEnAdm;

    // @DataMember
    String? InfoAdicional;

    // @DataMember
    String? EjecMultiempresa;

    Vista({this.Codigo,this.CodigoBlob,this.Nombre,this.Descripcion,this.SQL,this.CodigoTabla,this.GuardarBinario,this.TipoConsulta,this.ExportacionDefault,this.TipoExportacion,this.ParametrosExportacion,this.CodigoAyuda,this.EjecutarEnAdm,this.InfoAdicional,this.EjecMultiempresa});
    Vista.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Codigo = JsonConverters.toDouble(json['Codigo']);
        CodigoBlob = JsonConverters.toDouble(json['CodigoBlob']);
        Nombre = json['Nombre'];
        Descripcion = json['Descripcion'];
        SQL = json['SQL'];
        CodigoTabla = JsonConverters.toDouble(json['CodigoTabla']);
        GuardarBinario = json['GuardarBinario'];
        TipoConsulta = json['TipoConsulta'];
        ExportacionDefault = json['ExportacionDefault'];
        TipoExportacion = json['TipoExportacion'];
        ParametrosExportacion = json['ParametrosExportacion'];
        CodigoAyuda = json['CodigoAyuda'];
        EjecutarEnAdm = json['EjecutarEnAdm'];
        InfoAdicional = json['InfoAdicional'];
        EjecMultiempresa = json['EjecMultiempresa'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'Codigo': Codigo,
        'CodigoBlob': CodigoBlob,
        'Nombre': Nombre,
        'Descripcion': Descripcion,
        'SQL': SQL,
        'CodigoTabla': CodigoTabla,
        'GuardarBinario': GuardarBinario,
        'TipoConsulta': TipoConsulta,
        'ExportacionDefault': ExportacionDefault,
        'TipoExportacion': TipoExportacion,
        'ParametrosExportacion': ParametrosExportacion,
        'CodigoAyuda': CodigoAyuda,
        'EjecutarEnAdm': EjecutarEnAdm,
        'InfoAdicional': InfoAdicional,
        'EjecMultiempresa': EjecMultiempresa
    };

    getTypeName() => "Vista";
    TypeContext? context = _ctx;
}

// @DataContract
class Tabla implements IConvertible
{
    // @DataMember
    double? Codigo;

    // @DataMember
    String? Propietario;

    // @DataMember
    String? Tipo;

    // @DataMember
    String? Nombre;

    // @DataMember
    String? Alias;

    // @DataMember
    String? Descripcion;

    // @DataMember
    String? ParaReportes;

    // @DataMember
    String? CrearAlIniciar;

    // @DataMember
    int? CampoEmpresa;

    // @DataMember
    int? CampoUnico;

    Tabla({this.Codigo,this.Propietario,this.Tipo,this.Nombre,this.Alias,this.Descripcion,this.ParaReportes,this.CrearAlIniciar,this.CampoEmpresa,this.CampoUnico});
    Tabla.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Codigo = JsonConverters.toDouble(json['Codigo']);
        Propietario = json['Propietario'];
        Tipo = json['Tipo'];
        Nombre = json['Nombre'];
        Alias = json['Alias'];
        Descripcion = json['Descripcion'];
        ParaReportes = json['ParaReportes'];
        CrearAlIniciar = json['CrearAlIniciar'];
        CampoEmpresa = json['CampoEmpresa'];
        CampoUnico = json['CampoUnico'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'Codigo': Codigo,
        'Propietario': Propietario,
        'Tipo': Tipo,
        'Nombre': Nombre,
        'Alias': Alias,
        'Descripcion': Descripcion,
        'ParaReportes': ParaReportes,
        'CrearAlIniciar': CrearAlIniciar,
        'CampoEmpresa': CampoEmpresa,
        'CampoUnico': CampoUnico
    };

    getTypeName() => "Tabla";
    TypeContext? context = _ctx;
}

// @DataContract
class Columna implements IConvertible
{
    // @DataMember
    double? CodigoTabla;

    // @DataMember
    double? Codigo;

    // @DataMember
    String? Nombre;

    // @DataMember
    String? Alias;

    // @DataMember
    String? Descripcion;

    // @DataMember
    String? TipoDato;

    // @DataMember
    String? ObligatorioFormas;

    // @DataMember
    String? Hint;

    // @DataMember
    String? Mayuscula;

    // @DataMember
    int? Tamano;

    // @DataMember
    int? Escala;

    // @DataMember
    String? Tipo;

    // @DataMember
    String? VlrDefecto;

    // @DataMember
    String? PermiteEditar;

    // @DataMember
    int? Orden;

    // @DataMember
    String? Dinamico;

    // @DataMember
    String? ClaseControl;

    // @DataMember
    double? JoinLookup;

    // @DataMember
    String? EsID;

    // @DataMember
    String? Mascara;

    // @DataMember
    String? MostrarEnLista;

    // @DataMember
    String? InfoAdicional;

    // @DataMember
    String? WHEREDefecto;

    // @DataMember
    String? TieneResumen;

    // @DataMember
    String? FormatoResumen;

    // @DataMember
    String? TipoResumen;

    // @DataMember
    String? PosicionResumen;

    // @DataMember
    String? ResumenEnGrupo;

    // @DataMember
    String? ResumenEnTotal;

    // @DataMember
    int? IndiceGrupo;

    Columna({this.CodigoTabla,this.Codigo,this.Nombre,this.Alias,this.Descripcion,this.TipoDato,this.ObligatorioFormas,this.Hint,this.Mayuscula,this.Tamano,this.Escala,this.Tipo,this.VlrDefecto,this.PermiteEditar,this.Orden,this.Dinamico,this.ClaseControl,this.JoinLookup,this.EsID,this.Mascara,this.MostrarEnLista,this.InfoAdicional,this.WHEREDefecto,this.TieneResumen,this.FormatoResumen,this.TipoResumen,this.PosicionResumen,this.ResumenEnGrupo,this.ResumenEnTotal,this.IndiceGrupo});
    Columna.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        CodigoTabla = JsonConverters.toDouble(json['CodigoTabla']);
        Codigo = JsonConverters.toDouble(json['Codigo']);
        Nombre = json['Nombre'];
        Alias = json['Alias'];
        Descripcion = json['Descripcion'];
        TipoDato = json['TipoDato'];
        ObligatorioFormas = json['ObligatorioFormas'];
        Hint = json['Hint'];
        Mayuscula = json['Mayuscula'];
        Tamano = json['Tamano'];
        Escala = json['Escala'];
        Tipo = json['Tipo'];
        VlrDefecto = json['VlrDefecto'];
        PermiteEditar = json['PermiteEditar'];
        Orden = json['Orden'];
        Dinamico = json['Dinamico'];
        ClaseControl = json['ClaseControl'];
        JoinLookup = JsonConverters.toDouble(json['JoinLookup']);
        EsID = json['EsID'];
        Mascara = json['Mascara'];
        MostrarEnLista = json['MostrarEnLista'];
        InfoAdicional = json['InfoAdicional'];
        WHEREDefecto = json['WHEREDefecto'];
        TieneResumen = json['TieneResumen'];
        FormatoResumen = json['FormatoResumen'];
        TipoResumen = json['TipoResumen'];
        PosicionResumen = json['PosicionResumen'];
        ResumenEnGrupo = json['ResumenEnGrupo'];
        ResumenEnTotal = json['ResumenEnTotal'];
        IndiceGrupo = json['IndiceGrupo'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'CodigoTabla': CodigoTabla,
        'Codigo': Codigo,
        'Nombre': Nombre,
        'Alias': Alias,
        'Descripcion': Descripcion,
        'TipoDato': TipoDato,
        'ObligatorioFormas': ObligatorioFormas,
        'Hint': Hint,
        'Mayuscula': Mayuscula,
        'Tamano': Tamano,
        'Escala': Escala,
        'Tipo': Tipo,
        'VlrDefecto': VlrDefecto,
        'PermiteEditar': PermiteEditar,
        'Orden': Orden,
        'Dinamico': Dinamico,
        'ClaseControl': ClaseControl,
        'JoinLookup': JoinLookup,
        'EsID': EsID,
        'Mascara': Mascara,
        'MostrarEnLista': MostrarEnLista,
        'InfoAdicional': InfoAdicional,
        'WHEREDefecto': WHEREDefecto,
        'TieneResumen': TieneResumen,
        'FormatoResumen': FormatoResumen,
        'TipoResumen': TipoResumen,
        'PosicionResumen': PosicionResumen,
        'ResumenEnGrupo': ResumenEnGrupo,
        'ResumenEnTotal': ResumenEnTotal,
        'IndiceGrupo': IndiceGrupo
    };

    getTypeName() => "Columna";
    TypeContext? context = _ctx;
}

class DetalleJoinTabla implements IConvertible
{
    double? Codigo;
    String? CampoAMostrar;
    List<String>? Campos1;
    List<String>? Campos2;
    List<String>? Operadores;
    List<Map<String,dynamic>>? Datos;
    double? CodigoTabla1;
    String? SQL;
    DefinicionTabla? TablaDetalle;
    Vista? Vista;
    String? Version;

    DetalleJoinTabla({this.Codigo,this.CampoAMostrar,this.Campos1,this.Campos2,this.Operadores,this.Datos,this.CodigoTabla1,this.SQL,this.TablaDetalle,this.Vista,this.Version});
    DetalleJoinTabla.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Codigo = JsonConverters.toDouble(json['Codigo']);
        CampoAMostrar = json['CampoAMostrar'];
        Campos1 = JsonConverters.fromJson(json['Campos1'],'List<String>',context!);
        Campos2 = JsonConverters.fromJson(json['Campos2'],'List<String>',context!);
        Operadores = JsonConverters.fromJson(json['Operadores'],'List<String>',context!);
        Datos = JsonConverters.fromJson(json['Datos'],'List<Map<String,dynamic>>',context!);
        CodigoTabla1 = JsonConverters.toDouble(json['CodigoTabla1']);
        SQL = json['SQL'];
        TablaDetalle = JsonConverters.fromJson(json['TablaDetalle'],'DefinicionTabla',context!);
        Vista = JsonConverters.fromJson(json['Vista'],'Vista',context!);
        Version = json['Version'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'Codigo': Codigo,
        'CampoAMostrar': CampoAMostrar,
        'Campos1': JsonConverters.toJson(Campos1,'List<String>',context!),
        'Campos2': JsonConverters.toJson(Campos2,'List<String>',context!),
        'Operadores': JsonConverters.toJson(Operadores,'List<String>',context!),
        'Datos': JsonConverters.toJson(Datos,'List<Map<String,dynamic>>',context!),
        'CodigoTabla1': CodigoTabla1,
        'SQL': SQL,
        'TablaDetalle': JsonConverters.toJson(TablaDetalle,'DefinicionTabla',context!),
        'Vista': JsonConverters.toJson(Vista,'Vista',context!),
        'Version': Version
    };

    getTypeName() => "DetalleJoinTabla";
    TypeContext? context = _ctx;
}

class ColCountByScreen implements IConvertible
{
    int? lg;
    int? md;
    int? sm;
    int? xs;

    ColCountByScreen({this.lg,this.md,this.sm,this.xs});
    ColCountByScreen.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        lg = json['lg'];
        md = json['md'];
        sm = json['sm'];
        xs = json['xs'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'lg': lg,
        'md': md,
        'sm': sm,
        'xs': xs
    };

    getTypeName() => "ColCountByScreen";
    TypeContext? context = _ctx;
}

enum ItemTypeForm
{
    simple,
    group,
    tabbed,
    empty,
}

class EmptyItemForm implements IConvertible
{
    ItemTypeForm? itemType;
    int? visibleIndex;

    EmptyItemForm({this.itemType,this.visibleIndex});
    EmptyItemForm.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        itemType = JsonConverters.fromJson(json['itemType'],'ItemTypeForm',context!);
        visibleIndex = json['visibleIndex'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'itemType': JsonConverters.toJson(itemType,'ItemTypeForm',context!),
        'visibleIndex': visibleIndex
    };

    getTypeName() => "EmptyItemForm";
    TypeContext? context = _ctx;
}

class dxForm implements IConvertible
{
    ColCountByScreen? colCountByScreen;
    String? labelLocation;
    bool? readOnly;
    List<EmptyItemForm>? items;

    dxForm({this.colCountByScreen,this.labelLocation,this.readOnly,this.items});
    dxForm.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        colCountByScreen = JsonConverters.fromJson(json['colCountByScreen'],'ColCountByScreen',context!);
        labelLocation = json['labelLocation'];
        readOnly = json['readOnly'];
        items = JsonConverters.fromJson(json['items'],'List<EmptyItemForm>',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'colCountByScreen': JsonConverters.toJson(colCountByScreen,'ColCountByScreen',context!),
        'labelLocation': labelLocation,
        'readOnly': readOnly,
        'items': JsonConverters.toJson(items,'List<EmptyItemForm>',context!)
    };

    getTypeName() => "dxForm";
    TypeContext? context = _ctx;
}

class DefinicionTabla implements IConvertible
{
    Tabla? Tabla;
    List<Columna>? Columnas;
    List<DetalleJoinTabla>? Lookups;
    List<Frame>? Frames;
    List<DetalleIndices>? DetalleLlave;
    dxForm? Form;
    dxDataGrid? DataGrid;

    DefinicionTabla({this.Tabla,this.Columnas,this.Lookups,this.Frames,this.DetalleLlave,this.Form,this.DataGrid});
    DefinicionTabla.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Tabla = JsonConverters.fromJson(json['Tabla'],'Tabla',context!);
        Columnas = JsonConverters.fromJson(json['Columnas'],'List<Columna>',context!);
        Lookups = JsonConverters.fromJson(json['Lookups'],'List<DetalleJoinTabla>',context!);
        Frames = JsonConverters.fromJson(json['Frames'],'List<Frame>',context!);
        DetalleLlave = JsonConverters.fromJson(json['DetalleLlave'],'List<DetalleIndices>',context!);
        Form = JsonConverters.fromJson(json['Form'],'dxForm',context!);
        DataGrid = JsonConverters.fromJson(json['DataGrid'],'dxDataGrid',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'Tabla': JsonConverters.toJson(Tabla,'Tabla',context!),
        'Columnas': JsonConverters.toJson(Columnas,'List<Columna>',context!),
        'Lookups': JsonConverters.toJson(Lookups,'List<DetalleJoinTabla>',context!),
        'Frames': JsonConverters.toJson(Frames,'List<Frame>',context!),
        'DetalleLlave': JsonConverters.toJson(DetalleLlave,'List<DetalleIndices>',context!),
        'Form': JsonConverters.toJson(Form,'dxForm',context!),
        'DataGrid': JsonConverters.toJson(DataGrid,'dxDataGrid',context!)
    };

    getTypeName() => "DefinicionTabla";
    TypeContext? context = _ctx;
}

class PivotGridConf implements IConvertible
{
    double? Codigo;
    String? Nombre;
    String? CrearChart;
    String? Configuration;
    String? Chart;
    String? Observaciones;
    double? IDVista;
    String? Usuario;
    DateTime? FechaCreacion;

    PivotGridConf({this.Codigo,this.Nombre,this.CrearChart,this.Configuration,this.Chart,this.Observaciones,this.IDVista,this.Usuario,this.FechaCreacion});
    PivotGridConf.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Codigo = JsonConverters.toDouble(json['Codigo']);
        Nombre = json['Nombre'];
        CrearChart = json['CrearChart'];
        Configuration = json['Configuration'];
        Chart = json['Chart'];
        Observaciones = json['Observaciones'];
        IDVista = JsonConverters.toDouble(json['IDVista']);
        Usuario = json['Usuario'];
        FechaCreacion = JsonConverters.fromJson(json['FechaCreacion'],'DateTime',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'Codigo': Codigo,
        'Nombre': Nombre,
        'CrearChart': CrearChart,
        'Configuration': Configuration,
        'Chart': Chart,
        'Observaciones': Observaciones,
        'IDVista': IDVista,
        'Usuario': Usuario,
        'FechaCreacion': JsonConverters.toJson(FechaCreacion,'DateTime',context!)
    };

    getTypeName() => "PivotGridConf";
    TypeContext? context = _ctx;
}

class DefinicionCuboRS implements IConvertible
{
    Tabla? Tabla;
    String? Descripcion;
    List<Columna>? Filtros;
    List<Columna>? Filas;
    List<Columna>? Columnas;
    List<Columna>? Calculos;
    List<Columna>? Parametros;
    List<DetalleJoinTabla>? Lookups;
    Map<String,dynamic?>? dxPivotGrid;
    Map<String,dynamic?>? dxChart;
    dxForm? FormaParametros;
    PivotGridConf? PivotGridConf;
    String? Error;

    DefinicionCuboRS({this.Tabla,this.Descripcion,this.Filtros,this.Filas,this.Columnas,this.Calculos,this.Parametros,this.Lookups,this.dxPivotGrid,this.dxChart,this.FormaParametros,this.PivotGridConf,this.Error});
    DefinicionCuboRS.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Tabla = JsonConverters.fromJson(json['Tabla'],'Tabla',context!);
        Descripcion = json['Descripcion'];
        Filtros = JsonConverters.fromJson(json['Filtros'],'List<Columna>',context!);
        Filas = JsonConverters.fromJson(json['Filas'],'List<Columna>',context!);
        Columnas = JsonConverters.fromJson(json['Columnas'],'List<Columna>',context!);
        Calculos = JsonConverters.fromJson(json['Calculos'],'List<Columna>',context!);
        Parametros = JsonConverters.fromJson(json['Parametros'],'List<Columna>',context!);
        Lookups = JsonConverters.fromJson(json['Lookups'],'List<DetalleJoinTabla>',context!);
        dxPivotGrid = JsonConverters.fromJson(json['dxPivotGrid'],'Map<String,dynamic?>',context!);
        dxChart = JsonConverters.fromJson(json['dxChart'],'Map<String,dynamic?>',context!);
        FormaParametros = JsonConverters.fromJson(json['FormaParametros'],'dxForm',context!);
        PivotGridConf = JsonConverters.fromJson(json['PivotGridConf'],'PivotGridConf',context!);
        Error = json['Error'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'Tabla': JsonConverters.toJson(Tabla,'Tabla',context!),
        'Descripcion': Descripcion,
        'Filtros': JsonConverters.toJson(Filtros,'List<Columna>',context!),
        'Filas': JsonConverters.toJson(Filas,'List<Columna>',context!),
        'Columnas': JsonConverters.toJson(Columnas,'List<Columna>',context!),
        'Calculos': JsonConverters.toJson(Calculos,'List<Columna>',context!),
        'Parametros': JsonConverters.toJson(Parametros,'List<Columna>',context!),
        'Lookups': JsonConverters.toJson(Lookups,'List<DetalleJoinTabla>',context!),
        'dxPivotGrid': JsonConverters.toJson(dxPivotGrid,'Map<String,dynamic?>',context!),
        'dxChart': JsonConverters.toJson(dxChart,'Map<String,dynamic?>',context!),
        'FormaParametros': JsonConverters.toJson(FormaParametros,'dxForm',context!),
        'PivotGridConf': JsonConverters.toJson(PivotGridConf,'PivotGridConf',context!),
        'Error': Error
    };

    getTypeName() => "DefinicionCuboRS";
    TypeContext? context = _ctx;
}

// @Route("/Utilidades/Consultas/Cubos/Definicion")
class DefinicionCuboRQ implements IReturn<DefinicionCuboRS>, IConvertible
{
    int? IDVista;
    int? IDPivot;
    bool? DatosLookups;
    Lenguajes? Lenguaje;
    List<VersionLookup>? VersionesLookupCliente;

    DefinicionCuboRQ({this.IDVista,this.IDPivot,this.DatosLookups,this.Lenguaje,this.VersionesLookupCliente});
    DefinicionCuboRQ.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        IDVista = json['IDVista'];
        IDPivot = json['IDPivot'];
        DatosLookups = json['DatosLookups'];
        Lenguaje = JsonConverters.fromJson(json['Lenguaje'],'Lenguajes',context!);
        VersionesLookupCliente = JsonConverters.fromJson(json['VersionesLookupCliente'],'List<VersionLookup>',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'IDVista': IDVista,
        'IDPivot': IDPivot,
        'DatosLookups': DatosLookups,
        'Lenguaje': JsonConverters.toJson(Lenguaje,'Lenguajes',context!),
        'VersionesLookupCliente': JsonConverters.toJson(VersionesLookupCliente,'List<VersionLookup>',context!)
    };

    createResponse() => DefinicionCuboRS();
    getResponseTypeName() => "DefinicionCuboRS";
    getTypeName() => "DefinicionCuboRQ";
    TypeContext? context = _ctx;
}

TypeContext _ctx = TypeContext(library: 'ws.jimsnwa.com', types: <String, TypeInfo> {
    'Lenguajes': TypeInfo(TypeOf.Enum, enumValues:Lenguajes.values),
    'VersionLookup': TypeInfo(TypeOf.Class, create:() => VersionLookup()),
    'Vista': TypeInfo(TypeOf.Class, create:() => Vista()),
    'Tabla': TypeInfo(TypeOf.Class, create:() => Tabla()),
    'Columna': TypeInfo(TypeOf.Class, create:() => Columna()),
    'DetalleJoinTabla': TypeInfo(TypeOf.Class, create:() => DetalleJoinTabla()),
    'List<Map<String,dynamic>>': TypeInfo(TypeOf.Class, create:() => <Map<String,dynamic>>[]),
    'Map<String,dynamic>': TypeInfo(TypeOf.Class, create:() => Map<String,dynamic>()),
    'DefinicionTabla': TypeInfo(TypeOf.Class, create:() => DefinicionTabla()),
    'ColCountByScreen': TypeInfo(TypeOf.Class, create:() => ColCountByScreen()),
    'ItemTypeForm': TypeInfo(TypeOf.Enum, enumValues:ItemTypeForm.values),
    'EmptyItemForm': TypeInfo(TypeOf.Class, create:() => EmptyItemForm()),
    'dxForm': TypeInfo(TypeOf.Class, create:() => dxForm()),
    'List<EmptyItemForm>': TypeInfo(TypeOf.Class, create:() => <EmptyItemForm>[]),
    'List<Columna>': TypeInfo(TypeOf.Class, create:() => <Columna>[]),
    'List<DetalleJoinTabla>': TypeInfo(TypeOf.Class, create:() => <DetalleJoinTabla>[]),
    'List<Frame>': TypeInfo(TypeOf.Class, create:() => <Frame>[]),
    'Frame': TypeInfo(TypeOf.Class, create:() => Frame()),
    'List<DetalleIndices>': TypeInfo(TypeOf.Class, create:() => <DetalleIndices>[]),
    'DetalleIndices': TypeInfo(TypeOf.Class, create:() => DetalleIndices()),
    'dxDataGrid': TypeInfo(TypeOf.Class, create:() => dxDataGrid()),
    'PivotGridConf': TypeInfo(TypeOf.Class, create:() => PivotGridConf()),
    'DefinicionCuboRS': TypeInfo(TypeOf.Class, create:() => DefinicionCuboRS()),
    'Map<String,dynamic?>': TypeInfo(TypeOf.Class, create:() => Map<String,dynamic?>()),
    'DefinicionCuboRQ': TypeInfo(TypeOf.Class, create:() => DefinicionCuboRQ()),
    'List<VersionLookup>': TypeInfo(TypeOf.Class, create:() => <VersionLookup>[]),
});