/* Options:
Date: 2025-03-15 04:18:31
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: UpdateClient.*
//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;
}

// @DataContract(Name="ClientState", Namespace="http://schemas.servicestack.net/types")
enum ClientState
{
    Undefined,
    PendingCompletion,
    PendingOcr,
    PendingVerification,
    Verified,
}

class Face implements IConvertible
{
    double? age;
    String? gender;
    String? emotion;
    double? smile;
    String? hairColour;
    String? facialHair;
    String? makeup;
    String? glasses;
    String? accessories;

    Face({this.age,this.gender,this.emotion,this.smile,this.hairColour,this.facialHair,this.makeup,this.glasses,this.accessories});
    Face.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        age = JsonConverters.toDouble(json['age']);
        gender = json['gender'];
        emotion = json['emotion'];
        smile = JsonConverters.toDouble(json['smile']);
        hairColour = json['hairColour'];
        facialHair = json['facialHair'];
        makeup = json['makeup'];
        glasses = json['glasses'];
        accessories = json['accessories'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'age': age,
        'gender': gender,
        'emotion': emotion,
        'smile': smile,
        'hairColour': hairColour,
        'facialHair': facialHair,
        'makeup': makeup,
        'glasses': glasses,
        'accessories': accessories
    };

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

class VideoTimestamp implements IConvertible
{
    String? tagName;
    int? milli;
    String? imageUrl;

    VideoTimestamp({this.tagName,this.milli,this.imageUrl});
    VideoTimestamp.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        tagName = json['tagName'];
        milli = json['milli'];
        imageUrl = json['imageUrl'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'tagName': tagName,
        'milli': milli,
        'imageUrl': imageUrl
    };

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

class Video implements IConvertible
{
    int? id;
    String? videoUrl;
    String? imageUrl;
    List<VideoTimestamp>? videoTimestamps;

    Video({this.id,this.videoUrl,this.imageUrl,this.videoTimestamps});
    Video.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        id = json['id'];
        videoUrl = json['videoUrl'];
        imageUrl = json['imageUrl'];
        videoTimestamps = JsonConverters.fromJson(json['videoTimestamps'],'List<VideoTimestamp>',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'id': id,
        'videoUrl': videoUrl,
        'imageUrl': imageUrl,
        'videoTimestamps': JsonConverters.toJson(videoTimestamps,'List<VideoTimestamp>',context!)
    };

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

class Location implements IConvertible
{
    double? latitude;
    double? longitude;

    Location({this.latitude,this.longitude});
    Location.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

    Map<String, dynamic> toJson() => {
        'latitude': latitude,
        'longitude': longitude
    };

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

class Image implements IConvertible
{
    int? id;
    String? name;
    int? ocrId;
    String? url;

    Image({this.id,this.name,this.ocrId,this.url});
    Image.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        id = json['id'];
        name = json['name'];
        ocrId = json['ocrId'];
        url = json['url'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'id': id,
        'name': name,
        'ocrId': ocrId,
        'url': url
    };

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

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

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

class PassportChipData implements IConvertible
{
    bool? isIssuerVerified;
    String? issuerCommonName;
    String? issuerOrganisationName;
    String? issuerCountry;
    String? mrzLine1;
    String? mrzLine2;
    bool? isMrzLine1Verified;
    bool? isMrzLine2Verified;
    List<int>? dataGroupsVerified;
    List<int>? dataGroupsFailed;
    bool? isFaceMatch;
    double? faceMatchConfidence;

    PassportChipData({this.isIssuerVerified,this.issuerCommonName,this.issuerOrganisationName,this.issuerCountry,this.mrzLine1,this.mrzLine2,this.isMrzLine1Verified,this.isMrzLine2Verified,this.dataGroupsVerified,this.dataGroupsFailed,this.isFaceMatch,this.faceMatchConfidence});
    PassportChipData.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        isIssuerVerified = json['isIssuerVerified'];
        issuerCommonName = json['issuerCommonName'];
        issuerOrganisationName = json['issuerOrganisationName'];
        issuerCountry = json['issuerCountry'];
        mrzLine1 = json['mrzLine1'];
        mrzLine2 = json['mrzLine2'];
        isMrzLine1Verified = json['isMrzLine1Verified'];
        isMrzLine2Verified = json['isMrzLine2Verified'];
        dataGroupsVerified = JsonConverters.fromJson(json['dataGroupsVerified'],'List<int>',context!);
        dataGroupsFailed = JsonConverters.fromJson(json['dataGroupsFailed'],'List<int>',context!);
        isFaceMatch = json['isFaceMatch'];
        faceMatchConfidence = JsonConverters.toDouble(json['faceMatchConfidence']);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'isIssuerVerified': isIssuerVerified,
        'issuerCommonName': issuerCommonName,
        'issuerOrganisationName': issuerOrganisationName,
        'issuerCountry': issuerCountry,
        'mrzLine1': mrzLine1,
        'mrzLine2': mrzLine2,
        'isMrzLine1Verified': isMrzLine1Verified,
        'isMrzLine2Verified': isMrzLine2Verified,
        'dataGroupsVerified': JsonConverters.toJson(dataGroupsVerified,'List<int>',context!),
        'dataGroupsFailed': JsonConverters.toJson(dataGroupsFailed,'List<int>',context!),
        'isFaceMatch': isFaceMatch,
        'faceMatchConfidence': faceMatchConfidence
    };

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

class Passport implements IConvertible
{
    int? clientFileId;
    String? firstName;
    String? middleName;
    String? lastName;
    String? dateOfBirth;
    String? gender;
    String? mrzLineOne;
    String? mrzLineTwo1;
    String? mrzLineTwo2;
    String? mrzLineTwo3;
    String? mrzLineTwo4;
    String? mrzLineTwo5;
    String? mrzLineTwo6;
    String? mrzLineTwo7;
    String? mrzLineTwo8;
    ArrayOfImages? images;
    bool? isVerified;
    bool? isFaceMatch;
    double? faceMatchConfidence;
    bool? hasPcvSearch;
    bool? hasDfaSearch;
    bool? isPassportChipVerified;
    PassportChipData? passportChipData;
    bool? isEligibleForPcv;
    bool? isEligibleForDfa;

    Passport({this.clientFileId,this.firstName,this.middleName,this.lastName,this.dateOfBirth,this.gender,this.mrzLineOne,this.mrzLineTwo1,this.mrzLineTwo2,this.mrzLineTwo3,this.mrzLineTwo4,this.mrzLineTwo5,this.mrzLineTwo6,this.mrzLineTwo7,this.mrzLineTwo8,this.images,this.isVerified,this.isFaceMatch,this.faceMatchConfidence,this.hasPcvSearch,this.hasDfaSearch,this.isPassportChipVerified,this.passportChipData,this.isEligibleForPcv,this.isEligibleForDfa});
    Passport.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        clientFileId = json['clientFileId'];
        firstName = json['firstName'];
        middleName = json['middleName'];
        lastName = json['lastName'];
        dateOfBirth = json['dateOfBirth'];
        gender = json['gender'];
        mrzLineOne = json['mrzLineOne'];
        mrzLineTwo1 = json['mrzLineTwo1'];
        mrzLineTwo2 = json['mrzLineTwo2'];
        mrzLineTwo3 = json['mrzLineTwo3'];
        mrzLineTwo4 = json['mrzLineTwo4'];
        mrzLineTwo5 = json['mrzLineTwo5'];
        mrzLineTwo6 = json['mrzLineTwo6'];
        mrzLineTwo7 = json['mrzLineTwo7'];
        mrzLineTwo8 = json['mrzLineTwo8'];
        images = JsonConverters.fromJson(json['images'],'ArrayOfImages',context!);
        isVerified = json['isVerified'];
        isFaceMatch = json['isFaceMatch'];
        faceMatchConfidence = JsonConverters.toDouble(json['faceMatchConfidence']);
        hasPcvSearch = json['hasPcvSearch'];
        hasDfaSearch = json['hasDfaSearch'];
        isPassportChipVerified = json['isPassportChipVerified'];
        passportChipData = JsonConverters.fromJson(json['passportChipData'],'PassportChipData',context!);
        isEligibleForPcv = json['isEligibleForPcv'];
        isEligibleForDfa = json['isEligibleForDfa'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'clientFileId': clientFileId,
        'firstName': firstName,
        'middleName': middleName,
        'lastName': lastName,
        'dateOfBirth': dateOfBirth,
        'gender': gender,
        'mrzLineOne': mrzLineOne,
        'mrzLineTwo1': mrzLineTwo1,
        'mrzLineTwo2': mrzLineTwo2,
        'mrzLineTwo3': mrzLineTwo3,
        'mrzLineTwo4': mrzLineTwo4,
        'mrzLineTwo5': mrzLineTwo5,
        'mrzLineTwo6': mrzLineTwo6,
        'mrzLineTwo7': mrzLineTwo7,
        'mrzLineTwo8': mrzLineTwo8,
        'images': JsonConverters.toJson(images,'ArrayOfImages',context!),
        'isVerified': isVerified,
        'isFaceMatch': isFaceMatch,
        'faceMatchConfidence': faceMatchConfidence,
        'hasPcvSearch': hasPcvSearch,
        'hasDfaSearch': hasDfaSearch,
        'isPassportChipVerified': isPassportChipVerified,
        'passportChipData': JsonConverters.toJson(passportChipData,'PassportChipData',context!),
        'isEligibleForPcv': isEligibleForPcv,
        'isEligibleForDfa': isEligibleForDfa
    };

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

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

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

class DrivingLicence implements IConvertible
{
    int? clientFileId;
    String? firstName;
    String? middleName;
    String? lastName;
    String? dateOfBirth;
    String? address;
    String? drivingLicenceNumber;
    ArrayOfImages? images;
    bool? isVerified;
    bool? isFaceMatch;
    double? faceMatchConfidence;
    bool? hasDfaSearch;

    DrivingLicence({this.clientFileId,this.firstName,this.middleName,this.lastName,this.dateOfBirth,this.address,this.drivingLicenceNumber,this.images,this.isVerified,this.isFaceMatch,this.faceMatchConfidence,this.hasDfaSearch});
    DrivingLicence.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        clientFileId = json['clientFileId'];
        firstName = json['firstName'];
        middleName = json['middleName'];
        lastName = json['lastName'];
        dateOfBirth = json['dateOfBirth'];
        address = json['address'];
        drivingLicenceNumber = json['drivingLicenceNumber'];
        images = JsonConverters.fromJson(json['images'],'ArrayOfImages',context!);
        isVerified = json['isVerified'];
        isFaceMatch = json['isFaceMatch'];
        faceMatchConfidence = JsonConverters.toDouble(json['faceMatchConfidence']);
        hasDfaSearch = json['hasDfaSearch'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'clientFileId': clientFileId,
        'firstName': firstName,
        'middleName': middleName,
        'lastName': lastName,
        'dateOfBirth': dateOfBirth,
        'address': address,
        'drivingLicenceNumber': drivingLicenceNumber,
        'images': JsonConverters.toJson(images,'ArrayOfImages',context!),
        'isVerified': isVerified,
        'isFaceMatch': isFaceMatch,
        'faceMatchConfidence': faceMatchConfidence,
        'hasDfaSearch': hasDfaSearch
    };

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

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

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

class OtherDocument implements IConvertible
{
    int? clientFileId;
    String? type;
    String? typeOther;
    String? description;
    String? originalImageUrl;
    String? croppedImageUrl;
    bool? isVerified;

    OtherDocument({this.clientFileId,this.type,this.typeOther,this.description,this.originalImageUrl,this.croppedImageUrl,this.isVerified});
    OtherDocument.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        clientFileId = json['clientFileId'];
        type = json['type'];
        typeOther = json['typeOther'];
        description = json['description'];
        originalImageUrl = json['originalImageUrl'];
        croppedImageUrl = json['croppedImageUrl'];
        isVerified = json['isVerified'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'clientFileId': clientFileId,
        'type': type,
        'typeOther': typeOther,
        'description': description,
        'originalImageUrl': originalImageUrl,
        'croppedImageUrl': croppedImageUrl,
        'isVerified': isVerified
    };

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

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

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

class ProofOfDocument implements IConvertible
{
    /**
    * The ID of the ProofOfDocument
    */
    // @ApiMember(Description="The ID of the ProofOfDocument", IsRequired=true)
    int? id;

    /**
    * The name of the ProofOfDocument
    */
    // @ApiMember(Description="The name of the ProofOfDocument", IsRequired=true)
    String? name;

    ProofOfDocument({this.id,this.name});
    ProofOfDocument.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

    Map<String, dynamic> toJson() => {
        'id': id,
        'name': name
    };

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

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

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

