/* Options:
Date: 2026-06-15 07:10:45
Version: 6.02
Tip: To override a DTO option, remove "//" prefix before updating
BaseUrl: https://api.backgroundchecklatam.com

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

import 'package:servicestack/servicestack.dart';

enum SearchCountrys
{
    Colombia,
    COL,
    Mexico,
    MEX,
    Chile,
    CHL,
    Brasil,
    BRA,
    Panama,
    PAN,
    Dominicana,
    DOM,
    CostaRica,
    CRI,
    Argentina,
    ARG,
    Ecuador,
    ECU,
    Peru,
    PER,
    ElSalvador,
    SLV,
    Guatemala,
    GTM,
    Honduras,
    HND,
    Venezuela,
    VEN,
    ALL,
    AFG,
    ALB,
    DZA,
    AND,
    AGO,
    ATG,
    ARM,
    AUS,
    AUT,
    AZE,
    BHS,
    BHR,
    BGD,
    BRB,
    BLR,
    BEL,
    BLZ,
    BEN,
    BTN,
    BOL,
    BIH,
    BWA,
    BRN,
    BGR,
    BFA,
    BDI,
    CPV,
    KHM,
    CMR,
    CAN,
    CAF,
    TCD,
    CHN,
    COM,
    COG,
    CIV,
    HRV,
    CUB,
    CYP,
    CZE,
    DNK,
    DJI,
    DMA,
    TLS,
    EGY,
    GNQ,
    ERI,
    EST,
    ETH,
    FJI,
    FIN,
    FRA,
    GAB,
    GMB,
    GEO,
    DEU,
    GHA,
    GRC,
    GRD,
    GIN,
    GNB,
    GUY,
    HTI,
    HUN,
    ISL,
    IND,
    IDN,
    IRN,
    IRQ,
    IRL,
    ISR,
    ITA,
    JAM,
    JPN,
    JOR,
    KAZ,
    KEN,
    KIR,
    PRK,
    KOR,
    KWT,
    KGZ,
    LAO,
    LVA,
    LBN,
    LSO,
    LBR,
    LBY,
    LIE,
    LTU,
    LUX,
    MDG,
    MWI,
    MYS,
    MDV,
    MLI,
    MLT,
    MHL,
    MRT,
    MUS,
    FSM,
    MDA,
    MCO,
    MNG,
    MNE,
    MAR,
    MOZ,
    MMR,
    NAM,
    NRU,
    NPL,
    NLD,
    NZL,
    NIC,
    NER,
    NGA,
    MKD,
    NOR,
    OMN,
    PAK,
    PLW,
    PNG,
    PRY,
    PHL,
    POL,
    PRT,
    QAT,
    ROU,
    RUS,
    RWA,
    KNA,
    LCA,
    VCT,
    WSM,
    SMR,
    STP,
    SAU,
    SEN,
    SRB,
    SYC,
    SLE,
    SGP,
    SVK,
    SVN,
    SLB,
    SOM,
    ZAF,
    SSD,
    ESP,
    LKA,
    SDN,
    SUR,
    SWZ,
    SWE,
    CHE,
    SYR,
    TWN,
    TJK,
    TZA,
    THA,
    TGO,
    TON,
    TTO,
    TUN,
    TUR,
    TKM,
    TUV,
    UGA,
    UKR,
    ARE,
    GBR,
    USA,
    URY,
    UZB,
    VUT,
    VNM,
    YEM,
    ZMB,
    ZWE,
}

enum QueryStatus
{
    ok,
    fail,
}

enum Severity
{
    Success,
    Info,
    Warning,
    Error,
}

class Error implements IConvertible
{
    int? Code;
    String? Message;
    String? Source;
    Severity? ErrorSeverity;

    Error({this.Code,this.Message,this.Source,this.ErrorSeverity});
    Error.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Code = json['Code'];
        Message = json['Message'];
        Source = json['Source'];
        ErrorSeverity = JsonConverters.fromJson(json['ErrorSeverity'],'Severity',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'Code': Code,
        'Message': Message,
        'Source': Source,
        'ErrorSeverity': JsonConverters.toJson(ErrorSeverity,'Severity',context!)
    };

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

class DataValue implements IConvertible
{
    int? Order;
    String? Name;
    String? Description;
    String? Tooltip;
    String? Value;
    String? DataType;

    DataValue({this.Order,this.Name,this.Description,this.Tooltip,this.Value,this.DataType});
    DataValue.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Order = json['Order'];
        Name = json['Name'];
        Description = json['Description'];
        Tooltip = json['Tooltip'];
        Value = json['Value'];
        DataType = json['DataType'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'Order': Order,
        'Name': Name,
        'Description': Description,
        'Tooltip': Tooltip,
        'Value': Value,
        'DataType': DataType
    };

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

class FilterEvaluationResults implements IConvertible
{
    bool? Matched;
    String? MatchedRule;
    String? MatchedExcerpt;

    FilterEvaluationResults({this.Matched,this.MatchedRule,this.MatchedExcerpt});
    FilterEvaluationResults.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Matched = json['Matched'];
        MatchedRule = json['MatchedRule'];
        MatchedExcerpt = json['MatchedExcerpt'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'Matched': Matched,
        'MatchedRule': MatchedRule,
        'MatchedExcerpt': MatchedExcerpt
    };

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

class Record implements IConvertible
{
    List<DataValue>? Values;
    FilterEvaluationResults? FilterEvaluationResult;

    Record({this.Values,this.FilterEvaluationResult});
    Record.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Values = JsonConverters.fromJson(json['Values'],'List<DataValue>',context!);
        FilterEvaluationResult = JsonConverters.fromJson(json['FilterEvaluationResult'],'FilterEvaluationResults',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'Values': JsonConverters.toJson(Values,'List<DataValue>',context!),
        'FilterEvaluationResult': JsonConverters.toJson(FilterEvaluationResult,'FilterEvaluationResults',context!)
    };

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

class DataGroup implements IConvertible
{
    int? Id;
    String? Name;
    String? Description;
    List<DataGroup>? SubGroups;
    List<Record>? Records;
    List<Error>? Errors;
    int? ParentGroupID;
    bool? ValidationGroup;
    int? RiskPointsFound;
    int? RiskPointsNotFound;
    String? NotFoundMessage;
    bool? ConCoincidencias;
    int? RealPoints;

    DataGroup({this.Id,this.Name,this.Description,this.SubGroups,this.Records,this.Errors,this.ParentGroupID,this.ValidationGroup,this.RiskPointsFound,this.RiskPointsNotFound,this.NotFoundMessage,this.ConCoincidencias,this.RealPoints});
    DataGroup.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Id = json['Id'];
        Name = json['Name'];
        Description = json['Description'];
        SubGroups = JsonConverters.fromJson(json['SubGroups'],'List<DataGroup>',context!);
        Records = JsonConverters.fromJson(json['Records'],'List<Record>',context!);
        Errors = JsonConverters.fromJson(json['Errors'],'List<Error>',context!);
        ParentGroupID = json['ParentGroupID'];
        ValidationGroup = json['ValidationGroup'];
        RiskPointsFound = json['RiskPointsFound'];
        RiskPointsNotFound = json['RiskPointsNotFound'];
        NotFoundMessage = json['NotFoundMessage'];
        ConCoincidencias = json['ConCoincidencias'];
        RealPoints = json['RealPoints'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'Id': Id,
        'Name': Name,
        'Description': Description,
        'SubGroups': JsonConverters.toJson(SubGroups,'List<DataGroup>',context!),
        'Records': JsonConverters.toJson(Records,'List<Record>',context!),
        'Errors': JsonConverters.toJson(Errors,'List<Error>',context!),
        'ParentGroupID': ParentGroupID,
        'ValidationGroup': ValidationGroup,
        'RiskPointsFound': RiskPointsFound,
        'RiskPointsNotFound': RiskPointsNotFound,
        'NotFoundMessage': NotFoundMessage,
        'ConCoincidencias': ConCoincidencias,
        'RealPoints': RealPoints
    };

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

class BackgroundchekReport implements IConvertible
{
    int? AlertsCounter;
    bool? ShowRiskMeter;
    String? FullName;
    String? DocumentNumber;
    DateTime? ReportDate;
    BackgroundchekSeach? SearchData;
    QueryStatus? SearchStatus;
    String? ReportID;
    List<Error>? Errors;
    List<DataGroup>? Groups;
    String? baseName;
    List<String>? Resume;
    int? MaxRiskPoints;

    BackgroundchekReport({this.AlertsCounter,this.ShowRiskMeter,this.FullName,this.DocumentNumber,this.ReportDate,this.SearchData,this.SearchStatus,this.ReportID,this.Errors,this.Groups,this.baseName,this.Resume,this.MaxRiskPoints});
    BackgroundchekReport.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        AlertsCounter = json['AlertsCounter'];
        ShowRiskMeter = json['ShowRiskMeter'];
        FullName = json['FullName'];
        DocumentNumber = json['DocumentNumber'];
        ReportDate = JsonConverters.fromJson(json['ReportDate'],'DateTime',context!);
        SearchData = JsonConverters.fromJson(json['SearchData'],'BackgroundchekSeach',context!);
        SearchStatus = JsonConverters.fromJson(json['SearchStatus'],'QueryStatus',context!);
        ReportID = json['ReportID'];
        Errors = JsonConverters.fromJson(json['Errors'],'List<Error>',context!);
        Groups = JsonConverters.fromJson(json['Groups'],'List<DataGroup>',context!);
        baseName = json['baseName'];
        Resume = JsonConverters.fromJson(json['Resume'],'List<String>',context!);
        MaxRiskPoints = json['MaxRiskPoints'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'AlertsCounter': AlertsCounter,
        'ShowRiskMeter': ShowRiskMeter,
        'FullName': FullName,
        'DocumentNumber': DocumentNumber,
        'ReportDate': JsonConverters.toJson(ReportDate,'DateTime',context!),
        'SearchData': JsonConverters.toJson(SearchData,'BackgroundchekSeach',context!),
        'SearchStatus': JsonConverters.toJson(SearchStatus,'QueryStatus',context!),
        'ReportID': ReportID,
        'Errors': JsonConverters.toJson(Errors,'List<Error>',context!),
        'Groups': JsonConverters.toJson(Groups,'List<DataGroup>',context!),
        'baseName': baseName,
        'Resume': JsonConverters.toJson(Resume,'List<String>',context!),
        'MaxRiskPoints': MaxRiskPoints
    };

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

// @Route("/BackgroundchekSeach/{ApiCode}/{Country}/{DocumentType}/{Query}/{Version}")
// @Route("/BackgroundchekSeach/{ApiCode}/{Country}/{DocumentType}/{Query}/{Version}/{NombreTitular}")
class BackgroundchekSeach implements IReturn<BackgroundchekReport>, IConvertible
{
    String? ApiCode;
    SearchCountrys? Country;
    String? DocumentType;
    String? Query;
    int? Version;
    String? NombreTitular;

    BackgroundchekSeach({this.ApiCode,this.Country,this.DocumentType,this.Query,this.Version,this.NombreTitular});
    BackgroundchekSeach.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        ApiCode = json['ApiCode'];
        Country = JsonConverters.fromJson(json['Country'],'SearchCountrys',context!);
        DocumentType = json['DocumentType'];
        Query = json['Query'];
        Version = json['Version'];
        NombreTitular = json['NombreTitular'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'ApiCode': ApiCode,
        'Country': JsonConverters.toJson(Country,'SearchCountrys',context!),
        'DocumentType': DocumentType,
        'Query': Query,
        'Version': Version,
        'NombreTitular': NombreTitular
    };

    createResponse() => BackgroundchekReport();
    getResponseTypeName() => "BackgroundchekReport";
    getTypeName() => "BackgroundchekSeach";
    TypeContext? context = _ctx;
}

TypeContext _ctx = TypeContext(library: 'api.backgroundchecklatam.com', types: <String, TypeInfo> {
    'SearchCountrys': TypeInfo(TypeOf.Enum, enumValues:SearchCountrys.values),
    'QueryStatus': TypeInfo(TypeOf.Enum, enumValues:QueryStatus.values),
    'Severity': TypeInfo(TypeOf.Enum, enumValues:Severity.values),
    'Error': TypeInfo(TypeOf.Class, create:() => Error()),
    'DataValue': TypeInfo(TypeOf.Class, create:() => DataValue()),
    'FilterEvaluationResults': TypeInfo(TypeOf.Class, create:() => FilterEvaluationResults()),
    'Record': TypeInfo(TypeOf.Class, create:() => Record()),
    'List<DataValue>': TypeInfo(TypeOf.Class, create:() => <DataValue>[]),
    'DataGroup': TypeInfo(TypeOf.Class, create:() => DataGroup()),
    'List<DataGroup>': TypeInfo(TypeOf.Class, create:() => <DataGroup>[]),
    'List<Record>': TypeInfo(TypeOf.Class, create:() => <Record>[]),
    'List<Error>': TypeInfo(TypeOf.Class, create:() => <Error>[]),
    'BackgroundchekReport': TypeInfo(TypeOf.Class, create:() => BackgroundchekReport()),
    'BackgroundchekSeach': TypeInfo(TypeOf.Class, create:() => BackgroundchekSeach()),
});