Sanctions Search API: v2

AddClientTemplate

Clients

The following routes are available for this service:
GET	/clients/template	Get a template for adding 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;
}

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

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

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

class AddClientTemplateData extends BaseResponse implements IConvertible
{
    AddClientRequest? request;

    AddClientTemplateData({this.request});
    AddClientTemplateData.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() => "AddClientTemplateData";
    TypeContext? context = _ctx;
}

// @DataContract
class AddClientTemplateResponse implements IConvertible
{
    // @DataMember
    AddClientTemplateData? data;

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

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

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

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

// @DataContract
class AddClientTemplate extends BaseRequest implements IConvertible
{
    AddClientTemplate();
    AddClientTemplate.fromJson(Map<String, dynamic> json) : super.fromJson(json);
    fromMap(Map<String, dynamic> json) {
        super.fromMap(json);
        return this;
    }

    Map<String, dynamic> toJson() => super.toJson();
    getTypeName() => "AddClientTemplate";
    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()),
    'CreateMobileClientType': TypeInfo(TypeOf.Enum, enumValues:CreateMobileClientType.values),
    'ProofOfDocument': TypeInfo(TypeOf.Class, create:() => ProofOfDocument()),
    'ArrayOfProofOfDocuments': TypeInfo(TypeOf.Class, create:() => ArrayOfProofOfDocuments()),
    'ProofOfDocumentCategory': TypeInfo(TypeOf.Class, create:() => ProofOfDocumentCategory()),
    'ArrayOfProofOfDocumentCategories': TypeInfo(TypeOf.Class, create:() => ArrayOfProofOfDocumentCategories()),
    'LinkedTo': TypeInfo(TypeOf.Class, create:() => LinkedTo()),
    'ArrayOfLinkedTo': TypeInfo(TypeOf.Class, create:() => ArrayOfLinkedTo()),
    'AddClientRequest': TypeInfo(TypeOf.Class, create:() => AddClientRequest()),
    'AddClientTemplateData': TypeInfo(TypeOf.Class, create:() => AddClientTemplateData()),
    'AddClientTemplateResponse': TypeInfo(TypeOf.Class, create:() => AddClientTemplateResponse()),
    'AddClientTemplate': TypeInfo(TypeOf.Class, create:() => AddClientTemplate()),
});

Dart AddClientTemplate 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.

GET /clients/template HTTP/1.1 
Host: api.sanctionssearch.com 
Accept: application/xml

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

<AddClientTemplateResponse 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>
    <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>
  </Data>
</AddClientTemplateResponse>