class ProofOfDocumentCategory implements IConvertible
{
    /**
    * The ID of the ProofOfDocumentCategory
    */
    // @ApiMember(Description="The ID of the ProofOfDocumentCategory", IsRequired=true)
    int? id;

    /**
    * The category or subject that requires proof (e.g., 'Name', 'Address', 'Right to work')
    */
    // @ApiMember(Description="The category or subject that requires proof (e.g., 'Name', 'Address', 'Right to work')", IsRequired=true)
    String? proofOf;

    /**
    * The documents that can be used to provide proof for the specified category.
    */
    // @ApiMember(Description="The documents that can be used to provide proof for the specified category.", IsRequired=true)
    ArrayOfProofOfDocuments? proofOfDocuments;

    ProofOfDocumentCategory({this.id,this.proofOf,this.proofOfDocuments});
    ProofOfDocumentCategory.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

    Map<String, dynamic> toJson() => {
        'id': id,
        'proofOf': proofOf,
        'proofOfDocuments': JsonConverters.toJson(proofOfDocuments,'ArrayOfProofOfDocuments',context!)
    };

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

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

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

class Client implements IConvertible
{
    int? id;
    DateTime? dateCreated;
    String? name;
    String? email;
    String? reference;
    ClientState? state;
    String? mobileInternational;
    String? postCode;
    bool? isValidateMe;
    Face? face;
    Video? video;
    Location? location;
    int? numOfDocuments;
    ArrayOfPassports? passports;
    ArrayOfDrivingLicences? drivingLicences;
    ArrayOfOtherDocuments? otherDocuments;
    ArrayOfProofOfDocumentCategories? proofOfDocumentCategories;

