Sanctions Search API: v2

GetPepSearches

PEP

The following routes are available for this service:
POST	/peps/list	Get all PEP searches

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 SearchCriteria implements IConvertible
{
    String? name;
    String? address;
    String? country;
    String? dateOfBirth;
    String? nationality;
    String? reference;

    SearchCriteria({this.name,this.address,this.country,this.dateOfBirth,this.nationality,this.reference});
    SearchCriteria.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        name = json['name'];
        address = json['address'];
        country = json['country'];
        dateOfBirth = json['dateOfBirth'];
        nationality = json['nationality'];
        reference = json['reference'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'name': name,
        'address': address,
        'country': country,
        'dateOfBirth': dateOfBirth,
        'nationality': nationality,
        'reference': reference
    };

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

class PepSearchListItem implements IConvertible
{
    int? id;
    String? searchType;
    DateTime? dateSearched;
    DateTime? dateUpdated;
    DateTime? dateRenewal;
    DateTime? dateArchived;
    bool? isArchived;
    int? numOfResults;
    bool? clientInResults;
    bool? clientNotInResults;
    bool? affectedByUpdate;
    bool? isDayOneSearch;
    SearchCriteria? searchCriteria;

    PepSearchListItem({this.id,this.searchType,this.dateSearched,this.dateUpdated,this.dateRenewal,this.dateArchived,this.isArchived,this.numOfResults,this.clientInResults,this.clientNotInResults,this.affectedByUpdate,this.isDayOneSearch,this.searchCriteria});
    PepSearchListItem.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        id = json['id'];
        searchType = json['searchType'];
        dateSearched = JsonConverters.fromJson(json['dateSearched'],'DateTime',context!);
        dateUpdated = JsonConverters.fromJson(json['dateUpdated'],'DateTime',context!);
        dateRenewal = JsonConverters.fromJson(json['dateRenewal'],'DateTime',context!);
        dateArchived = JsonConverters.fromJson(json['dateArchived'],'DateTime',context!);
        isArchived = json['isArchived'];
        numOfResults = json['numOfResults'];
        clientInResults = json['clientInResults'];
        clientNotInResults = json['clientNotInResults'];
        affectedByUpdate = json['affectedByUpdate'];
        isDayOneSearch = json['isDayOneSearch'];
        searchCriteria = JsonConverters.fromJson(json['searchCriteria'],'SearchCriteria',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'id': id,
        'searchType': searchType,
        'dateSearched': JsonConverters.toJson(dateSearched,'DateTime',context!),
        'dateUpdated': JsonConverters.toJson(dateUpdated,'DateTime',context!),
        'dateRenewal': JsonConverters.toJson(dateRenewal,'DateTime',context!),
        'dateArchived': JsonConverters.toJson(dateArchived,'DateTime',context!),
        'isArchived': isArchived,
        'numOfResults': numOfResults,
        'clientInResults': clientInResults,
        'clientNotInResults': clientNotInResults,
        'affectedByUpdate': affectedByUpdate,
        'isDayOneSearch': isDayOneSearch,
        'searchCriteria': JsonConverters.toJson(searchCriteria,'SearchCriteria',context!)
    };

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

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

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

class GetPepSearchesData extends BaseResponse implements IConvertible
{
    int? totalSearchRecords;
    int? currentPageNum;
    int? maxPageNum;
    ArrayOfPepSearchListItem? searchRecords;

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

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

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

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

// @DataContract
class GetPepSearchesResponse implements IConvertible
{
    // @DataMember
    GetPepSearchesData? data;

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

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

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

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

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

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

    GetPepSearchesRequest({this.subUserName,this.listUnresolvedSearches,this.listUpdatedSearches,this.listArchivedSearches,this.page,this.sortOrder,this.nameSearch,this.nameSearchExact,this.filterReference,this.filterPepType,this.filterType,this.filterDateFrom,this.filterDateTo,this.filterUserName});
    GetPepSearchesRequest.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

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

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

// @DataContract
class GetPepSearches extends BaseRequest implements IConvertible
{
    // @DataMember
    GetPepSearchesRequest? request;

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

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

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

    getTypeName() => "GetPepSearches";
    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()),
    'SearchCriteria': TypeInfo(TypeOf.Class, create:() => SearchCriteria()),
    'PepSearchListItem': TypeInfo(TypeOf.Class, create:() => PepSearchListItem()),
    'ArrayOfPepSearchListItem': TypeInfo(TypeOf.Class, create:() => ArrayOfPepSearchListItem()),
    'GetPepSearchesData': TypeInfo(TypeOf.Class, create:() => GetPepSearchesData()),
    'GetPepSearchesResponse': TypeInfo(TypeOf.Class, create:() => GetPepSearchesResponse()),
    'GetPepSearchesRequest': TypeInfo(TypeOf.Class, create:() => GetPepSearchesRequest()),
    'GetPepSearches': TypeInfo(TypeOf.Class, create:() => GetPepSearches()),
});

Dart GetPepSearches 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 /peps/list HTTP/1.1 
Host: api.sanctionssearch.com 
Accept: application/xml
Content-Type: application/xml
Content-Length: length

<GetPepSearches xmlns:i="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://schemas.servicestack.net/types">
  <Authentication>
    <ApiUserId>String</ApiUserId>
    <ApiUserKey>String</ApiUserKey>
  </Authentication>
  <Request>
    <FilterDateFrom>0001-01-01T00:00:00</FilterDateFrom>
    <FilterDateTo>0001-01-01T00:00:00</FilterDateTo>
    <FilterPepType>String</FilterPepType>
    <FilterReference>String</FilterReference>
    <FilterType>String</FilterType>
    <FilterUserName>String</FilterUserName>
    <ListArchivedSearches>false</ListArchivedSearches>
    <ListUnresolvedSearches>false</ListUnresolvedSearches>
    <ListUpdatedSearches>false</ListUpdatedSearches>
    <NameSearch>String</NameSearch>
    <NameSearchExact>false</NameSearchExact>
    <Page>0</Page>
    <SortOrder>String</SortOrder>
    <SubUserName>String</SubUserName>
  </Request>
</GetPepSearches>

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

<GetPepSearchesResponse 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>
    <CurrentPageNum>0</CurrentPageNum>
    <MaxPageNum>0</MaxPageNum>
    <SearchRecords>
      <SearchRecord>
        <AffectedByUpdate>false</AffectedByUpdate>
        <ClientInResults>false</ClientInResults>
        <ClientNotInResults>false</ClientNotInResults>
        <DateArchived>0001-01-01T00:00:00</DateArchived>
        <DateRenewal>0001-01-01T00:00:00</DateRenewal>
        <DateSearched>0001-01-01T00:00:00</DateSearched>
        <DateUpdated>0001-01-01T00:00:00</DateUpdated>
        <Id>0</Id>
        <IsArchived>false</IsArchived>
        <IsDayOneSearch>false</IsDayOneSearch>
        <NumOfResults>0</NumOfResults>
        <SearchCriteria>
          <Address>String</Address>
          <Country>String</Country>
          <DateOfBirth>String</DateOfBirth>
          <Name>String</Name>
          <Nationality>String</Nationality>
          <Reference>String</Reference>
        </SearchCriteria>
        <SearchType>String</SearchType>
      </SearchRecord>
    </SearchRecords>
    <TotalSearchRecords>0</TotalSearchRecords>
  </Data>
</GetPepSearchesResponse>