Sanctions Search API: v2

AddClient

Clients

The following routes are available for this service:
POST	/clients	Add a client

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;
}

// @DataContract
class ResponseError implements IConvertible
{
    // @DataMember(Order=1)
    String? errorCode;

    // @DataMember(Order=2)
    String? fieldName;

    // @DataMember(Order=3)
    String? message;

    // @DataMember(Order=4)
    Map<String,String?>? meta;

    ResponseError({this.errorCode,this.fieldName,this.message,this.meta});
    ResponseError.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        errorCode = json['errorCode'];
        fieldName = json['fieldName'];
        message = json['message'];
        meta = JsonConverters.toStringMap(json['meta']);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'errorCode': errorCode,
        'fieldName': fieldName,
        'message': message,
        'meta': meta
    };

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

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

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

// @DataContract
class ResponseStatus implements IConvertible
{
    // @DataMember(Order=1)
    String? errorCode;

    // @DataMember(Order=2)
    String? message;

    // @DataMember(Order=3)
    String? stackTrace;

    // @DataMember(Order=4)
    ArrayOfResponseError? errors;

    // @DataMember(Order=5)
    Map<String,String?>? meta;

    ResponseStatus({this.errorCode,this.message,this.stackTrace,this.errors,this.meta});
    ResponseStatus.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        errorCode = json['errorCode'];
        message = json['message'];
        stackTrace = json['stackTrace'];
        errors = JsonConverters.fromJson(json['errors'],'ArrayOfResponseError',context!);
        meta = JsonConverters.toStringMap(json['meta']);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'errorCode': errorCode,
        'message': message,
        'stackTrace': stackTrace,
        'errors': JsonConverters.toJson(errors,'ArrayOfResponseError',context!),
        'meta': meta
    };

    getTypeName() => "ResponseStatus";
    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 LinkedTo implements IConvertible
{
    int? clientId;
    int? id;
    String? type;
    String? subtype;
    String? status;
    String? description;
    bool? isArchived;
    String? name;
    DateTime? date;

    LinkedTo({this.clientId,this.id,this.type,this.subtype,this.status,this.description,this.isArchived,this.name,this.date});
    LinkedTo.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        clientId = json['clientId'];
        id = json['id'];
        type = json['type'];
        subtype = json['subtype'];
        status = json['status'];
        description = json['description'];
        isArchived = json['isArchived'];
        name = json['name'];
        date = JsonConverters.fromJson(json['date'],'DateTime',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'clientId': clientId,
        'id': id,
        'type': type,
        'subtype': subtype,
        'status': status,
        'description': description,
        'isArchived': isArchived,
        'name': name,
        'date': JsonConverters.toJson(date,'DateTime',context!)
    };

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

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

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

// @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 AddClientData extends BaseResponse implements IBaseSearchResponse, IConvertible
{
    ArrayOfLinkedTo? linkedTo;
    Client? client;

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

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

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

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

// @DataContract
class AddClientResponse implements IConvertible
{
    // @DataMember
    AddClientData? data;

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

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

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

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

// @DataContract(Name="CreateMobileClientType", Namespace="http://schemas.servicestack.net/types")
enum CreateMobileClientType
{
    Undefined,
    ValidateMe,
    PassportChipVerification,
}

class AddClientRequest implements IConvertible
{
    /**
    * The full name of the client
    */
    // @ApiMember(Description="The full name of the client", IsRequired=true)
    String? name;

    /**
    * The email address of the client
    */
    // @ApiMember(Description="The email address of the client", IsRequired=true)
    String? email;

    /**
    * The client's mobile phone number in international format (e.g. '+447123456789')
    */
    // @ApiMember(Description="The client's mobile phone number in international format (e.g. '+447123456789')", IsRequired=true)
    String? mobileInternational;

    /**
    * The postal code of the client's address. Used in emails sent to the client to help them recognize the communication as genuine
    */
    // @ApiMember(Description="The postal code of the client's address. Used in emails sent to the client to help them recognize the communication as genuine", IsRequired=true)
    String? postCode;

    /**
    * Specifies the type of ValidateMe preset. Possible values are 'ValidateMe' for configuring RequiredDocuments, or 'PassportChipVerification' for setting the Passport as Proof of Name
    */
    // @ApiMember(Description="Specifies the type of ValidateMe preset. Possible values are 'ValidateMe' for configuring RequiredDocuments, or 'PassportChipVerification' for setting the Passport as Proof of Name", IsRequired=true)
    CreateMobileClientType? proofOfPreset;

    /**
    * The categories of proof and selected documents that the client can use to provide proof. Required if ClientType is set to 'ValidateMe'
    */
    // @ApiMember(Description="The categories of proof and selected documents that the client can use to provide proof. Required if ClientType is set to 'ValidateMe'")
    ArrayOfProofOfDocumentCategories? proofOfDocumentCategories;

    /**
    * If the client should be linked to other searches, specify the them here
    */
    // @ApiMember(Description="If the client should be linked to other searches, specify the them here")
    ArrayOfLinkedTo? linkedTo;

    AddClientRequest({this.name,this.email,this.mobileInternational,this.postCode,this.proofOfPreset,this.proofOfDocumentCategories,this.linkedTo});
    AddClientRequest.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        name = json['name'];
        email = json['email'];
        mobileInternational = json['mobileInternational'];
        postCode = json['postCode'];
        proofOfPreset = JsonConverters.fromJson(json['proofOfPreset'],'CreateMobileClientType',context!);
        proofOfDocumentCategories = JsonConverters.fromJson(json['proofOfDocumentCategories'],'ArrayOfProofOfDocumentCategories',context!);
        linkedTo = JsonConverters.fromJson(json['linkedTo'],'ArrayOfLinkedTo',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'name': name,
        'email': email,
        'mobileInternational': mobileInternational,
        'postCode': postCode,
        'proofOfPreset': JsonConverters.toJson(proofOfPreset,'CreateMobileClientType',context!),
        'proofOfDocumentCategories': JsonConverters.toJson(proofOfDocumentCategories,'ArrayOfProofOfDocumentCategories',context!),
        'linkedTo': JsonConverters.toJson(linkedTo,'ArrayOfLinkedTo',context!)
    };

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

// @DataContract
class AddClient extends BaseRequest implements IConvertible
{
    // @DataMember
    AddClientRequest? request;

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

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

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

    getTypeName() => "AddClient";
    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()),
    'ArrayOfResponseError': TypeInfo(TypeOf.Class, create:() => ArrayOfResponseError()),
    'BaseResponse': TypeInfo(TypeOf.Class, create:() => BaseResponse()),
    'LinkedTo': TypeInfo(TypeOf.Class, create:() => LinkedTo()),
    'ArrayOfLinkedTo': TypeInfo(TypeOf.Class, create:() => ArrayOfLinkedTo()),
    '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()),
    'AddClientData': TypeInfo(TypeOf.Class, create:() => AddClientData()),
    'AddClientResponse': TypeInfo(TypeOf.Class, create:() => AddClientResponse()),
    'CreateMobileClientType': TypeInfo(TypeOf.Enum, enumValues:CreateMobileClientType.values),
    'AddClientRequest': TypeInfo(TypeOf.Class, create:() => AddClientRequest()),
    'AddClient': TypeInfo(TypeOf.Class, create:() => AddClient()),
});

Dart AddClient DTOs

To override the Content-type in your clients, use the HTTP Accept Header, append the .xml suffix or ?format=xml

HTTP + XML

The following are sample HTTP requests and responses. The placeholders shown need to be replaced with actual values.

POST /clients HTTP/1.1 
Host: api.sanctionssearch.com 
Accept: application/xml
Content-Type: application/xml
Content-Length: length

<AddClient xmlns:i="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://schemas.servicestack.net/types">
  <Authentication>
    <ApiUserId>String</ApiUserId>
    <ApiUserKey>String</ApiUserKey>
  </Authentication>
  <Request>
    <Email>String</Email>
    <LinkedTo>
      <LinkedTo>
        <ClientId>0</ClientId>
        <Date>0001-01-01T00:00:00</Date>
        <Description>String</Description>
        <Id>0</Id>
        <IsArchived>false</IsArchived>
        <Name>String</Name>
        <Status>String</Status>
        <Subtype>String</Subtype>
        <Type>String</Type>
      </LinkedTo>
    </LinkedTo>
    <MobileInternational>String</MobileInternational>
    <Name>String</Name>
    <PostCode>String</PostCode>
    <ProofOfDocumentCategories>
      <CategoryId>
        <Id>0</Id>
        <ProofOf>String</ProofOf>
        <ProofOfDocuments>
          <DocumentId>
            <Id>0</Id>
            <Name>String</Name>
          </DocumentId>
        </ProofOfDocuments>
      </CategoryId>
    </ProofOfDocumentCategories>
    <ProofOfPreset>Undefined</ProofOfPreset>
  </Request>
</AddClient>

HTTP/1.1 200 OK
Content-Type: application/xml
Content-Length: length

<AddClientResponse xmlns:i="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://schemas.servicestack.net/types">
  <Data>
    <ResponseStatus>
      <ErrorCode>String</ErrorCode>
      <Message>String</Message>
      <StackTrace>String</StackTrace>
      <Errors>
        <ResponseError>
          <ErrorCode>String</ErrorCode>
          <FieldName>String</FieldName>
          <Message>String</Message>
          <Meta xmlns:d6p1="http://schemas.microsoft.com/2003/10/Serialization/Arrays">
            <d6p1:KeyValueOfstringstring>
              <d6p1:Key>String</d6p1:Key>
              <d6p1:Value>String</d6p1:Value>
            </d6p1:KeyValueOfstringstring>
          </Meta>
        </ResponseError>
      </Errors>
      <Meta xmlns:d4p1="http://schemas.microsoft.com/2003/10/Serialization/Arrays">
        <d4p1:KeyValueOfstringstring>
          <d4p1:Key>String</d4p1:Key>
          <d4p1:Value>String</d4p1:Value>
        </d4p1:KeyValueOfstringstring>
      </Meta>
    </ResponseStatus>
    <Client>
      <DateCreated>0001-01-01T00:00:00</DateCreated>
      <DrivingLicences>
        <Passport>
          <Address>String</Address>
          <ClientFileId>0</ClientFileId>
          <DateOfBirth>String</DateOfBirth>
          <DrivingLicenceNumber>String</DrivingLicenceNumber>
          <FaceMatchConfidence>0</FaceMatchConfidence>
          <FirstName>String</FirstName>
          <HasDfaSearch>false</HasDfaSearch>
          <Images>
            <CategoryId>
              <Id>0</Id>
              <Name>String</Name>
              <OcrId>0</OcrId>
              <Url>String</Url>
            </CategoryId>
          </Images>
          <IsFaceMatch>false</IsFaceMatch>
          <IsVerified>false</IsVerified>
          <LastName>String</LastName>
          <MiddleName>String</MiddleName>
        </Passport>
      </DrivingLicences>
      <Email>String</Email>
      <Face>
        <Accessories>String</Accessories>
        <Age>0</Age>
        <Emotion>String</Emotion>
        <FacialHair>String</FacialHair>
        <Gender>String</Gender>
        <Glasses>String</Glasses>
        <HairColour>String</HairColour>
        <Makeup>String</Makeup>
        <Smile>0</Smile>
      </Face>
      <Id>0</Id>
      <IsValidateMe>false</IsValidateMe>
      <Location>
        <Latitude>0</Latitude>
        <Longitude>0</Longitude>
      </Location>
      <MobileInternational>String</MobileInternational>
      <Name>String</Name>
      <NumOfDocuments>0</NumOfDocuments>
      <OtherDocuments>
        <OtherDocument>
          <ClientFileId>0</ClientFileId>
          <CroppedImageUrl>String</CroppedImageUrl>
          <Description>String</Description>
          <IsVerified>false</IsVerified>
          <OriginalImageUrl>String</OriginalImageUrl>
          <Type>String</Type>
          <TypeOther>String</TypeOther>
        </OtherDocument>
      </OtherDocuments>
      <Passports>
        <Passport>
          <ClientFileId>0</ClientFileId>
          <DateOfBirth>String</DateOfBirth>
          <FaceMatchConfidence>0</FaceMatchConfidence>
          <FirstName>String</FirstName>
          <Gender>String</Gender>
          <HasDfaSearch>false</HasDfaSearch>
          <HasPcvSearch>false</HasPcvSearch>
          <Images>
            <CategoryId>
              <Id>0</Id>
              <Name>String</Name>
              <OcrId>0</OcrId>
              <Url>String</Url>
            </CategoryId>
          </Images>
          <IsEligibleForDfa>false</IsEligibleForDfa>
          <IsEligibleForPcv>false</IsEligibleForPcv>
          <IsFaceMatch>false</IsFaceMatch>
          <IsPassportChipVerified>false</IsPassportChipVerified>
          <IsVerified>false</IsVerified>
          <LastName>String</LastName>
          <MiddleName>String</MiddleName>
          <MrzLineOne>String</MrzLineOne>
          <MrzLineTwo1>String</MrzLineTwo1>
          <MrzLineTwo2>String</MrzLineTwo2>
          <MrzLineTwo3>String</MrzLineTwo3>
          <MrzLineTwo4>String</MrzLineTwo4>
          <MrzLineTwo5>String</MrzLineTwo5>
          <MrzLineTwo6>String</MrzLineTwo6>
          <MrzLineTwo7>String</MrzLineTwo7>
          <MrzLineTwo8>String</MrzLineTwo8>
          <PassportChipData>
            <DataGroupsFailed xmlns:d7p1="http://schemas.microsoft.com/2003/10/Serialization/Arrays">
              <d7p1:int>0</d7p1:int>
            </DataGroupsFailed>
            <DataGroupsVerified xmlns:d7p1="http://schemas.microsoft.com/2003/10/Serialization/Arrays">
              <d7p1:int>0</d7p1:int>
            </DataGroupsVerified>
            <FaceMatchConfidence>0</FaceMatchConfidence>
            <IsFaceMatch>false</IsFaceMatch>
            <IsIssuerVerified>false</IsIssuerVerified>
            <IsMrzLine1Verified>false</IsMrzLine1Verified>
            <IsMrzLine2Verified>false</IsMrzLine2Verified>
            <IssuerCommonName>String</IssuerCommonName>
            <IssuerCountry>String</IssuerCountry>
            <IssuerOrganisationName>String</IssuerOrganisationName>
            <MRZLine1>String</MRZLine1>
            <MRZLine2>String</MRZLine2>
          </PassportChipData>
        </Passport>
      </Passports>
      <PostCode>String</PostCode>
      <ProofOfDocumentCategories>
        <CategoryId>
          <Id>0</Id>
          <ProofOf>String</ProofOf>
          <ProofOfDocuments>
            <DocumentId>
              <Id>0</Id>
              <Name>String</Name>
            </DocumentId>
          </ProofOfDocuments>
        </CategoryId>
      </ProofOfDocumentCategories>
      <Reference>String</Reference>
      <State>Undefined</State>
      <Video>
        <Id>0</Id>
        <ImageUrl>String</ImageUrl>
        <VideoTimestamps>
          <VideoTimestamp>
            <ImageUrl>String</ImageUrl>
            <Milli>0</Milli>
            <TagName>String</TagName>
          </VideoTimestamp>
        </VideoTimestamps>
        <VideoUrl>String</VideoUrl>
      </Video>
    </Client>
    <LinkedTo>
      <LinkedTo>
        <ClientId>0</ClientId>
        <Date>0001-01-01T00:00:00</Date>
        <Description>String</Description>
        <Id>0</Id>
        <IsArchived>false</IsArchived>
        <Name>String</Name>
        <Status>String</Status>
        <Subtype>String</Subtype>
        <Type>String</Type>
      </LinkedTo>
    </LinkedTo>
  </Data>
</AddClientResponse>