    Client({this.id,this.dateCreated,this.name,this.email,this.reference,this.state,this.mobileInternational,this.postCode,this.isValidateMe,this.face,this.video,this.location,this.numOfDocuments,this.passports,this.drivingLicences,this.otherDocuments,this.proofOfDocumentCategories});
    Client.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        id = json['id'];
        dateCreated = JsonConverters.fromJson(json['dateCreated'],'DateTime',context!);
        name = json['name'];
        email = json['email'];
        reference = json['reference'];
        state = JsonConverters.fromJson(json['state'],'ClientState',context!);
        mobileInternational = json['mobileInternational'];
        postCode = json['postCode'];
        isValidateMe = json['isValidateMe'];
        face = JsonConverters.fromJson(json['face'],'Face',context!);
        video = JsonConverters.fromJson(json['video'],'Video',context!);
        location = JsonConverters.fromJson(json['location'],'Location',context!);
        numOfDocuments = json['numOfDocuments'];
        passports = JsonConverters.fromJson(json['passports'],'ArrayOfPassports',context!);
        drivingLicences = JsonConverters.fromJson(json['drivingLicences'],'ArrayOfDrivingLicences',context!);
        otherDocuments = JsonConverters.fromJson(json['otherDocuments'],'ArrayOfOtherDocuments',context!);
        proofOfDocumentCategories = JsonConverters.fromJson(json['proofOfDocumentCategories'],'ArrayOfProofOfDocumentCategories',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'id': id,
        'dateCreated': JsonConverters.toJson(dateCreated,'DateTime',context!),
        'name': name,
        'email': email,
        'reference': reference,
        'state': JsonConverters.toJson(state,'ClientState',context!),
        'mobileInternational': mobileInternational,
        'postCode': postCode,
        'isValidateMe': isValidateMe,
        'face': JsonConverters.toJson(face,'Face',context!),
        'video': JsonConverters.toJson(video,'Video',context!),
        'location': JsonConverters.toJson(location,'Location',context!),
        'numOfDocuments': numOfDocuments,
        'passports': JsonConverters.toJson(passports,'ArrayOfPassports',context!),
        'drivingLicences': JsonConverters.toJson(drivingLicences,'ArrayOfDrivingLicences',context!),
        'otherDocuments': JsonConverters.toJson(otherDocuments,'ArrayOfOtherDocuments',context!),
        'proofOfDocumentCategories': JsonConverters.toJson(proofOfDocumentCategories,'ArrayOfProofOfDocumentCategories',context!)
    };

