FrameAppWS

DefinicionCuboRQ

The following routes are available for this service:
All Verbs	/Utilidades/Consultas/Cubos/Definicion

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

// @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;
}

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

    // @DataMember
    String? SQL;

    // @DataMember
    List<String>? Campos1;

    // @DataMember
    List<String>? Campos2;

    // @DataMember
    DefinicionTabla? TablaFrame;

    Frame({this.Codigo,this.SQL,this.Campos1,this.Campos2,this.TablaFrame});
    Frame.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Codigo = JsonConverters.toDouble(json['Codigo']);
        SQL = json['SQL'];
        Campos1 = JsonConverters.fromJson(json['Campos1'],'List<String>',context!);
        Campos2 = JsonConverters.fromJson(json['Campos2'],'List<String>',context!);
        TablaFrame = JsonConverters.fromJson(json['TablaFrame'],'DefinicionTabla',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'Codigo': Codigo,
        'SQL': SQL,
        'Campos1': JsonConverters.toJson(Campos1,'List<String>',context!),
        'Campos2': JsonConverters.toJson(Campos2,'List<String>',context!),
        'TablaFrame': JsonConverters.toJson(TablaFrame,'DefinicionTabla',context!)
    };

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

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

    // @DataMember
    String? NombreIndice;

    // @DataMember
    double? CodigoColumna;

    // @DataMember
    String? TipoCalculo;

    // @DataMember
    String? Secuencia;

    // @DataMember
    String? NombreColumna;

    DetalleIndices({this.CodigoTabla,this.NombreIndice,this.CodigoColumna,this.TipoCalculo,this.Secuencia,this.NombreColumna});
    DetalleIndices.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        CodigoTabla = JsonConverters.toDouble(json['CodigoTabla']);
        NombreIndice = json['NombreIndice'];
        CodigoColumna = JsonConverters.toDouble(json['CodigoColumna']);
        TipoCalculo = json['TipoCalculo'];
        Secuencia = json['Secuencia'];
        NombreColumna = json['NombreColumna'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'CodigoTabla': CodigoTabla,
        'NombreIndice': NombreIndice,
        'CodigoColumna': CodigoColumna,
        'TipoCalculo': TipoCalculo,
        'Secuencia': Secuencia,
        'NombreColumna': NombreColumna
    };

    getTypeName() => "DetalleIndices";
    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 ValidationRule implements IConvertible
{
    String? type;
    String? message;

    ValidationRule({this.type,this.message});
    ValidationRule.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        type = json['type'];
        message = json['message'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'type': type,
        'message': message
    };

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

class LookupGrid implements IConvertible
{
    bool? allowClearing;
    String? displayExpr;
    String? valueExpr;

    LookupGrid({this.allowClearing,this.displayExpr,this.valueExpr});
    LookupGrid.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        allowClearing = json['allowClearing'];
        displayExpr = json['displayExpr'];
        valueExpr = json['valueExpr'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'allowClearing': allowClearing,
        'displayExpr': displayExpr,
        'valueExpr': valueExpr
    };

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

class ColumnGrid implements IConvertible
{
    String? caption;
    String? dataField;
    String? dataType;
    int? visibleIndex;
    List<ValidationRule>? validationRules;
    LookupGrid? lookup;
    bool? allowEditing;
    bool? encodeHtml;
    Map<String,dynamic?>? editorOptions;
    int? groupIndex;

    ColumnGrid({this.caption,this.dataField,this.dataType,this.visibleIndex,this.validationRules,this.lookup,this.allowEditing,this.encodeHtml,this.editorOptions,this.groupIndex});
    ColumnGrid.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        caption = json['caption'];
        dataField = json['dataField'];
        dataType = json['dataType'];
        visibleIndex = json['visibleIndex'];
        validationRules = JsonConverters.fromJson(json['validationRules'],'List<ValidationRule>',context!);
        lookup = JsonConverters.fromJson(json['lookup'],'LookupGrid',context!);
        allowEditing = json['allowEditing'];
        encodeHtml = json['encodeHtml'];
        editorOptions = JsonConverters.fromJson(json['editorOptions'],'Map<String,dynamic?>',context!);
        groupIndex = json['groupIndex'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'caption': caption,
        'dataField': dataField,
        'dataType': dataType,
        'visibleIndex': visibleIndex,
        'validationRules': JsonConverters.toJson(validationRules,'List<ValidationRule>',context!),
        'lookup': JsonConverters.toJson(lookup,'LookupGrid',context!),
        'allowEditing': allowEditing,
        'encodeHtml': encodeHtml,
        'editorOptions': JsonConverters.toJson(editorOptions,'Map<String,dynamic?>',context!),
        'groupIndex': groupIndex
    };

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

class EditingGrid implements IConvertible
{
    bool? allowAdding;
    bool? allowDeleting;
    bool? allowUpdating;
    String? mode;

    EditingGrid({this.allowAdding,this.allowDeleting,this.allowUpdating,this.mode});
    EditingGrid.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        allowAdding = json['allowAdding'];
        allowDeleting = json['allowDeleting'];
        allowUpdating = json['allowUpdating'];
        mode = json['mode'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'allowAdding': allowAdding,
        'allowDeleting': allowDeleting,
        'allowUpdating': allowUpdating,
        'mode': mode
    };

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

class gridSummaryGroupItems implements IConvertible
{
    String? column;
    String? displayFormat;
    bool? showInGroupFooter;
    String? summaryType;

    gridSummaryGroupItems({this.column,this.displayFormat,this.showInGroupFooter,this.summaryType});
    gridSummaryGroupItems.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        column = json['column'];
        displayFormat = json['displayFormat'];
        showInGroupFooter = json['showInGroupFooter'];
        summaryType = json['summaryType'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'column': column,
        'displayFormat': displayFormat,
        'showInGroupFooter': showInGroupFooter,
        'summaryType': summaryType
    };

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

class gridSummaryTotalItems implements IConvertible
{
    String? column;
    String? displayFormat;
    String? summaryType;

    gridSummaryTotalItems({this.column,this.displayFormat,this.summaryType});
    gridSummaryTotalItems.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        column = json['column'];
        displayFormat = json['displayFormat'];
        summaryType = json['summaryType'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'column': column,
        'displayFormat': displayFormat,
        'summaryType': summaryType
    };

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

class gridSummary implements IConvertible
{
    List<gridSummaryGroupItems>? groupItems;
    List<gridSummaryTotalItems>? totalItems;

    gridSummary({this.groupItems,this.totalItems});
    gridSummary.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        groupItems = JsonConverters.fromJson(json['groupItems'],'List<gridSummaryGroupItems>',context!);
        totalItems = JsonConverters.fromJson(json['totalItems'],'List<gridSummaryTotalItems>',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'groupItems': JsonConverters.toJson(groupItems,'List<gridSummaryGroupItems>',context!),
        'totalItems': JsonConverters.toJson(totalItems,'List<gridSummaryTotalItems>',context!)
    };

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

class dxDataGrid implements IConvertible
{
    List<ColumnGrid>? columns;
    bool? showColumnLines;
    bool? showRowLines;
    bool? rowAlternationEnabled;
    bool? showBorders;
    EditingGrid? editing;
    gridSummary? summary;

    dxDataGrid({this.columns,this.showColumnLines,this.showRowLines,this.rowAlternationEnabled,this.showBorders,this.editing,this.summary});
    dxDataGrid.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        columns = JsonConverters.fromJson(json['columns'],'List<ColumnGrid>',context!);
        showColumnLines = json['showColumnLines'];
        showRowLines = json['showRowLines'];
        rowAlternationEnabled = json['rowAlternationEnabled'];
        showBorders = json['showBorders'];
        editing = JsonConverters.fromJson(json['editing'],'EditingGrid',context!);
        summary = JsonConverters.fromJson(json['summary'],'gridSummary',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'columns': JsonConverters.toJson(columns,'List<ColumnGrid>',context!),
        'showColumnLines': showColumnLines,
        'showRowLines': showRowLines,
        'rowAlternationEnabled': rowAlternationEnabled,
        'showBorders': showBorders,
        'editing': JsonConverters.toJson(editing,'EditingGrid',context!),
        'summary': JsonConverters.toJson(summary,'gridSummary',context!)
    };

    getTypeName() => "dxDataGrid";
    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;
}

// @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;
}

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;
    String? Ordenar;

    DetalleJoinTabla({this.Codigo,this.CampoAMostrar,this.Campos1,this.Campos2,this.Operadores,this.Datos,this.CodigoTabla1,this.SQL,this.TablaDetalle,this.Vista,this.Version,this.Ordenar});
    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'];
        Ordenar = json['Ordenar'];
        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,
        'Ordenar': Ordenar
    };

    getTypeName() => "DetalleJoinTabla";
    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;
}

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;
}

class DefinicionCuboRQ implements 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!)
    };

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

TypeContext _ctx = TypeContext(library: 'soluser_recaudo.sgsas.co', types: <String, TypeInfo> {
    'Tabla': TypeInfo(TypeOf.Class, create:() => Tabla()),
    'Columna': TypeInfo(TypeOf.Class, create:() => Columna()),
    'Frame': TypeInfo(TypeOf.Class, create:() => Frame()),
    'DefinicionTabla': TypeInfo(TypeOf.Class, create:() => DefinicionTabla()),
    'DetalleIndices': TypeInfo(TypeOf.Class, create:() => DetalleIndices()),
    '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>[]),
    'ValidationRule': TypeInfo(TypeOf.Class, create:() => ValidationRule()),
    'LookupGrid': TypeInfo(TypeOf.Class, create:() => LookupGrid()),
    'ColumnGrid': TypeInfo(TypeOf.Class, create:() => ColumnGrid()),
    'List<ValidationRule>': TypeInfo(TypeOf.Class, create:() => <ValidationRule>[]),
    'Map<String,dynamic?>': TypeInfo(TypeOf.Class, create:() => Map<String,dynamic?>()),
    'EditingGrid': TypeInfo(TypeOf.Class, create:() => EditingGrid()),
    'gridSummaryGroupItems': TypeInfo(TypeOf.Class, create:() => gridSummaryGroupItems()),
    'gridSummaryTotalItems': TypeInfo(TypeOf.Class, create:() => gridSummaryTotalItems()),
    'gridSummary': TypeInfo(TypeOf.Class, create:() => gridSummary()),
    'List<gridSummaryGroupItems>': TypeInfo(TypeOf.Class, create:() => <gridSummaryGroupItems>[]),
    'List<gridSummaryTotalItems>': TypeInfo(TypeOf.Class, create:() => <gridSummaryTotalItems>[]),
    'dxDataGrid': TypeInfo(TypeOf.Class, create:() => dxDataGrid()),
    'List<ColumnGrid>': TypeInfo(TypeOf.Class, create:() => <ColumnGrid>[]),
    'List<Columna>': TypeInfo(TypeOf.Class, create:() => <Columna>[]),
    'List<DetalleJoinTabla>': TypeInfo(TypeOf.Class, create:() => <DetalleJoinTabla>[]),
    'DetalleJoinTabla': TypeInfo(TypeOf.Class, create:() => DetalleJoinTabla()),
    'List<Frame>': TypeInfo(TypeOf.Class, create:() => <Frame>[]),
    'List<DetalleIndices>': TypeInfo(TypeOf.Class, create:() => <DetalleIndices>[]),
    'Vista': TypeInfo(TypeOf.Class, create:() => Vista()),
    'List<Map<String,dynamic>>': TypeInfo(TypeOf.Class, create:() => <Map<String,dynamic>>[]),
    'Map<String,dynamic>': TypeInfo(TypeOf.Class, create:() => Map<String,dynamic>()),
    'PivotGridConf': TypeInfo(TypeOf.Class, create:() => PivotGridConf()),
    'DefinicionCuboRS': TypeInfo(TypeOf.Class, create:() => DefinicionCuboRS()),
    'Lenguajes': TypeInfo(TypeOf.Enum, enumValues:Lenguajes.values),
    'VersionLookup': TypeInfo(TypeOf.Class, create:() => VersionLookup()),
    'DefinicionCuboRQ': TypeInfo(TypeOf.Class, create:() => DefinicionCuboRQ()),
    'List<VersionLookup>': TypeInfo(TypeOf.Class, create:() => <VersionLookup>[]),
});

Dart DefinicionCuboRQ DTOs

To override the Content-type in your clients, use the HTTP Accept Header, append the .jsv suffix or ?format=jsv

HTTP + JSV

The following are sample HTTP requests and responses. The placeholders shown need to be replaced with actual values.

POST /Utilidades/Consultas/Cubos/Definicion HTTP/1.1 
Host: soluser-recaudo.sgsas.co 
Accept: text/jsv
Content-Type: text/jsv
Content-Length: length

{
	IDVista: 0,
	IDPivot: 0,
	DatosLookups: False,
	Lenguaje: ES,
	VersionesLookupCliente: 
	[
		{
			CodLookup: 0,
			Version: String
		}
	]
}

HTTP/1.1 200 OK
Content-Type: text/jsv
Content-Length: length

{
	Tabla: 
	{
		Codigo: 0,
		Propietario: String,
		Tipo: String,
		Nombre: String,
		Alias: String,
		Descripcion: String,
		ParaReportes: String,
		CrearAlIniciar: String,
		CampoEmpresa: 0,
		CampoUnico: 0
	},
	Descripcion: String,
	Filtros: 
	[
		{
			CodigoTabla: 0,
			Codigo: 0,
			Nombre: String,
			Alias: String,
			Descripcion: String,
			TipoDato: String,
			ObligatorioFormas: String,
			Hint: String,
			Mayuscula: String,
			Tamano: 0,
			Escala: 0,
			Tipo: String,
			VlrDefecto: String,
			PermiteEditar: String,
			Orden: 0,
			Dinamico: String,
			ClaseControl: String,
			JoinLookup: 0,
			EsID: String,
			Mascara: String,
			MostrarEnLista: String,
			InfoAdicional: String,
			WHEREDefecto: String,
			TieneResumen: String,
			FormatoResumen: String,
			TipoResumen: String,
			PosicionResumen: String,
			ResumenEnGrupo: String,
			ResumenEnTotal: String,
			IndiceGrupo: 0
		}
	],
	Filas: 
	[
		{
			CodigoTabla: 0,
			Codigo: 0,
			Nombre: String,
			Alias: String,
			Descripcion: String,
			TipoDato: String,
			ObligatorioFormas: String,
			Hint: String,
			Mayuscula: String,
			Tamano: 0,
			Escala: 0,
			Tipo: String,
			VlrDefecto: String,
			PermiteEditar: String,
			Orden: 0,
			Dinamico: String,
			ClaseControl: String,
			JoinLookup: 0,
			EsID: String,
			Mascara: String,
			MostrarEnLista: String,
			InfoAdicional: String,
			WHEREDefecto: String,
			TieneResumen: String,
			FormatoResumen: String,
			TipoResumen: String,
			PosicionResumen: String,
			ResumenEnGrupo: String,
			ResumenEnTotal: String,
			IndiceGrupo: 0
		}
	],
	Columnas: 
	[
		{
			CodigoTabla: 0,
			Codigo: 0,
			Nombre: String,
			Alias: String,
			Descripcion: String,
			TipoDato: String,
			ObligatorioFormas: String,
			Hint: String,
			Mayuscula: String,
			Tamano: 0,
			Escala: 0,
			Tipo: String,
			VlrDefecto: String,
			PermiteEditar: String,
			Orden: 0,
			Dinamico: String,
			ClaseControl: String,
			JoinLookup: 0,
			EsID: String,
			Mascara: String,
			MostrarEnLista: String,
			InfoAdicional: String,
			WHEREDefecto: String,
			TieneResumen: String,
			FormatoResumen: String,
			TipoResumen: String,
			PosicionResumen: String,
			ResumenEnGrupo: String,
			ResumenEnTotal: String,
			IndiceGrupo: 0
		}
	],
	Calculos: 
	[
		{
			CodigoTabla: 0,
			Codigo: 0,
			Nombre: String,
			Alias: String,
			Descripcion: String,
			TipoDato: String,
			ObligatorioFormas: String,
			Hint: String,
			Mayuscula: String,
			Tamano: 0,
			Escala: 0,
			Tipo: String,
			VlrDefecto: String,
			PermiteEditar: String,
			Orden: 0,
			Dinamico: String,
			ClaseControl: String,
			JoinLookup: 0,
			EsID: String,
			Mascara: String,
			MostrarEnLista: String,
			InfoAdicional: String,
			WHEREDefecto: String,
			TieneResumen: String,
			FormatoResumen: String,
			TipoResumen: String,
			PosicionResumen: String,
			ResumenEnGrupo: String,
			ResumenEnTotal: String,
			IndiceGrupo: 0
		}
	],
	Parametros: 
	[
		{
			CodigoTabla: 0,
			Codigo: 0,
			Nombre: String,
			Alias: String,
			Descripcion: String,
			TipoDato: String,
			ObligatorioFormas: String,
			Hint: String,
			Mayuscula: String,
			Tamano: 0,
			Escala: 0,
			Tipo: String,
			VlrDefecto: String,
			PermiteEditar: String,
			Orden: 0,
			Dinamico: String,
			ClaseControl: String,
			JoinLookup: 0,
			EsID: String,
			Mascara: String,
			MostrarEnLista: String,
			InfoAdicional: String,
			WHEREDefecto: String,
			TieneResumen: String,
			FormatoResumen: String,
			TipoResumen: String,
			PosicionResumen: String,
			ResumenEnGrupo: String,
			ResumenEnTotal: String,
			IndiceGrupo: 0
		}
	],
	Lookups: 
	[
		{
			Codigo: 0,
			CampoAMostrar: String,
			Campos1: 
			[
				String
			],
			Campos2: 
			[
				String
			],
			Operadores: 
			[
				String
			],
			Datos: 
			[
				{
					String: {}
				}
			],
			CodigoTabla1: 0,
			SQL: String,
			TablaDetalle: 
			{
				Tabla: 
				{
					Codigo: 0,
					Propietario: String,
					Tipo: String,
					Nombre: String,
					Alias: String,
					Descripcion: String,
					ParaReportes: String,
					CrearAlIniciar: String,
					CampoEmpresa: 0,
					CampoUnico: 0
				},
				Columnas: 
				[
					{
						CodigoTabla: 0,
						Codigo: 0,
						Nombre: String,
						Alias: String,
						Descripcion: String,
						TipoDato: String,
						ObligatorioFormas: String,
						Hint: String,
						Mayuscula: String,
						Tamano: 0,
						Escala: 0,
						Tipo: String,
						VlrDefecto: String,
						PermiteEditar: String,
						Orden: 0,
						Dinamico: String,
						ClaseControl: String,
						JoinLookup: 0,
						EsID: String,
						Mascara: String,
						MostrarEnLista: String,
						InfoAdicional: String,
						WHEREDefecto: String,
						TieneResumen: String,
						FormatoResumen: String,
						TipoResumen: String,
						PosicionResumen: String,
						ResumenEnGrupo: String,
						ResumenEnTotal: String,
						IndiceGrupo: 0
					}
				],
				Lookups: 
				[
					{
						Codigo: 0,
						CampoAMostrar: String,
						Campos1: 
						[
							String
						],
						Campos2: 
						[
							String
						],
						Operadores: 
						[
							String
						],
						Datos: 
						[
							{
								String: {}
							}
						],
						CodigoTabla1: 0,
						SQL: String,
						TablaDetalle: 
						{
							Tabla: 
							{
								Codigo: 0,
								Propietario: String,
								Tipo: String,
								Nombre: String,
								Alias: String,
								Descripcion: String,
								ParaReportes: String,
								CrearAlIniciar: String,
								CampoEmpresa: 0,
								CampoUnico: 0
							},
							Columnas: 
							[
								{
									CodigoTabla: 0,
									Codigo: 0,
									Nombre: String,
									Alias: String,
									Descripcion: String,
									TipoDato: String,
									ObligatorioFormas: String,
									Hint: String,
									Mayuscula: String,
									Tamano: 0,
									Escala: 0,
									Tipo: String,
									VlrDefecto: String,
									PermiteEditar: String,
									Orden: 0,
									Dinamico: String,
									ClaseControl: String,
									JoinLookup: 0,
									EsID: String,
									Mascara: String,
									MostrarEnLista: String,
									InfoAdicional: String,
									WHEREDefecto: String,
									TieneResumen: String,
									FormatoResumen: String,
									TipoResumen: String,
									PosicionResumen: String,
									ResumenEnGrupo: String,
									ResumenEnTotal: String,
									IndiceGrupo: 0
								}
							],
							Lookups: 
							[
								{
									Codigo: 0,
									CampoAMostrar: String,
									Campos1: 
									[
										String
									],
									Campos2: 
									[
										String
									],
									Operadores: 
									[
										String
									],
									Datos: 
									[
										{
											String: {}
										}
									],
									CodigoTabla1: 0,
									SQL: String,
									TablaDetalle: 
									{
										Tabla: 
										{
											Codigo: 0,
											Propietario: String,
											Tipo: String,
											Nombre: String,
											Alias: String,
											Descripcion: String,
											ParaReportes: String,
											CrearAlIniciar: String,
											CampoEmpresa: 0,
											CampoUnico: 0
										},
										Columnas: 
										[
											{
												CodigoTabla: 0,
												Codigo: 0,
												Nombre: String,
												Alias: String,
												Descripcion: String,
												TipoDato: String,
												ObligatorioFormas: String,
												Hint: String,
												Mayuscula: String,
												Tamano: 0,
												Escala: 0,
												Tipo: String,
												VlrDefecto: String,
												PermiteEditar: String,
												Orden: 0,
												Dinamico: String,
												ClaseControl: String,
												JoinLookup: 0,
												EsID: String,
												Mascara: String,
												MostrarEnLista: String,
												InfoAdicional: String,
												WHEREDefecto: String,
												TieneResumen: String,
												FormatoResumen: String,
												TipoResumen: String,
												PosicionResumen: String,
												ResumenEnGrupo: String,
												ResumenEnTotal: String,
												IndiceGrupo: 0
											}
										],
										Frames: 
										[
											{
												Codigo: 0,
												SQL: String,
												Campos1: 
												[
													String
												],
												Campos2: 
												[
													String
												]
											}
										],
										DetalleLlave: 
										[
											{
												CodigoTabla: 0,
												NombreIndice: String,
												CodigoColumna: 0,
												TipoCalculo: String,
												Secuencia: String,
												NombreColumna: String
											}
										],
										Form: 
										{
											colCountByScreen: 
											{
												lg: 0,
												md: 0,
												sm: 0,
												xs: 0
											},
											labelLocation: String,
											readOnly: False,
											items: 
											[
												{
													itemType: simple,
													visibleIndex: 0
												}
											]
										},
										DataGrid: 
										{
											"columns": 
											[
												{
													"caption": "String",
													"dataField": "String",
													"dataType": "String",
													"visibleIndex": 0,
													"validationRules": 
													[
														{
															"type": "String",
															"message": "String"
														}
													],
													"lookup": 
													{
														"allowClearing": false,
														"displayExpr": "String",
														"valueExpr": "String"
													},
													"allowEditing": false,
													"encodeHtml": false,
													"editorOptions": 
													{
														"String": {}
													},
													"groupIndex": 0
												}
											],
											"showColumnLines": false,
											"showRowLines": false,
											"rowAlternationEnabled": false,
											"showBorders": false,
											"editing": 
											{
												"allowAdding": false,
												"allowDeleting": false,
												"allowUpdating": false,
												"mode": "String"
											},
											"summary": 
											{
												"groupItems": 
												[
													{
														"column": "String",
														"displayFormat": "String",
														"showInGroupFooter": false,
														"summaryType": "String"
													}
												],
												"totalItems": 
												[
													{
														"column": "String",
														"displayFormat": "String",
														"summaryType": "String"
													}
												]
											}
										}
									},
									Vista: 
									{
										Codigo: 0,
										CodigoBlob: 0,
										Nombre: String,
										Descripcion: String,
										SQL: String,
										CodigoTabla: 0,
										GuardarBinario: String,
										TipoConsulta: String,
										ExportacionDefault: String,
										TipoExportacion: String,
										ParametrosExportacion: 0,
										CodigoAyuda: String,
										EjecutarEnAdm: String,
										InfoAdicional: String,
										EjecMultiempresa: String
									},
									Version: String,
									Ordenar: String
								}
							],
							Frames: 
							[
								{
									Codigo: 0,
									SQL: String,
									Campos1: 
									[
										String
									],
									Campos2: 
									[
										String
									],
									TablaFrame: 
									{
										Tabla: 
										{
											Codigo: 0,
											Propietario: String,
											Tipo: String,
											Nombre: String,
											Alias: String,
											Descripcion: String,
											ParaReportes: String,
											CrearAlIniciar: String,
											CampoEmpresa: 0,
											CampoUnico: 0
										},
										Columnas: 
										[
											{
												CodigoTabla: 0,
												Codigo: 0,
												Nombre: String,
												Alias: String,
												Descripcion: String,
												TipoDato: String,
												ObligatorioFormas: String,
												Hint: String,
												Mayuscula: String,
												Tamano: 0,
												Escala: 0,
												Tipo: String,
												VlrDefecto: String,
												PermiteEditar: String,
												Orden: 0,
												Dinamico: String,
												ClaseControl: String,
												JoinLookup: 0,
												EsID: String,
												Mascara: String,
												MostrarEnLista: String,
												InfoAdicional: String,
												WHEREDefecto: String,
												TieneResumen: String,
												FormatoResumen: String,
												TipoResumen: String,
												PosicionResumen: String,
												ResumenEnGrupo: String,
												ResumenEnTotal: String,
												IndiceGrupo: 0
											}
										],
										Lookups: 
										[
											{
												Codigo: 0,
												CampoAMostrar: String,
												Campos1: 
												[
													String
												],
												Campos2: 
												[
													String
												],
												Operadores: 
												[
													String
												],
												Datos: 
												[
													{
														String: {}
													}
												],
												CodigoTabla1: 0,
												SQL: String,
												Vista: 
												{
													Codigo: 0,
													CodigoBlob: 0,
													Nombre: String,
													Descripcion: String,
													SQL: String,
													CodigoTabla: 0,
													GuardarBinario: String,
													TipoConsulta: String,
													ExportacionDefault: String,
													TipoExportacion: String,
													ParametrosExportacion: 0,
													CodigoAyuda: String,
													EjecutarEnAdm: String,
													InfoAdicional: String,
													EjecMultiempresa: String
												},
												Version: String,
												Ordenar: String
											}
										],
										Frames: 
										[
											{
												Codigo: 0,
												SQL: String,
												Campos1: 
												[
													String
												],
												Campos2: 
												[
													String
												]
											}
										],
										DetalleLlave: 
										[
											{
												CodigoTabla: 0,
												NombreIndice: String,
												CodigoColumna: 0,
												TipoCalculo: String,
												Secuencia: String,
												NombreColumna: String
											}
										],
										Form: 
										{
											colCountByScreen: 
											{
												lg: 0,
												md: 0,
												sm: 0,
												xs: 0
											},
											labelLocation: String,
											readOnly: False,
											items: 
											[
												{
													itemType: simple,
													visibleIndex: 0
												}
											]
										},
										DataGrid: 
										{
											"columns": 
											[
												{
													"caption": "String",
													"dataField": "String",
													"dataType": "String",
													"visibleIndex": 0,
													"validationRules": 
													[
														{
															"type": "String",
															"message": "String"
														}
													],
													"lookup": 
													{
														"allowClearing": false,
														"displayExpr": "String",
														"valueExpr": "String"
													},
													"allowEditing": false,
													"encodeHtml": false,
													"editorOptions": 
													{
														"String": {}
													},
													"groupIndex": 0
												}
											],
											"showColumnLines": false,
											"showRowLines": false,
											"rowAlternationEnabled": false,
											"showBorders": false,
											"editing": 
											{
												"allowAdding": false,
												"allowDeleting": false,
												"allowUpdating": false,
												"mode": "String"
											},
											"summary": 
											{
												"groupItems": 
												[
													{
														"column": "String",
														"displayFormat": "String",
														"showInGroupFooter": false,
														"summaryType": "String"
													}
												],
												"totalItems": 
												[
													{
														"column": "String",
														"displayFormat": "String",
														"summaryType": "String"
													}
												]
											}
										}
									}
								}
							],
							DetalleLlave: 
							[
								{
									CodigoTabla: 0,
									NombreIndice: String,
									CodigoColumna: 0,
									TipoCalculo: String,
									Secuencia: String,
									NombreColumna: String
								}
							],
							Form: 
							{
								colCountByScreen: 
								{
									lg: 0,
									md: 0,
									sm: 0,
									xs: 0
								},
								labelLocation: String,
								readOnly: False,
								items: 
								[
									{
										itemType: simple,
										visibleIndex: 0
									}
								]
							},
							DataGrid: 
							{
								"columns": 
								[
									{
										"caption": "String",
										"dataField": "String",
										"dataType": "String",
										"visibleIndex": 0,
										"validationRules": 
										[
											{
												"type": "String",
												"message": "String"
											}
										],
										"lookup": 
										{
											"allowClearing": false,
											"displayExpr": "String",
											"valueExpr": "String"
										},
										"allowEditing": false,
										"encodeHtml": false,
										"editorOptions": 
										{
											"String": {}
										},
										"groupIndex": 0
									}
								],
								"showColumnLines": false,
								"showRowLines": false,
								"rowAlternationEnabled": false,
								"showBorders": false,
								"editing": 
								{
									"allowAdding": false,
									"allowDeleting": false,
									"allowUpdating": false,
									"mode": "String"
								},
								"summary": 
								{
									"groupItems": 
									[
										{
											"column": "String",
											"displayFormat": "String",
											"showInGroupFooter": false,
											"summaryType": "String"
										}
									],
									"totalItems": 
									[
										{
											"column": "String",
											"displayFormat": "String",
											"summaryType": "String"
										}
									]
								}
							}
						},
						Vista: 
						{
							Codigo: 0,
							CodigoBlob: 0,
							Nombre: String,
							Descripcion: String,
							SQL: String,
							CodigoTabla: 0,
							GuardarBinario: String,
							TipoConsulta: String,
							ExportacionDefault: String,
							TipoExportacion: String,
							ParametrosExportacion: 0,
							CodigoAyuda: String,
							EjecutarEnAdm: String,
							InfoAdicional: String,
							EjecMultiempresa: String
						},
						Version: String,
						Ordenar: String
					}
				],
				Frames: 
				[
					{
						Codigo: 0,
						SQL: String,
						Campos1: 
						[
							String
						],
						Campos2: 
						[
							String
						],
						TablaFrame: 
						{
							Tabla: 
							{
								Codigo: 0,
								Propietario: String,
								Tipo: String,
								Nombre: String,
								Alias: String,
								Descripcion: String,
								ParaReportes: String,
								CrearAlIniciar: String,
								CampoEmpresa: 0,
								CampoUnico: 0
							},
							Columnas: 
							[
								{
									CodigoTabla: 0,
									Codigo: 0,
									Nombre: String,
									Alias: String,
									Descripcion: String,
									TipoDato: String,
									ObligatorioFormas: String,
									Hint: String,
									Mayuscula: String,
									Tamano: 0,
									Escala: 0,
									Tipo: String,
									VlrDefecto: String,
									PermiteEditar: String,
									Orden: 0,
									Dinamico: String,
									ClaseControl: String,
									JoinLookup: 0,
									EsID: String,
									Mascara: String,
									MostrarEnLista: String,
									InfoAdicional: String,
									WHEREDefecto: String,
									TieneResumen: String,
									FormatoResumen: String,
									TipoResumen: String,
									PosicionResumen: String,
									ResumenEnGrupo: String,
									ResumenEnTotal: String,
									IndiceGrupo: 0
								}
							],
							Lookups: 
							[
								{
									Codigo: 0,
									CampoAMostrar: String,
									Campos1: 
									[
										String
									],
									Campos2: 
									[
										String
									],
									Operadores: 
									[
										String
									],
									Datos: 
									[
										{
											String: {}
										}
									],
									CodigoTabla1: 0,
									SQL: String,
									TablaDetalle: 
									{
										Tabla: 
										{
											Codigo: 0,
											Propietario: String,
											Tipo: String,
											Nombre: String,
											Alias: String,
											Descripcion: String,
											ParaReportes: String,
											CrearAlIniciar: String,
											CampoEmpresa: 0,
											CampoUnico: 0
										},
										Columnas: 
										[
											{
												CodigoTabla: 0,
												Codigo: 0,
												Nombre: String,
												Alias: String,
												Descripcion: String,
												TipoDato: String,
												ObligatorioFormas: String,
												Hint: String,
												Mayuscula: String,
												Tamano: 0,
												Escala: 0,
												Tipo: String,
												VlrDefecto: String,
												PermiteEditar: String,
												Orden: 0,
												Dinamico: String,
												ClaseControl: String,
												JoinLookup: 0,
												EsID: String,
												Mascara: String,
												MostrarEnLista: String,
												InfoAdicional: String,
												WHEREDefecto: String,
												TieneResumen: String,
												FormatoResumen: String,
												TipoResumen: String,
												PosicionResumen: String,
												ResumenEnGrupo: String,
												ResumenEnTotal: String,
												IndiceGrupo: 0
											}
										],
										Lookups: 
										[
											{
												Codigo: 0,
												CampoAMostrar: String,
												Campos1: 
												[
													String
												],
												Campos2: 
												[
													String
												],
												Operadores: 
												[
													String
												],
												Datos: 
												[
													{
														String: {}
													}
												],
												CodigoTabla1: 0,
												SQL: String,
												Vista: 
												{
													Codigo: 0,
													CodigoBlob: 0,
													Nombre: String,
													Descripcion: String,
													SQL: String,
													CodigoTabla: 0,
													GuardarBinario: String,
													TipoConsulta: String,
													ExportacionDefault: String,
													TipoExportacion: String,
													ParametrosExportacion: 0,
													CodigoAyuda: String,
													EjecutarEnAdm: String,
													InfoAdicional: String,
													EjecMultiempresa: String
												},
												Version: String,
												Ordenar: String
											}
										],
										Frames: 
										[
											{
												Codigo: 0,
												SQL: String,
												Campos1: 
												[
													String
												],
												Campos2: 
												[
													String
												]
											}
										],
										DetalleLlave: 
										[
											{
												CodigoTabla: 0,
												NombreIndice: String,
												CodigoColumna: 0,
												TipoCalculo: String,
												Secuencia: String,
												NombreColumna: String
											}
										],
										Form: 
										{
											colCountByScreen: 
											{
												lg: 0,
												md: 0,
												sm: 0,
												xs: 0
											},
											labelLocation: String,
											readOnly: False,
											items: 
											[
												{
													itemType: simple,
													visibleIndex: 0
												}
											]
										},
										DataGrid: 
										{
											"columns": 
											[
												{
													"caption": "String",
													"dataField": "String",
													"dataType": "String",
													"visibleIndex": 0,
													"validationRules": 
													[
														{
															"type": "String",
															"message": "String"
														}
													],
													"lookup": 
													{
														"allowClearing": false,
														"displayExpr": "String",
														"valueExpr": "String"
													},
													"allowEditing": false,
													"encodeHtml": false,
													"editorOptions": 
													{
														"String": {}
													},
													"groupIndex": 0
												}
											],
											"showColumnLines": false,
											"showRowLines": false,
											"rowAlternationEnabled": false,
											"showBorders": false,
											"editing": 
											{
												"allowAdding": false,
												"allowDeleting": false,
												"allowUpdating": false,
												"mode": "String"
											},
											"summary": 
											{
												"groupItems": 
												[
													{
														"column": "String",
														"displayFormat": "String",
														"showInGroupFooter": false,
														"summaryType": "String"
													}
												],
												"totalItems": 
												[
													{
														"column": "String",
														"displayFormat": "String",
														"summaryType": "String"
													}
												]
											}
										}
									},
									Vista: 
									{
										Codigo: 0,
										CodigoBlob: 0,
										Nombre: String,
										Descripcion: String,
										SQL: String,
										CodigoTabla: 0,
										GuardarBinario: String,
										TipoConsulta: String,
										ExportacionDefault: String,
										TipoExportacion: String,
										ParametrosExportacion: 0,
										CodigoAyuda: String,
										EjecutarEnAdm: String,
										InfoAdicional: String,
										EjecMultiempresa: String
									},
									Version: String,
									Ordenar: String
								}
							],
							Frames: 
							[
								{
									Codigo: 0,
									SQL: String,
									Campos1: 
									[
										String
									],
									Campos2: 
									[
										String
									],
									TablaFrame: 
									{
										Tabla: 
										{
											Codigo: 0,
											Propietario: String,
											Tipo: String,
											Nombre: String,
											Alias: String,
											Descripcion: String,
											ParaReportes: String,
											CrearAlIniciar: String,
											CampoEmpresa: 0,
											CampoUnico: 0
										},
										Columnas: 
										[
											{
												CodigoTabla: 0,
												Codigo: 0,
												Nombre: String,
												Alias: String,
												Descripcion: String,
												TipoDato: String,
												ObligatorioFormas: String,
												Hint: String,
												Mayuscula: String,
												Tamano: 0,
												Escala: 0,
												Tipo: String,
												VlrDefecto: String,
												PermiteEditar: String,
												Orden: 0,
												Dinamico: String,
												ClaseControl: String,
												JoinLookup: 0,
												EsID: String,
												Mascara: String,
												MostrarEnLista: String,
												InfoAdicional: String,
												WHEREDefecto: String,
												TieneResumen: String,
												FormatoResumen: String,
												TipoResumen: String,
												PosicionResumen: String,
												ResumenEnGrupo: String,
												ResumenEnTotal: String,
												IndiceGrupo: 0
											}
										],
										Lookups: 
										[
											{
												Codigo: 0,
												CampoAMostrar: String,
												Campos1: 
												[
													String
												],
												Campos2: 
												[
													String
												],
												Operadores: 
												[
													String
												],
												Datos: 
												[
													{
														String: {}
													}
												],
												CodigoTabla1: 0,
												SQL: String,
												Vista: 
												{
													Codigo: 0,
													CodigoBlob: 0,
													Nombre: String,
													Descripcion: String,
													SQL: String,
													CodigoTabla: 0,
													GuardarBinario: String,
													TipoConsulta: String,
													ExportacionDefault: String,
													TipoExportacion: String,
													ParametrosExportacion: 0,
													CodigoAyuda: String,
													EjecutarEnAdm: String,
													InfoAdicional: String,
													EjecMultiempresa: String
												},
												Version: String,
												Ordenar: String
											}
										],
										Frames: 
										[
											{
												Codigo: 0,
												SQL: String,
												Campos1: 
												[
													String
												],
												Campos2: 
												[
													String
												]
											}
										],
										DetalleLlave: 
										[
											{
												CodigoTabla: 0,
												NombreIndice: String,
												CodigoColumna: 0,
												TipoCalculo: String,
												Secuencia: String,
												NombreColumna: String
											}
										],
										Form: 
										{
											colCountByScreen: 
											{
												lg: 0,
												md: 0,
												sm: 0,
												xs: 0
											},
											labelLocation: String,
											readOnly: False,
											items: 
											[
												{
													itemType: simple,
													visibleIndex: 0
												}
											]
										},
										DataGrid: 
										{
											"columns": 
											[
												{
													"caption": "String",
													"dataField": "String",
													"dataType": "String",
													"visibleIndex": 0,
													"validationRules": 
													[
														{
															"type": "String",
															"message": "String"
														}
													],
													"lookup": 
													{
														"allowClearing": false,
														"displayExpr": "String",
														"valueExpr": "String"
													},
													"allowEditing": false,
													"encodeHtml": false,
													"editorOptions": 
													{
														"String": {}
													},
													"groupIndex": 0
												}
											],
											"showColumnLines": false,
											"showRowLines": false,
											"rowAlternationEnabled": false,
											"showBorders": false,
											"editing": 
											{
												"allowAdding": false,
												"allowDeleting": false,
												"allowUpdating": false,
												"mode": "String"
											},
											"summary": 
											{
												"groupItems": 
												[
													{
														"column": "String",
														"displayFormat": "String",
														"showInGroupFooter": false,
														"summaryType": "String"
													}
												],
												"totalItems": 
												[
													{
														"column": "String",
														"displayFormat": "String",
														"summaryType": "String"
													}
												]
											}
										}
									}
								}
							],
							DetalleLlave: 
							[
								{
									CodigoTabla: 0,
									NombreIndice: String,
									CodigoColumna: 0,
									TipoCalculo: String,
									Secuencia: String,
									NombreColumna: String
								}
							],
							Form: 
							{
								colCountByScreen: 
								{
									lg: 0,
									md: 0,
									sm: 0,
									xs: 0
								},
								labelLocation: String,
								readOnly: False,
								items: 
								[
									{
										itemType: simple,
										visibleIndex: 0
									}
								]
							},
							DataGrid: 
							{
								"columns": 
								[
									{
										"caption": "String",
										"dataField": "String",
										"dataType": "String",
										"visibleIndex": 0,
										"validationRules": 
										[
											{
												"type": "String",
												"message": "String"
											}
										],
										"lookup": 
										{
											"allowClearing": false,
											"displayExpr": "String",
											"valueExpr": "String"
										},
										"allowEditing": false,
										"encodeHtml": false,
										"editorOptions": 
										{
											"String": {}
										},
										"groupIndex": 0
									}
								],
								"showColumnLines": false,
								"showRowLines": false,
								"rowAlternationEnabled": false,
								"showBorders": false,
								"editing": 
								{
									"allowAdding": false,
									"allowDeleting": false,
									"allowUpdating": false,
									"mode": "String"
								},
								"summary": 
								{
									"groupItems": 
									[
										{
											"column": "String",
											"displayFormat": "String",
											"showInGroupFooter": false,
											"summaryType": "String"
										}
									],
									"totalItems": 
									[
										{
											"column": "String",
											"displayFormat": "String",
											"summaryType": "String"
										}
									]
								}
							}
						}
					}
				],
				DetalleLlave: 
				[
					{
						CodigoTabla: 0,
						NombreIndice: String,
						CodigoColumna: 0,
						TipoCalculo: String,
						Secuencia: String,
						NombreColumna: String
					}
				],
				Form: 
				{
					colCountByScreen: 
					{
						lg: 0,
						md: 0,
						sm: 0,
						xs: 0
					},
					labelLocation: String,
					readOnly: False,
					items: 
					[
						{
							itemType: simple,
							visibleIndex: 0
						}
					]
				},
				DataGrid: 
				{
					"columns": 
					[
						{
							"caption": "String",
							"dataField": "String",
							"dataType": "String",
							"visibleIndex": 0,
							"validationRules": 
							[
								{
									"type": "String",
									"message": "String"
								}
							],
							"lookup": 
							{
								"allowClearing": false,
								"displayExpr": "String",
								"valueExpr": "String"
							},
							"allowEditing": false,
							"encodeHtml": false,
							"editorOptions": 
							{
								"String": {}
							},
							"groupIndex": 0
						}
					],
					"showColumnLines": false,
					"showRowLines": false,
					"rowAlternationEnabled": false,
					"showBorders": false,
					"editing": 
					{
						"allowAdding": false,
						"allowDeleting": false,
						"allowUpdating": false,
						"mode": "String"
					},
					"summary": 
					{
						"groupItems": 
						[
							{
								"column": "String",
								"displayFormat": "String",
								"showInGroupFooter": false,
								"summaryType": "String"
							}
						],
						"totalItems": 
						[
							{
								"column": "String",
								"displayFormat": "String",
								"summaryType": "String"
							}
						]
					}
				}
			},
			Vista: 
			{
				Codigo: 0,
				CodigoBlob: 0,
				Nombre: String,
				Descripcion: String,
				SQL: String,
				CodigoTabla: 0,
				GuardarBinario: String,
				TipoConsulta: String,
				ExportacionDefault: String,
				TipoExportacion: String,
				ParametrosExportacion: 0,
				CodigoAyuda: String,
				EjecutarEnAdm: String,
				InfoAdicional: String,
				EjecMultiempresa: String
			},
			Version: String,
			Ordenar: String
		}
	],
	dxPivotGrid: 
	{
		String: {}
	},
	dxChart: 
	{
		String: {}
	},
	FormaParametros: 
	{
		colCountByScreen: 
		{
			lg: 0,
			md: 0,
			sm: 0,
			xs: 0
		},
		labelLocation: String,
		readOnly: False,
		items: 
		[
			{
				itemType: simple,
				visibleIndex: 0
			}
		]
	},
	PivotGridConf: 
	{
		Codigo: 0,
		Nombre: String,
		CrearChart: String,
		Configuration: String,
		Chart: String,
		Observaciones: String,
		IDVista: 0,
		Usuario: String
	},
	Error: String
}