/* Options:
Date: 2025-03-15 04:15:56
Version: 8.30
Tip: To override a DTO option, remove "//" prefix before updating
BaseUrl: https://api.sanctionssearch.com/v2

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

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

// @DataContract
class Authentication implements IConvertible
{
    /**
    * The API User ID provided by us when you signed up to use our API
    */
    // @DataMember
    // @ApiMember(Description="The API User ID provided by us when you signed up to use our API", IsRequired=true, ParameterType="header, body")
    String? apiUserId;

    /**
    * The API User Key provided by us when you signed up to use our API
    */
    // @DataMember
    // @ApiMember(Description="The API User Key provided by us when you signed up to use our API", IsRequired=true, ParameterType="header, body")
    String? apiUserKey;

    Authentication({this.apiUserId,this.apiUserKey});
    Authentication.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

    Map<String, dynamic> toJson() => {
        'apiUserId': apiUserId,
        'apiUserKey': apiUserKey
    };

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

// @DataContract
class BaseRequest implements IBaseRequest, IConvertible
{
    /**
    * The authentication credentials
    */
    // @DataMember
    // @ApiMember(Description="The authentication credentials", IsRequired=true, ParameterType="header, body")
    Authentication? authentication;

    BaseRequest({this.authentication});
    BaseRequest.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

    Map<String, dynamic> toJson() => {
        'authentication': JsonConverters.toJson(authentication,'Authentication',context!)
    };

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

abstract class IBaseRequest
{
    Authentication? authentication;
}

class GetValidIdsRequest implements IConvertible
{
    /**
    * If the searches are being accessed by a sub user, specify their username here to only return searches they have permissions to view
    */
    // @ApiMember(Description="If the searches are being accessed by a sub user, specify their username here to only return searches they have permissions to view")
    String? subUserName;

    int? page;
    String? sortOrder;
    String? nameSearch;
    String? filterReference;
    String? filterType;
    DateTime? filterDateFrom;
    DateTime? filterDateTo;
    /**
    * If set, will only return searches created by the user
    */
    // @ApiMember(Description="If set, will only return searches created by the user")
    String? filterUserName;

    GetValidIdsRequest({this.subUserName,this.page,this.sortOrder,this.nameSearch,this.filterReference,this.filterType,this.filterDateFrom,this.filterDateTo,this.filterUserName});
    GetValidIdsRequest.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        subUserName = json['subUserName'];
        page = json['page'];
        sortOrder = json['sortOrder'];
        nameSearch = json['nameSearch'];
        filterReference = json['filterReference'];
        filterType = json['filterType'];
        filterDateFrom = JsonConverters.fromJson(json['filterDateFrom'],'DateTime',context!);
        filterDateTo = JsonConverters.fromJson(json['filterDateTo'],'DateTime',context!);
        filterUserName = json['filterUserName'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'subUserName': subUserName,
        'page': page,
        'sortOrder': sortOrder,
        'nameSearch': nameSearch,
        'filterReference': filterReference,
        'filterType': filterType,
        'filterDateFrom': JsonConverters.toJson(filterDateFrom,'DateTime',context!),
        'filterDateTo': JsonConverters.toJson(filterDateTo,'DateTime',context!),
        'filterUserName': filterUserName
    };

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

class BaseResponse implements IBaseDataResponse, IHasResponseStatus, IConvertible
{
    /**
    * The status of the response
    */
    // @ApiMember(Description="The status of the response")
    ResponseStatus? responseStatus;

    BaseResponse({this.responseStatus});
    BaseResponse.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

    Map<String, dynamic> toJson() => {
        'responseStatus': JsonConverters.toJson(responseStatus,'ResponseStatus',context!)
    };

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

class ValidIdSearchCriteria implements IConvertible
{
    String? fullName;
    DateTime? dateOfBirth;
    String? gender;
    String? address;

    ValidIdSearchCriteria({this.fullName,this.dateOfBirth,this.gender,this.address});
    ValidIdSearchCriteria.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        fullName = json['fullName'];
        dateOfBirth = JsonConverters.fromJson(json['dateOfBirth'],'DateTime',context!);
        gender = json['gender'];
        address = json['address'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'fullName': fullName,
        'dateOfBirth': JsonConverters.toJson(dateOfBirth,'DateTime',context!),
        'gender': gender,
        'address': address
    };

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

class ValidIdListItem implements IConvertible
{
    int? id;
    int? type;
    int? score;
    String? status;
    DateTime? dateSearched;
    String? reference;
    bool? pepError;
    bool? replaced;
    int? replacementSearchId;
    bool? hasCompletedRequest;
    bool? hasCompletedSearch;
    ValidIdSearchCriteria? searchCriteria;