    getTypeName() => "Client";
    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 UpdateClientData extends BaseResponse implements IConvertible
{
    Client? client;

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

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

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

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

abstract class IBaseDataResponse
{
    ResponseStatus? responseStatus;
}

abstract class IHasResponseStatus
{
    ResponseStatus? responseStatus;
}

// @DataContract
class UpdateClientResponse implements IConvertible
{
    // @DataMember
    UpdateClientData? data;

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

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

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

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

// @Route("/clients/{Id}", "PUT")
// @DataContract
class UpdateClient extends BaseRequest implements IReturn<UpdateClientResponse>, IConvertible, IPut
{
    // @DataMember
    // @ApiMember(IsRequired=true, ParameterType="path")
    int? id;

    // @DataMember
    Client? request;

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

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

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

    createResponse() => UpdateClientResponse();
    getResponseTypeName() => "UpdateClientResponse";
    getTypeName() => "UpdateClient";
    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),
    'ClientState': TypeInfo(TypeOf.Enum, enumValues:ClientState.values),
    'Face': TypeInfo(TypeOf.Class, create:() => Face()),
    'VideoTimestamp': TypeInfo(TypeOf.Class, create:() => VideoTimestamp()),
    'Video': TypeInfo(TypeOf.Class, create:() => Video()),
    'List<VideoTimestamp>': TypeInfo(TypeOf.Class, create:() => <VideoTimestamp>[]),
    'Location': TypeInfo(TypeOf.Class, create:() => Location()),
    'Image': TypeInfo(TypeOf.Class, create:() => Image()),
    'ArrayOfImages': TypeInfo(TypeOf.Class, create:() => ArrayOfImages()),
    'PassportChipData': TypeInfo(TypeOf.Class, create:() => PassportChipData()),
    'Passport': TypeInfo(TypeOf.Class, create:() => Passport()),
    'ArrayOfPassports': TypeInfo(TypeOf.Class, create:() => ArrayOfPassports()),
    'DrivingLicence': TypeInfo(TypeOf.Class, create:() => DrivingLicence()),
    'ArrayOfDrivingLicences': TypeInfo(TypeOf.Class, create:() => ArrayOfDrivingLicences()),
    'OtherDocument': TypeInfo(TypeOf.Class, create:() => OtherDocument()),
    'ArrayOfOtherDocuments': TypeInfo(TypeOf.Class, create:() => ArrayOfOtherDocuments()),
    'ProofOfDocument': TypeInfo(TypeOf.Class, create:() => ProofOfDocument()),
    'ArrayOfProofOfDocuments': TypeInfo(TypeOf.Class, create:() => ArrayOfProofOfDocuments()),
    'ProofOfDocumentCategory': TypeInfo(TypeOf.Class, create:() => ProofOfDocumentCategory()),
    'ArrayOfProofOfDocumentCategories': TypeInfo(TypeOf.Class, create:() => ArrayOfProofOfDocumentCategories()),
    'Client': TypeInfo(TypeOf.Class, create:() => Client()),
    'BaseResponse': TypeInfo(TypeOf.Class, create:() => BaseResponse()),
    'UpdateClientData': TypeInfo(TypeOf.Class, create:() => UpdateClientData()),
    'IBaseDataResponse': TypeInfo(TypeOf.Interface),
    'IHasResponseStatus': TypeInfo(TypeOf.Interface),
    'UpdateClientResponse': TypeInfo(TypeOf.Class, create:() => UpdateClientResponse()),
    'UpdateClient': TypeInfo(TypeOf.Class, create:() => UpdateClient()),
});