/* Options:
Date: 2025-06-07 19:37:12
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: DefinicionProcedimientoRQ.*
//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 IdentificadoresFunciones implements IConvertible
{
    // @DataMember
    String? AliasFuncion;

    // @DataMember
    String? NombreFuncion;

    // @DataMember
    String? Descripcion;

    // @DataMember
    String? TipoRespuesta;

    // @DataMember
    String? Background;

    // @DataMember
    String? UsuarioCreo;

    // @DataMember
    DateTime? FechaCreacion;

    // @DataMember
    int? Consecutivo;

    // @DataMember
    String? TipoExport;

    // @DataMember
    String? Ayuda;

    // @DataMember
    String? Endpoint;

    // @DataMember
    String? ConsumeAPI;

    // @DataMember
    String? APIRest;

    // @DataMember
    String? PropiedadRest;

    IdentificadoresFunciones({this.AliasFuncion,this.NombreFuncion,this.Descripcion,this.TipoRespuesta,this.Background,this.UsuarioCreo,this.FechaCreacion,this.Consecutivo,this.TipoExport,this.Ayuda,this.Endpoint,this.ConsumeAPI,this.APIRest,this.PropiedadRest});
    IdentificadoresFunciones.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        AliasFuncion = json['AliasFuncion'];
        NombreFuncion = json['NombreFuncion'];
        Descripcion = json['Descripcion'];
        TipoRespuesta = json['TipoRespuesta'];
        Background = json['Background'];
        UsuarioCreo = json['UsuarioCreo'];
        FechaCreacion = JsonConverters.fromJson(json['FechaCreacion'],'DateTime',context!);
        Consecutivo = json['Consecutivo'];
        TipoExport = json['TipoExport'];
        Ayuda = json['Ayuda'];
        Endpoint = json['Endpoint'];
        ConsumeAPI = json['ConsumeAPI'];
        APIRest = json['APIRest'];
        PropiedadRest = json['PropiedadRest'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'AliasFuncion': AliasFuncion,
        'NombreFuncion': NombreFuncion,
        'Descripcion': Descripcion,
        'TipoRespuesta': TipoRespuesta,
        'Background': Background,
        'UsuarioCreo': UsuarioCreo,
        'FechaCreacion': JsonConverters.toJson(FechaCreacion,'DateTime',context!),
        'Consecutivo': Consecutivo,
        'TipoExport': TipoExport,
        'Ayuda': Ayuda,
        'Endpoint': Endpoint,
        'ConsumeAPI': ConsumeAPI,
        'APIRest': APIRest,
        'PropiedadRest': PropiedadRest
    };

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

class DefinicionParametro implements IConvertible
{
    String? Direccion;
    double? IdVista;
    String? TipoDato;
    String? NombreParametro;
    String? Alias;
    String? Ayuda;
    List<Map<String,dynamic>>? DatosLookup;
    String? CampoTexto;
    String? CampoValor;
    String? Version;
    bool? Obligatorio;
    String? ValorDefecto;
    bool? Visible;

    DefinicionParametro({this.Direccion,this.IdVista,this.TipoDato,this.NombreParametro,this.Alias,this.Ayuda,this.DatosLookup,this.CampoTexto,this.CampoValor,this.Version,this.Obligatorio,this.ValorDefecto,this.Visible});
    DefinicionParametro.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Direccion = json['Direccion'];
        IdVista = JsonConverters.toDouble(json['IdVista']);
        TipoDato = json['TipoDato'];
        NombreParametro = json['NombreParametro'];
        Alias = json['Alias'];
        Ayuda = json['Ayuda'];
        DatosLookup = JsonConverters.fromJson(json['DatosLookup'],'List<Map<String,dynamic>>',context!);
        CampoTexto = json['CampoTexto'];
        CampoValor = json['CampoValor'];
        Version = json['Version'];
        Obligatorio = json['Obligatorio'];
        ValorDefecto = json['ValorDefecto'];
        Visible = json['Visible'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'Direccion': Direccion,
        'IdVista': IdVista,
        'TipoDato': TipoDato,
        'NombreParametro': NombreParametro,
        'Alias': Alias,
        'Ayuda': Ayuda,
        'DatosLookup': JsonConverters.toJson(DatosLookup,'List<Map<String,dynamic>>',context!),
        'CampoTexto': CampoTexto,
        'CampoValor': CampoValor,
        'Version': Version,
        'Obligatorio': Obligatorio,
        'ValorDefecto': ValorDefecto,
        'Visible': Visible
    };

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

// @DataContract
class PermisosFunciones implements IConvertible
{
    // @DataMember
    double? CodigoSistema;

    // @DataMember
    double? CodigoEmpresa;

    // @DataMember
    String? AliasFuncion;

    // @DataMember
    String? Usuario;

    // @DataMember
    String? UsuarioCreo;

    // @DataMember
    DateTime? FechaCreacion;

    // @DataMember
    String? IP;

    PermisosFunciones({this.CodigoSistema,this.CodigoEmpresa,this.AliasFuncion,this.Usuario,this.UsuarioCreo,this.FechaCreacion,this.IP});
    PermisosFunciones.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        CodigoSistema = JsonConverters.toDouble(json['CodigoSistema']);
        CodigoEmpresa = JsonConverters.toDouble(json['CodigoEmpresa']);
        AliasFuncion = json['AliasFuncion'];
        Usuario = json['Usuario'];
        UsuarioCreo = json['UsuarioCreo'];
        FechaCreacion = JsonConverters.fromJson(json['FechaCreacion'],'DateTime',context!);
        IP = json['IP'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'CodigoSistema': CodigoSistema,
        'CodigoEmpresa': CodigoEmpresa,
        'AliasFuncion': AliasFuncion,
        'Usuario': Usuario,
        'UsuarioCreo': UsuarioCreo,
        'FechaCreacion': JsonConverters.toJson(FechaCreacion,'DateTime',context!),
        'IP': IP
    };

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

class UltimoEstado implements IConvertible
{
    double? CodigoEjecucion;
    String? Estado;

    UltimoEstado({this.CodigoEjecucion,this.Estado});
    UltimoEstado.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

    Map<String, dynamic> toJson() => {
        'CodigoEjecucion': CodigoEjecucion,
        'Estado': Estado
    };

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

class DefinicionProcedimientoRS implements IConvertible
{
    IdentificadoresFunciones? Procedimiento;
    List<DefinicionParametro>? Parametros;
    List<PermisosFunciones>? Permisos;
    UltimoEstado? UltimoEstado;
    String? Error;

    DefinicionProcedimientoRS({this.Procedimiento,this.Parametros,this.Permisos,this.UltimoEstado,this.Error});
    DefinicionProcedimientoRS.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Procedimiento = JsonConverters.fromJson(json['Procedimiento'],'IdentificadoresFunciones',context!);
        Parametros = JsonConverters.fromJson(json['Parametros'],'List<DefinicionParametro>',context!);
        Permisos = JsonConverters.fromJson(json['Permisos'],'List<PermisosFunciones>',context!);
        UltimoEstado = JsonConverters.fromJson(json['UltimoEstado'],'UltimoEstado',context!);
        Error = json['Error'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'Procedimiento': JsonConverters.toJson(Procedimiento,'IdentificadoresFunciones',context!),
        'Parametros': JsonConverters.toJson(Parametros,'List<DefinicionParametro>',context!),
        'Permisos': JsonConverters.toJson(Permisos,'List<PermisosFunciones>',context!),
        'UltimoEstado': JsonConverters.toJson(UltimoEstado,'UltimoEstado',context!),
        'Error': Error
    };

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

// @Route("/Utilidades/Procedimientos/Definicion")
class DefinicionProcedimientoRQ implements IReturn<DefinicionProcedimientoRS>, IConvertible, IPost
{
    int? Consecutivo;
    List<VersionLookup>? VersionesLookupCliente;
    bool? DatosLookups;
    Lenguajes? Lenguaje;

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

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

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

    createResponse() => DefinicionProcedimientoRS();
    getResponseTypeName() => "DefinicionProcedimientoRS";
    getTypeName() => "DefinicionProcedimientoRQ";
    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()),
    'IdentificadoresFunciones': TypeInfo(TypeOf.Class, create:() => IdentificadoresFunciones()),
    'DefinicionParametro': TypeInfo(TypeOf.Class, create:() => DefinicionParametro()),
    'List<Map<String,dynamic>>': TypeInfo(TypeOf.Class, create:() => <Map<String,dynamic>>[]),
    'Map<String,dynamic>': TypeInfo(TypeOf.Class, create:() => Map<String,dynamic>()),
    'PermisosFunciones': TypeInfo(TypeOf.Class, create:() => PermisosFunciones()),
    'UltimoEstado': TypeInfo(TypeOf.Class, create:() => UltimoEstado()),
    'DefinicionProcedimientoRS': TypeInfo(TypeOf.Class, create:() => DefinicionProcedimientoRS()),
    'List<DefinicionParametro>': TypeInfo(TypeOf.Class, create:() => <DefinicionParametro>[]),
    'List<PermisosFunciones>': TypeInfo(TypeOf.Class, create:() => <PermisosFunciones>[]),
    'DefinicionProcedimientoRQ': TypeInfo(TypeOf.Class, create:() => DefinicionProcedimientoRQ()),
    'List<VersionLookup>': TypeInfo(TypeOf.Class, create:() => <VersionLookup>[]),
});