/* Options:
Date: 2025-06-07 19:07:30
Version: 8.12
Tip: To override a DTO option, remove "//" prefix before updating
BaseUrl: https://soluser-recaudo.sgsas.co

//GlobalNamespace: 
//AddServiceStackTypes: True
//AddResponseStatus: False
//AddImplicitVersion: 
//AddDescriptionAsComments: True
IncludeTypes: FormasDinamicasRQ.*
//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 Forma implements IConvertible
{
    // @DataMember
    double? Codigo;

    // @DataMember
    String? Nombre;

    // @DataMember
    String? Descripcion;

    // @DataMember
    int? CodigoTabla;

    // @DataMember
    int? CodigoConsulta;

    // @DataMember
    int? CodigoAyuda;

    // @DataMember
    String? Tipo;

    // @DataMember
    int? Alto;

    // @DataMember
    int? Ancho;

    // @DataMember
    String? Redimensionar;

    // @DataMember
    int? BlobLayout;

    // @DataMember
    String? SoloLectura;

    // @DataMember
    String? LookupsConCodigo;

    // @DataMember
    int? BlobLayoutJson;

    // @DataMember
    String? InfoAdicional;

    // @DataMember
    String? WHEREAdicional;

    // @DataMember
    String? ProcedimientoGuardar;

    // @DataMember
    String? WSGuardar;

    // @DataMember
    String? WSValidacion;

    // @DataMember
    String? ProcedimientoValidaciones;

    // @DataMember
    String? LinkAyuda;

    Forma({this.Codigo,this.Nombre,this.Descripcion,this.CodigoTabla,this.CodigoConsulta,this.CodigoAyuda,this.Tipo,this.Alto,this.Ancho,this.Redimensionar,this.BlobLayout,this.SoloLectura,this.LookupsConCodigo,this.BlobLayoutJson,this.InfoAdicional,this.WHEREAdicional,this.ProcedimientoGuardar,this.WSGuardar,this.WSValidacion,this.ProcedimientoValidaciones,this.LinkAyuda});
    Forma.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Codigo = JsonConverters.toDouble(json['Codigo']);
        Nombre = json['Nombre'];
        Descripcion = json['Descripcion'];
        CodigoTabla = json['CodigoTabla'];
        CodigoConsulta = json['CodigoConsulta'];
        CodigoAyuda = json['CodigoAyuda'];
        Tipo = json['Tipo'];
        Alto = json['Alto'];
        Ancho = json['Ancho'];
        Redimensionar = json['Redimensionar'];
        BlobLayout = json['BlobLayout'];
        SoloLectura = json['SoloLectura'];
        LookupsConCodigo = json['LookupsConCodigo'];
        BlobLayoutJson = json['BlobLayoutJson'];
        InfoAdicional = json['InfoAdicional'];
        WHEREAdicional = json['WHEREAdicional'];
        ProcedimientoGuardar = json['ProcedimientoGuardar'];
        WSGuardar = json['WSGuardar'];
        WSValidacion = json['WSValidacion'];
        ProcedimientoValidaciones = json['ProcedimientoValidaciones'];
        LinkAyuda = json['LinkAyuda'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'Codigo': Codigo,
        'Nombre': Nombre,
        'Descripcion': Descripcion,
        'CodigoTabla': CodigoTabla,
        'CodigoConsulta': CodigoConsulta,
        'CodigoAyuda': CodigoAyuda,
        'Tipo': Tipo,
        'Alto': Alto,
        'Ancho': Ancho,
        'Redimensionar': Redimensionar,
        'BlobLayout': BlobLayout,
        'SoloLectura': SoloLectura,
        'LookupsConCodigo': LookupsConCodigo,
        'BlobLayoutJson': BlobLayoutJson,
        'InfoAdicional': InfoAdicional,
        'WHEREAdicional': WHEREAdicional,
        'ProcedimientoGuardar': ProcedimientoGuardar,
        'WSGuardar': WSGuardar,
        'WSValidacion': WSValidacion,
        'ProcedimientoValidaciones': ProcedimientoValidaciones,
        'LinkAyuda': LinkAyuda
    };

    getTypeName() => "Forma";
    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 DetalleForma implements IConvertible
{
    double? Codigo;
    List<String>? Campos1;
    List<String>? Campos2;
    List<String>? Operadores;
    DefinicionTabla? TablaDetalle;
    String? TipoCaptura;
    int? FormaCaptura;
    int? CodigoArchivo;
    int? TablaArchivo;

    DetalleForma({this.Codigo,this.Campos1,this.Campos2,this.Operadores,this.TablaDetalle,this.TipoCaptura,this.FormaCaptura,this.CodigoArchivo,this.TablaArchivo});
    DetalleForma.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Codigo = JsonConverters.toDouble(json['Codigo']);
        Campos1 = JsonConverters.fromJson(json['Campos1'],'List<String>',context!);
        Campos2 = JsonConverters.fromJson(json['Campos2'],'List<String>',context!);
        Operadores = JsonConverters.fromJson(json['Operadores'],'List<String>',context!);
        TablaDetalle = JsonConverters.fromJson(json['TablaDetalle'],'DefinicionTabla',context!);
        TipoCaptura = json['TipoCaptura'];
        FormaCaptura = json['FormaCaptura'];
        CodigoArchivo = json['CodigoArchivo'];
        TablaArchivo = json['TablaArchivo'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'Codigo': Codigo,
        'Campos1': JsonConverters.toJson(Campos1,'List<String>',context!),
        'Campos2': JsonConverters.toJson(Campos2,'List<String>',context!),
        'Operadores': JsonConverters.toJson(Operadores,'List<String>',context!),
        'TablaDetalle': JsonConverters.toJson(TablaDetalle,'DefinicionTabla',context!),
        'TipoCaptura': TipoCaptura,
        'FormaCaptura': FormaCaptura,
        'CodigoArchivo': CodigoArchivo,
        'TablaArchivo': TablaArchivo
    };

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

class FormasDinamicasRS implements IConvertible
{
    Forma? Forma;
    DefinicionTabla? Maestro;
    List<DetalleForma>? Detalles;

    FormasDinamicasRS({this.Forma,this.Maestro,this.Detalles});
    FormasDinamicasRS.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Forma = JsonConverters.fromJson(json['Forma'],'Forma',context!);
        Maestro = JsonConverters.fromJson(json['Maestro'],'DefinicionTabla',context!);
        Detalles = JsonConverters.fromJson(json['Detalles'],'List<DetalleForma>',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'Forma': JsonConverters.toJson(Forma,'Forma',context!),
        'Maestro': JsonConverters.toJson(Maestro,'DefinicionTabla',context!),
        'Detalles': JsonConverters.toJson(Detalles,'List<DetalleForma>',context!)
    };

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

// @Route("/Utilidades/Formas/Definicion")
class FormasDinamicasRQ implements IReturn<FormasDinamicasRS>, IConvertible, IPost
{
    int? Codigo;
    bool? DatosLookups;
    Lenguajes? Lenguaje;
    List<VersionLookup>? VersionesLookupCliente;

    FormasDinamicasRQ({this.Codigo,this.DatosLookups,this.Lenguaje,this.VersionesLookupCliente});
    FormasDinamicasRQ.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

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

    createResponse() => FormasDinamicasRS();
    getResponseTypeName() => "FormasDinamicasRS";
    getTypeName() => "FormasDinamicasRQ";
    TypeContext? context = _ctx;
}

TypeContext _ctx = TypeContext(library: 'soluser_recaudo.sgsas.co', types: <String, TypeInfo> {
    'Lenguajes': TypeInfo(TypeOf.Enum, enumValues:Lenguajes.values),
    'VersionLookup': TypeInfo(TypeOf.Class, create:() => VersionLookup()),
    'Forma': TypeInfo(TypeOf.Class, create:() => Forma()),
    'DefinicionTabla': TypeInfo(TypeOf.Class, create:() => DefinicionTabla()),
    'Tabla': TypeInfo(TypeOf.Class, create:() => Tabla()),
    'List<Columna>': TypeInfo(TypeOf.Class, create:() => <Columna>[]),
    '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>[]),
    'Frame': TypeInfo(TypeOf.Class, create:() => Frame()),
    'List<DetalleIndices>': TypeInfo(TypeOf.Class, create:() => <DetalleIndices>[]),
    'DetalleIndices': TypeInfo(TypeOf.Class, create:() => DetalleIndices()),
    'dxForm': TypeInfo(TypeOf.Class, create:() => dxForm()),
    'dxDataGrid': TypeInfo(TypeOf.Class, create:() => dxDataGrid()),
    'DetalleForma': TypeInfo(TypeOf.Class, create:() => DetalleForma()),
    'FormasDinamicasRS': TypeInfo(TypeOf.Class, create:() => FormasDinamicasRS()),
    'List<DetalleForma>': TypeInfo(TypeOf.Class, create:() => <DetalleForma>[]),
    'FormasDinamicasRQ': TypeInfo(TypeOf.Class, create:() => FormasDinamicasRQ()),
    'List<VersionLookup>': TypeInfo(TypeOf.Class, create:() => <VersionLookup>[]),
});