    ValidIdListItem({this.id,this.type,this.score,this.status,this.dateSearched,this.reference,this.pepError,this.replaced,this.replacementSearchId,this.hasCompletedRequest,this.hasCompletedSearch,this.searchCriteria});
    ValidIdListItem.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        id = json['id'];
        type = json['type'];
        score = json['score'];
        status = json['status'];
        dateSearched = JsonConverters.fromJson(json['dateSearched'],'DateTime',context!);
        reference = json['reference'];
        pepError = json['pepError'];
        replaced = json['replaced'];
        replacementSearchId = json['replacementSearchId'];
        hasCompletedRequest = json['hasCompletedRequest'];
        hasCompletedSearch = json['hasCompletedSearch'];
        searchCriteria = JsonConverters.fromJson(json['searchCriteria'],'ValidIdSearchCriteria',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'id': id,
        'type': type,
        'score': score,
        'status': status,
        'dateSearched': JsonConverters.toJson(dateSearched,'DateTime',context!),
        'reference': reference,
        'pepError': pepError,
        'replaced': replaced,
        'replacementSearchId': replacementSearchId,
        'hasCompletedRequest': hasCompletedRequest,
        'hasCompletedSearch': hasCompletedSearch,
        'searchCriteria': JsonConverters.toJson(searchCriteria,'ValidIdSearchCriteria',context!)
    };

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

class ArrayOfValidIdListItem extends ListBase<ValidIdListItem> implements IConvertible
{
    final List<ValidIdListItem> l = [];
    set length(int newLength) { l.length = newLength; }
    int get length => l.length;
    ValidIdListItem operator [](int index) => l[index];
    void operator []=(int index, ValidIdListItem value) { l[index] = value; }
    ArrayOfValidIdListItem();
    ArrayOfValidIdListItem.fromJson(Map<String, dynamic> json) : super();
    fromMap(Map<String, dynamic> json) {
        return this;
    }

    Map<String, dynamic> toJson() => {};
    getTypeName() => "ArrayOfValidIdListItem";
    TypeContext? context = _ctx;
}

class GetValidIdsData extends BaseResponse implements IConvertible
{
    int? totalSearchRecords;
    int? currentPageNum;
    int? maxPageNum;
    ArrayOfValidIdListItem? searchRecords;

    GetValidIdsData({this.totalSearchRecords,this.currentPageNum,this.maxPageNum,this.searchRecords});
    GetValidIdsData.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        super.fromMap(json);
        totalSearchRecords = json['totalSearchRecords'];
        currentPageNum = json['currentPageNum'];
        maxPageNum = json['maxPageNum'];
        searchRecords = JsonConverters.fromJson(json['searchRecords'],'ArrayOfValidIdListItem',context!);
        return this;
    }

    Map<String, dynamic> toJson() => super.toJson()..addAll({
        'totalSearchRecords': totalSearchRecords,
        'currentPageNum': currentPageNum,
        'maxPageNum': maxPageNum,
        'searchRecords': JsonConverters.toJson(searchRecords,'ArrayOfValidIdListItem',context!)
    });

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

abstract class IBaseDataResponse
{
    ResponseStatus? responseStatus;
}

abstract class IHasResponseStatus
{
    ResponseStatus? responseStatus;
}

// @DataContract
class GetValidIdsResponse implements IConvertible
{
    // @DataMember
    GetValidIdsData? data;

    GetValidIdsResponse({this.data});
    GetValidIdsResponse.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

    Map<String, dynamic> toJson() => {
        'data': JsonConverters.toJson(data,'GetValidIdsData',context!)
    };

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

// @Route("/validid/list", "POST")
// @DataContract
class GetValidIds extends BaseRequest implements IReturn<GetValidIdsResponse>, IConvertible, IPost
{
    // @DataMember
    GetValidIdsRequest? request;

    GetValidIds({this.request});
    GetValidIds.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

    Map<String, dynamic> toJson() => super.toJson()..addAll({
        'request': JsonConverters.toJson(request,'GetValidIdsRequest',context!)
    });

    createResponse() => GetValidIdsResponse();
    getResponseTypeName() => "GetValidIdsResponse";
    getTypeName() => "GetValidIds";
    TypeContext? context = _ctx;
}

TypeContext _ctx = TypeContext(library: 'api.sanctionssearch.com', types: <String, TypeInfo> {
    'Authentication': TypeInfo(TypeOf.Class, create:() => Authentication()),
    'BaseRequest': TypeInfo(TypeOf.Class, create:() => BaseRequest()),
    'IBaseRequest': TypeInfo(TypeOf.Interface),
    'GetValidIdsRequest': TypeInfo(TypeOf.Class, create:() => GetValidIdsRequest()),
    'BaseResponse': TypeInfo(TypeOf.Class, create:() => BaseResponse()),
    'ValidIdSearchCriteria': TypeInfo(TypeOf.Class, create:() => ValidIdSearchCriteria()),
    'ValidIdListItem': TypeInfo(TypeOf.Class, create:() => ValidIdListItem()),
    'ArrayOfValidIdListItem': TypeInfo(TypeOf.Class, create:() => ArrayOfValidIdListItem()),
    'GetValidIdsData': TypeInfo(TypeOf.Class, create:() => GetValidIdsData()),
    'IBaseDataResponse': TypeInfo(TypeOf.Interface),
    'IHasResponseStatus': TypeInfo(TypeOf.Interface),
    'GetValidIdsResponse': TypeInfo(TypeOf.Class, create:() => GetValidIdsResponse()),
    'GetValidIds': TypeInfo(TypeOf.Class, create:() => GetValidIds()),
});