/* Options:
Date: 2025-07-02 13:06:11
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: AddCompanyLookup.*
//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. Can be provided in the request body, or as a header parameter (X-Api-User)
    */
    // @DataMember
    // @ApiMember(Description="The API User ID provided by us when you signed up to use our API. Can be provided in the request body, or as a header parameter (X-Api-User)", IsRequired=true, ParameterType="header, body")
    String? apiUserId;

    /**
    * The API User Key provided by us when you signed up to use our API. Can be provided in the request body, or as a header parameter (X-Api-Key)
    */
    // @DataMember
    // @ApiMember(Description="The API User Key provided by us when you signed up to use our API. Can be provided in the request body, or as a header parameter (X-Api-Key)", IsRequired=true, ParameterType="header, body")
    String? apiUserKey;

    /**
    * The User ID of the user making the request (e.g. a sub user). This is optional but can be used to associate API requests with a specific user, thereby allowing user permissions to be enforced. Can be provided in the body, or as a header parameter (X-User-Id).
    */
    // @DataMember
    // @ApiMember(Description="The User ID of the user making the request (e.g. a sub user). This is optional but can be used to associate API requests with a specific user, thereby allowing user permissions to be enforced. Can be provided in the body, or as a header parameter (X-User-Id).", ParameterType="header, body")
    String? userId;

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

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

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

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

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

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

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

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

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

abstract class IBaseRequest
{
    Authentication? authentication;
}

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

    Map<String, dynamic> toJson() => {};
    getTypeName() => "ArrayOfLists";
    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 AddCompanyLookupRequest implements IConvertible
{
    /**
    * If the search should be saved against a single Sub User account, specify their username here
    */
    // @ApiMember(Description="If the search should be saved against a single Sub User account, specify their username here")
    String? subUserName;

    int? companyLookupId;
    String? companyRegistrationNumber;
    String? companyName;
    String? companyAddress;
    String? companyCountry;
    bool? performEnhancedSearch;
    ArrayOfLists? selectedLists;
    /**
    * If the search should be linked to other searches, specify the them here
    */
    // @ApiMember(Description="If the search should be linked to other searches, specify the them here")
    ArrayOfLinkedTo? linkedTo;

    AddCompanyLookupRequest({this.subUserName,this.companyLookupId,this.companyRegistrationNumber,this.companyName,this.companyAddress,this.companyCountry,this.performEnhancedSearch,this.selectedLists,this.linkedTo});
    AddCompanyLookupRequest.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        subUserName = json['subUserName'];
        companyLookupId = json['companyLookupId'];
        companyRegistrationNumber = json['companyRegistrationNumber'];
        companyName = json['companyName'];
        companyAddress = json['companyAddress'];
        companyCountry = json['companyCountry'];
        performEnhancedSearch = json['performEnhancedSearch'];
        selectedLists = JsonConverters.fromJson(json['selectedLists'],'ArrayOfLists',context!);
        linkedTo = JsonConverters.fromJson(json['linkedTo'],'ArrayOfLinkedTo',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'subUserName': subUserName,
        'companyLookupId': companyLookupId,
        'companyRegistrationNumber': companyRegistrationNumber,
        'companyName': companyName,
        'companyAddress': companyAddress,
        'companyCountry': companyCountry,
        'performEnhancedSearch': performEnhancedSearch,
        'selectedLists': JsonConverters.toJson(selectedLists,'ArrayOfLists',context!),
        'linkedTo': JsonConverters.toJson(linkedTo,'ArrayOfLinkedTo',context!)
    };

    getTypeName() => "AddCompanyLookupRequest";
    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 CompanyDirectorOrShareholder implements IConvertible
{
    int? id;
    String? searchType;
    DateTime? dateSearched;
    DateTime? dateUpdated;
    int? numOfResults;
    bool? clientInResults;
    bool? clientNotInResults;
    bool? affectedByUpdate;
    SearchCriteria? searchCriteria;
    bool? isDirector;
    bool? isShareholder;

    CompanyDirectorOrShareholder({this.id,this.searchType,this.dateSearched,this.dateUpdated,this.numOfResults,this.clientInResults,this.clientNotInResults,this.affectedByUpdate,this.searchCriteria,this.isDirector,this.isShareholder});
    CompanyDirectorOrShareholder.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!);
        numOfResults = json['numOfResults'];
        clientInResults = json['clientInResults'];
        clientNotInResults = json['clientNotInResults'];
        affectedByUpdate = json['affectedByUpdate'];
        searchCriteria = JsonConverters.fromJson(json['searchCriteria'],'SearchCriteria',context!);
        isDirector = json['isDirector'];
        isShareholder = json['isShareholder'];
        return this;
    }

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

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

class SearchSource implements IConvertible
{
    String? listId;
    String? listName;
    String? listShortName;
    bool? isAffectedByListUpdate;

    SearchSource({this.listId,this.listName,this.listShortName,this.isAffectedByListUpdate});
    SearchSource.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        listId = json['listId'];
        listName = json['listName'];
        listShortName = json['listShortName'];
        isAffectedByListUpdate = json['isAffectedByListUpdate'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'listId': listId,
        'listName': listName,
        'listShortName': listShortName,
        'isAffectedByListUpdate': isAffectedByListUpdate
    };

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

class SearchListItem implements IConvertible
{
    int? id;
    String? searchType;
    DateTime? dateSearched;
    DateTime? dateUpdated;
    DateTime? dateArchived;
    bool? isArchived;
    int? numOfResults;
    bool? clientInResults;
    bool? clientNotInResults;
    bool? affectedByUpdate;
    SearchCriteria? searchCriteria;
    List<SearchSource>? searchSources;

    SearchListItem({this.id,this.searchType,this.dateSearched,this.dateUpdated,this.dateArchived,this.isArchived,this.numOfResults,this.clientInResults,this.clientNotInResults,this.affectedByUpdate,this.searchCriteria,this.searchSources});
    SearchListItem.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!);
        dateArchived = JsonConverters.fromJson(json['dateArchived'],'DateTime',context!);
        isArchived = json['isArchived'];
        numOfResults = json['numOfResults'];
        clientInResults = json['clientInResults'];
        clientNotInResults = json['clientNotInResults'];
        affectedByUpdate = json['affectedByUpdate'];
        searchCriteria = JsonConverters.fromJson(json['searchCriteria'],'SearchCriteria',context!);
        searchSources = JsonConverters.fromJson(json['searchSources'],'List<SearchSource>',context!);
        return this;
    }

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

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

class CompanyLookupEnhancedLatestAccounts implements IConvertible
{
    String? currency;
    double? turnover;
    double? shareholdersEquity;
    int? creditRating;
    int? creditLimit;
    String? creditRatingDescription;
    int? accountRefDay;
    int? accountRefMonth;
    DateTime? accountNextDueDate;
    DateTime? accountLastMadeUpDate;
    String? accountCategory;
    DateTime? returnLastMadeUpDate;

    CompanyLookupEnhancedLatestAccounts({this.currency,this.turnover,this.shareholdersEquity,this.creditRating,this.creditLimit,this.creditRatingDescription,this.accountRefDay,this.accountRefMonth,this.accountNextDueDate,this.accountLastMadeUpDate,this.accountCategory,this.returnLastMadeUpDate});
    CompanyLookupEnhancedLatestAccounts.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        currency = json['currency'];
        turnover = JsonConverters.toDouble(json['turnover']);
        shareholdersEquity = JsonConverters.toDouble(json['shareholdersEquity']);
        creditRating = json['creditRating'];
        creditLimit = json['creditLimit'];
        creditRatingDescription = json['creditRatingDescription'];
        accountRefDay = json['accountRefDay'];
        accountRefMonth = json['accountRefMonth'];
        accountNextDueDate = JsonConverters.fromJson(json['accountNextDueDate'],'DateTime',context!);
        accountLastMadeUpDate = JsonConverters.fromJson(json['accountLastMadeUpDate'],'DateTime',context!);
        accountCategory = json['accountCategory'];
        returnLastMadeUpDate = JsonConverters.fromJson(json['returnLastMadeUpDate'],'DateTime',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'currency': currency,
        'turnover': turnover,
        'shareholdersEquity': shareholdersEquity,
        'creditRating': creditRating,
        'creditLimit': creditLimit,
        'creditRatingDescription': creditRatingDescription,
        'accountRefDay': accountRefDay,
        'accountRefMonth': accountRefMonth,
        'accountNextDueDate': JsonConverters.toJson(accountNextDueDate,'DateTime',context!),
        'accountLastMadeUpDate': JsonConverters.toJson(accountLastMadeUpDate,'DateTime',context!),
        'accountCategory': accountCategory,
        'returnLastMadeUpDate': JsonConverters.toJson(returnLastMadeUpDate,'DateTime',context!)
    };

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

class CompanyLookupEnhancedSummary implements IConvertible
{
    String? name;
    String? country;
    String? registrationNumber;
    String? dateOfIncorporation;
    String? typeOfIncorporation;
    String? companyStatus;
    String? address;
    String? telephone;
    String? sicCode;
    String? sicDescription;
    String? principleActivity;
    CompanyLookupEnhancedLatestAccounts? latestAccounts;

    CompanyLookupEnhancedSummary({this.name,this.country,this.registrationNumber,this.dateOfIncorporation,this.typeOfIncorporation,this.companyStatus,this.address,this.telephone,this.sicCode,this.sicDescription,this.principleActivity,this.latestAccounts});
    CompanyLookupEnhancedSummary.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        name = json['name'];
        country = json['country'];
        registrationNumber = json['registrationNumber'];
        dateOfIncorporation = json['dateOfIncorporation'];
        typeOfIncorporation = json['typeOfIncorporation'];
        companyStatus = json['companyStatus'];
        address = json['address'];
        telephone = json['telephone'];
        sicCode = json['sicCode'];
        sicDescription = json['sicDescription'];
        principleActivity = json['principleActivity'];
        latestAccounts = JsonConverters.fromJson(json['latestAccounts'],'CompanyLookupEnhancedLatestAccounts',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'name': name,
        'country': country,
        'registrationNumber': registrationNumber,
        'dateOfIncorporation': dateOfIncorporation,
        'typeOfIncorporation': typeOfIncorporation,
        'companyStatus': companyStatus,
        'address': address,
        'telephone': telephone,
        'sicCode': sicCode,
        'sicDescription': sicDescription,
        'principleActivity': principleActivity,
        'latestAccounts': JsonConverters.toJson(latestAccounts,'CompanyLookupEnhancedLatestAccounts',context!)
    };

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

class CompanyLookupEnhancedAddress implements IConvertible
{
    String? fullAddress;
    String? address1;
    String? address2;
    String? address3;
    String? address4;
    String? postCode;
    String? telephone;

    CompanyLookupEnhancedAddress({this.fullAddress,this.address1,this.address2,this.address3,this.address4,this.postCode,this.telephone});
    CompanyLookupEnhancedAddress.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        fullAddress = json['fullAddress'];
        address1 = json['address1'];
        address2 = json['address2'];
        address3 = json['address3'];
        address4 = json['address4'];
        postCode = json['postCode'];
        telephone = json['telephone'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'fullAddress': fullAddress,
        'address1': address1,
        'address2': address2,
        'address3': address3,
        'address4': address4,
        'postCode': postCode,
        'telephone': telephone
    };

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

class CompanyLookupEnhancedWebsite implements IConvertible
{
    String? website;

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

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

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

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

class CompanyLookupEnhancedAdditionalContact implements IConvertible
{
    String? telephone;
    String? faxNumber;
    String? emailAddress;
    String? webAddress;
    String? twitter;
    String? facebook;
    String? googlePlus;
    String? linkedIn;
    String? contactName;
    String? businessClassification;

    CompanyLookupEnhancedAdditionalContact({this.telephone,this.faxNumber,this.emailAddress,this.webAddress,this.twitter,this.facebook,this.googlePlus,this.linkedIn,this.contactName,this.businessClassification});
    CompanyLookupEnhancedAdditionalContact.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        telephone = json['telephone'];
        faxNumber = json['faxNumber'];
        emailAddress = json['emailAddress'];
        webAddress = json['webAddress'];
        twitter = json['twitter'];
        facebook = json['facebook'];
        googlePlus = json['googlePlus'];
        linkedIn = json['linkedIn'];
        contactName = json['contactName'];
        businessClassification = json['businessClassification'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'telephone': telephone,
        'faxNumber': faxNumber,
        'emailAddress': emailAddress,
        'webAddress': webAddress,
        'twitter': twitter,
        'facebook': facebook,
        'googlePlus': googlePlus,
        'linkedIn': linkedIn,
        'contactName': contactName,
        'businessClassification': businessClassification
    };

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

class CompanyLookupEnhancedContactInfo implements IConvertible
{
    CompanyLookupEnhancedAddress? registeredAddress;
    List<CompanyLookupEnhancedAddress>? tradingAddresses;
    List<CompanyLookupEnhancedWebsite>? websites;
    CompanyLookupEnhancedAdditionalContact? additionalContactInfo;

    CompanyLookupEnhancedContactInfo({this.registeredAddress,this.tradingAddresses,this.websites,this.additionalContactInfo});
    CompanyLookupEnhancedContactInfo.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        registeredAddress = JsonConverters.fromJson(json['registeredAddress'],'CompanyLookupEnhancedAddress',context!);
        tradingAddresses = JsonConverters.fromJson(json['tradingAddresses'],'List<CompanyLookupEnhancedAddress>',context!);
        websites = JsonConverters.fromJson(json['websites'],'List<CompanyLookupEnhancedWebsite>',context!);
        additionalContactInfo = JsonConverters.fromJson(json['additionalContactInfo'],'CompanyLookupEnhancedAdditionalContact',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'registeredAddress': JsonConverters.toJson(registeredAddress,'CompanyLookupEnhancedAddress',context!),
        'tradingAddresses': JsonConverters.toJson(tradingAddresses,'List<CompanyLookupEnhancedAddress>',context!),
        'websites': JsonConverters.toJson(websites,'List<CompanyLookupEnhancedWebsite>',context!),
        'additionalContactInfo': JsonConverters.toJson(additionalContactInfo,'CompanyLookupEnhancedAdditionalContact',context!)
    };

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

class CompanyLookupEnhancedSicCode implements IConvertible
{
    int? sicCode2003;
    String? sicCode2003Description;
    int? sicCode2007;
    String? sicCode2007Description;
    String? status;

    CompanyLookupEnhancedSicCode({this.sicCode2003,this.sicCode2003Description,this.sicCode2007,this.sicCode2007Description,this.status});
    CompanyLookupEnhancedSicCode.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        sicCode2003 = json['sicCode2003'];
        sicCode2003Description = json['sicCode2003Description'];
        sicCode2007 = json['sicCode2007'];
        sicCode2007Description = json['sicCode2007Description'];
        status = json['status'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'sicCode2003': sicCode2003,
        'sicCode2003Description': sicCode2003Description,
        'sicCode2007': sicCode2007,
        'sicCode2007Description': sicCode2007Description,
        'status': status
    };

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

class CompanyLookupEnhancedPreviousName implements IConvertible
{
    DateTime? dateChanged;
    String? name;

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

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

    Map<String, dynamic> toJson() => {
        'dateChanged': JsonConverters.toJson(dateChanged,'DateTime',context!),
        'name': name
    };

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

class CompanyLookupEnhancedShareholder implements IConvertible
{
    String? title;
    String? forename;
    String? surname;
    String? address1;
    String? address2;
    String? address3;
    String? address4;
    String? address5;
    String? postCode;
    String? shareType;
    double? number;
    double? value;
    String? currency;
    String? shareholderType;
    String? shareClass;

    CompanyLookupEnhancedShareholder({this.title,this.forename,this.surname,this.address1,this.address2,this.address3,this.address4,this.address5,this.postCode,this.shareType,this.number,this.value,this.currency,this.shareholderType,this.shareClass});
    CompanyLookupEnhancedShareholder.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        title = json['title'];
        forename = json['forename'];
        surname = json['surname'];
        address1 = json['address1'];
        address2 = json['address2'];
        address3 = json['address3'];
        address4 = json['address4'];
        address5 = json['address5'];
        postCode = json['postCode'];
        shareType = json['shareType'];
        number = JsonConverters.toDouble(json['number']);
        value = JsonConverters.toDouble(json['value']);
        currency = json['currency'];
        shareholderType = json['shareholderType'];
        shareClass = json['shareClass'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'title': title,
        'forename': forename,
        'surname': surname,
        'address1': address1,
        'address2': address2,
        'address3': address3,
        'address4': address4,
        'address5': address5,
        'postCode': postCode,
        'shareType': shareType,
        'number': number,
        'value': value,
        'currency': currency,
        'shareholderType': shareholderType,
        'shareClass': shareClass
    };

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

class CompanyLookupEnhancedShareStructure implements IConvertible
{
    double? issuedShareCapital;
    List<CompanyLookupEnhancedShareholder>? shareholders;

    CompanyLookupEnhancedShareStructure({this.issuedShareCapital,this.shareholders});
    CompanyLookupEnhancedShareStructure.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        issuedShareCapital = JsonConverters.toDouble(json['issuedShareCapital']);
        shareholders = JsonConverters.fromJson(json['shareholders'],'List<CompanyLookupEnhancedShareholder>',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'issuedShareCapital': issuedShareCapital,
        'shareholders': JsonConverters.toJson(shareholders,'List<CompanyLookupEnhancedShareholder>',context!)
    };

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

class CompanyLookupEnhancedDirector implements IConvertible
{
    String? name;
    String? address;
    String? gender;
    DateTime? appointmentDate;
    DateTime? resignationDate;
    DateTime? dateOfBirth;
    String? position;
    int? idNumber;
    int? currentDirectorships;
    int? previousDirectorships;
    int? totalDirectorships;

    CompanyLookupEnhancedDirector({this.name,this.address,this.gender,this.appointmentDate,this.resignationDate,this.dateOfBirth,this.position,this.idNumber,this.currentDirectorships,this.previousDirectorships,this.totalDirectorships});
    CompanyLookupEnhancedDirector.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        name = json['name'];
        address = json['address'];
        gender = json['gender'];
        appointmentDate = JsonConverters.fromJson(json['appointmentDate'],'DateTime',context!);
        resignationDate = JsonConverters.fromJson(json['resignationDate'],'DateTime',context!);
        dateOfBirth = JsonConverters.fromJson(json['dateOfBirth'],'DateTime',context!);
        position = json['position'];
        idNumber = json['idNumber'];
        currentDirectorships = json['currentDirectorships'];
        previousDirectorships = json['previousDirectorships'];
        totalDirectorships = json['totalDirectorships'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'name': name,
        'address': address,
        'gender': gender,
        'appointmentDate': JsonConverters.toJson(appointmentDate,'DateTime',context!),
        'resignationDate': JsonConverters.toJson(resignationDate,'DateTime',context!),
        'dateOfBirth': JsonConverters.toJson(dateOfBirth,'DateTime',context!),
        'position': position,
        'idNumber': idNumber,
        'currentDirectorships': currentDirectorships,
        'previousDirectorships': previousDirectorships,
        'totalDirectorships': totalDirectorships
    };

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

class CompanyLookupEnhancedDirectors implements IConvertible
{
    List<CompanyLookupEnhancedDirector>? currentDirectors;
    List<CompanyLookupEnhancedDirector>? previousDirectors;

    CompanyLookupEnhancedDirectors({this.currentDirectors,this.previousDirectors});
    CompanyLookupEnhancedDirectors.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

    Map<String, dynamic> toJson() => {
        'currentDirectors': JsonConverters.toJson(currentDirectors,'List<CompanyLookupEnhancedDirector>',context!),
        'previousDirectors': JsonConverters.toJson(previousDirectors,'List<CompanyLookupEnhancedDirector>',context!)
    };

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

class CompanyLookupEnhancedCompany implements IConvertible
{
    String? country;
    String? companyName;
    String? companyNumber;

    CompanyLookupEnhancedCompany({this.country,this.companyName,this.companyNumber});
    CompanyLookupEnhancedCompany.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        country = json['country'];
        companyName = json['companyName'];
        companyNumber = json['companyNumber'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'country': country,
        'companyName': companyName,
        'companyNumber': companyNumber
    };

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

class CompanyLookupEnhancedStructure implements IConvertible
{
    List<CompanyLookupEnhancedCompany>? parentCompanies;
    List<CompanyLookupEnhancedCompany>? subsidiaryCompanies;

    CompanyLookupEnhancedStructure({this.parentCompanies,this.subsidiaryCompanies});
    CompanyLookupEnhancedStructure.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

    Map<String, dynamic> toJson() => {
        'parentCompanies': JsonConverters.toJson(parentCompanies,'List<CompanyLookupEnhancedCompany>',context!),
        'subsidiaryCompanies': JsonConverters.toJson(subsidiaryCompanies,'List<CompanyLookupEnhancedCompany>',context!)
    };

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

class CompanyLookupEnhancedCCJ implements IConvertible
{
    DateTime? date;
    String? court;
    double? amount;
    String? caseNumber;
    String? status;
    String? datePaid;
    String? incomingRecordDetails;

    CompanyLookupEnhancedCCJ({this.date,this.court,this.amount,this.caseNumber,this.status,this.datePaid,this.incomingRecordDetails});
    CompanyLookupEnhancedCCJ.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        date = JsonConverters.fromJson(json['date'],'DateTime',context!);
        court = json['court'];
        amount = JsonConverters.toDouble(json['amount']);
        caseNumber = json['caseNumber'];
        status = json['status'];
        datePaid = json['datePaid'];
        incomingRecordDetails = json['incomingRecordDetails'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'date': JsonConverters.toJson(date,'DateTime',context!),
        'court': court,
        'amount': amount,
        'caseNumber': caseNumber,
        'status': status,
        'datePaid': datePaid,
        'incomingRecordDetails': incomingRecordDetails
    };

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

class CompanyLookupEnhancedCCJs implements IConvertible
{
    List<CompanyLookupEnhancedCCJ>? possibleCCJs;
    List<CompanyLookupEnhancedCCJ>? exactCCJs;

    CompanyLookupEnhancedCCJs({this.possibleCCJs,this.exactCCJs});
    CompanyLookupEnhancedCCJs.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

    Map<String, dynamic> toJson() => {
        'possibleCCJs': JsonConverters.toJson(possibleCCJs,'List<CompanyLookupEnhancedCCJ>',context!),
        'exactCCJs': JsonConverters.toJson(exactCCJs,'List<CompanyLookupEnhancedCCJ>',context!)
    };

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

class CompanyLookupEnhancedEvent implements IConvertible
{
    DateTime? date;
    String? description;

    CompanyLookupEnhancedEvent({this.date,this.description});
    CompanyLookupEnhancedEvent.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

    Map<String, dynamic> toJson() => {
        'date': JsonConverters.toJson(date,'DateTime',context!),
        'description': description
    };

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

class CompanyLookupEnhancedCommentary implements IConvertible
{
    String? text;
    String? positiveOrNegative;
    int? priority;

    CompanyLookupEnhancedCommentary({this.text,this.positiveOrNegative,this.priority});
    CompanyLookupEnhancedCommentary.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        text = json['text'];
        positiveOrNegative = json['positiveOrNegative'];
        priority = json['priority'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'text': text,
        'positiveOrNegative': positiveOrNegative,
        'priority': priority
    };

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

class CompanyLookupEnhancedCreditLimit implements IConvertible
{
    DateTime? date;
    int? dateOrder;
    int? amount;

    CompanyLookupEnhancedCreditLimit({this.date,this.dateOrder,this.amount});
    CompanyLookupEnhancedCreditLimit.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

    Map<String, dynamic> toJson() => {
        'date': JsonConverters.toJson(date,'DateTime',context!),
        'dateOrder': dateOrder,
        'amount': amount
    };

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

class CompanyLookupEnhancedCreditRating implements IConvertible
{
    DateTime? date;
    int? dateOrder;
    int? amount;
    String? shortDescription;
    String? description;

    CompanyLookupEnhancedCreditRating({this.date,this.dateOrder,this.amount,this.shortDescription,this.description});
    CompanyLookupEnhancedCreditRating.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        date = JsonConverters.fromJson(json['date'],'DateTime',context!);
        dateOrder = json['dateOrder'];
        amount = json['amount'];
        shortDescription = json['shortDescription'];
        description = json['description'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'date': JsonConverters.toJson(date,'DateTime',context!),
        'dateOrder': dateOrder,
        'amount': amount,
        'shortDescription': shortDescription,
        'description': description
    };

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

class CompanyLookupEnhancedCreditAccount implements IConvertible
{
    List<CompanyLookupEnhancedCreditLimit>? creditLimitHistory;
    List<CompanyLookupEnhancedCreditRating>? creditRatingHistory;

    CompanyLookupEnhancedCreditAccount({this.creditLimitHistory,this.creditRatingHistory});
    CompanyLookupEnhancedCreditAccount.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        creditLimitHistory = JsonConverters.fromJson(json['creditLimitHistory'],'List<CompanyLookupEnhancedCreditLimit>',context!);
        creditRatingHistory = JsonConverters.fromJson(json['creditRatingHistory'],'List<CompanyLookupEnhancedCreditRating>',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'creditLimitHistory': JsonConverters.toJson(creditLimitHistory,'List<CompanyLookupEnhancedCreditLimit>',context!),
        'creditRatingHistory': JsonConverters.toJson(creditRatingHistory,'List<CompanyLookupEnhancedCreditRating>',context!)
    };

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

class CompanyLookupFinancialProfit implements IConvertible
{
    double? turnover;
    double? Export;
    double? costOfSales;
    double? grossProfit;
    double? wagesAndSalaries;
    double? directorEmolument;
    double? operatingProfit;
    double? depreciation;
    double? auditFees;
    double? interestPayments;
    double? pretaxProfit;
    double? taxation;
    double? profitAfterTax;
    double? dividendsPayable;
    double? retainedProfit;

    CompanyLookupFinancialProfit({this.turnover,this.Export,this.costOfSales,this.grossProfit,this.wagesAndSalaries,this.directorEmolument,this.operatingProfit,this.depreciation,this.auditFees,this.interestPayments,this.pretaxProfit,this.taxation,this.profitAfterTax,this.dividendsPayable,this.retainedProfit});
    CompanyLookupFinancialProfit.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        turnover = JsonConverters.toDouble(json['turnover']);
        Export = JsonConverters.toDouble(json['export']);
        costOfSales = JsonConverters.toDouble(json['costOfSales']);
        grossProfit = JsonConverters.toDouble(json['grossProfit']);
        wagesAndSalaries = JsonConverters.toDouble(json['wagesAndSalaries']);
        directorEmolument = JsonConverters.toDouble(json['directorEmolument']);
        operatingProfit = JsonConverters.toDouble(json['operatingProfit']);
        depreciation = JsonConverters.toDouble(json['depreciation']);
        auditFees = JsonConverters.toDouble(json['auditFees']);
        interestPayments = JsonConverters.toDouble(json['interestPayments']);
        pretaxProfit = JsonConverters.toDouble(json['pretaxProfit']);
        taxation = JsonConverters.toDouble(json['taxation']);
        profitAfterTax = JsonConverters.toDouble(json['profitAfterTax']);
        dividendsPayable = JsonConverters.toDouble(json['dividendsPayable']);
        retainedProfit = JsonConverters.toDouble(json['retainedProfit']);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'turnover': turnover,
        'export': Export,
        'costOfSales': costOfSales,
        'grossProfit': grossProfit,
        'wagesAndSalaries': wagesAndSalaries,
        'directorEmolument': directorEmolument,
        'operatingProfit': operatingProfit,
        'depreciation': depreciation,
        'auditFees': auditFees,
        'interestPayments': interestPayments,
        'pretaxProfit': pretaxProfit,
        'taxation': taxation,
        'profitAfterTax': profitAfterTax,
        'dividendsPayable': dividendsPayable,
        'retainedProfit': retainedProfit
    };

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

class CompanyLookupFinancialBalance implements IConvertible
{
    double? tangibleAccounts;
    double? intangibleAssets;
    double? totalFixedAssets;
    double? stock;
    double? tradeDebtors;
    double? cash;
    double? otherDebtors;
    double? miscCurrentAssets;
    double? totalCurrentAssets;
    double? tradeCreditors;
    double? bankLoansAndOverdrafts;
    double? otherShortTermFinance;
    double? miscCurrentLiabilities;
    double? totalCurrentLiabilities;
    double? bankLoansAndOverdraftsAndLTL;
    double? otherLongTermFinance;
    double? totalLongTermFinance;

    CompanyLookupFinancialBalance({this.tangibleAccounts,this.intangibleAssets,this.totalFixedAssets,this.stock,this.tradeDebtors,this.cash,this.otherDebtors,this.miscCurrentAssets,this.totalCurrentAssets,this.tradeCreditors,this.bankLoansAndOverdrafts,this.otherShortTermFinance,this.miscCurrentLiabilities,this.totalCurrentLiabilities,this.bankLoansAndOverdraftsAndLTL,this.otherLongTermFinance,this.totalLongTermFinance});
    CompanyLookupFinancialBalance.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        tangibleAccounts = JsonConverters.toDouble(json['tangibleAccounts']);
        intangibleAssets = JsonConverters.toDouble(json['intangibleAssets']);
        totalFixedAssets = JsonConverters.toDouble(json['totalFixedAssets']);
        stock = JsonConverters.toDouble(json['stock']);
        tradeDebtors = JsonConverters.toDouble(json['tradeDebtors']);
        cash = JsonConverters.toDouble(json['cash']);
        otherDebtors = JsonConverters.toDouble(json['otherDebtors']);
        miscCurrentAssets = JsonConverters.toDouble(json['miscCurrentAssets']);
        totalCurrentAssets = JsonConverters.toDouble(json['totalCurrentAssets']);
        tradeCreditors = JsonConverters.toDouble(json['tradeCreditors']);
        bankLoansAndOverdrafts = JsonConverters.toDouble(json['bankLoansAndOverdrafts']);
        otherShortTermFinance = JsonConverters.toDouble(json['otherShortTermFinance']);
        miscCurrentLiabilities = JsonConverters.toDouble(json['miscCurrentLiabilities']);
        totalCurrentLiabilities = JsonConverters.toDouble(json['totalCurrentLiabilities']);
        bankLoansAndOverdraftsAndLTL = JsonConverters.toDouble(json['bankLoansAndOverdraftsAndLTL']);
        otherLongTermFinance = JsonConverters.toDouble(json['otherLongTermFinance']);
        totalLongTermFinance = JsonConverters.toDouble(json['totalLongTermFinance']);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'tangibleAccounts': tangibleAccounts,
        'intangibleAssets': intangibleAssets,
        'totalFixedAssets': totalFixedAssets,
        'stock': stock,
        'tradeDebtors': tradeDebtors,
        'cash': cash,
        'otherDebtors': otherDebtors,
        'miscCurrentAssets': miscCurrentAssets,
        'totalCurrentAssets': totalCurrentAssets,
        'tradeCreditors': tradeCreditors,
        'bankLoansAndOverdrafts': bankLoansAndOverdrafts,
        'otherShortTermFinance': otherShortTermFinance,
        'miscCurrentLiabilities': miscCurrentLiabilities,
        'totalCurrentLiabilities': totalCurrentLiabilities,
        'bankLoansAndOverdraftsAndLTL': bankLoansAndOverdraftsAndLTL,
        'otherLongTermFinance': otherLongTermFinance,
        'totalLongTermFinance': totalLongTermFinance
    };

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

class CompanyLookupFinancialCapital implements IConvertible
{
    double? calledUpSharedCapital;
    double? profitAndLossAccountReserve;
    double? revaluationReserve;
    double? sundryReserves;
    double? shareholderFunds;

    CompanyLookupFinancialCapital({this.calledUpSharedCapital,this.profitAndLossAccountReserve,this.revaluationReserve,this.sundryReserves,this.shareholderFunds});
    CompanyLookupFinancialCapital.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        calledUpSharedCapital = JsonConverters.toDouble(json['calledUpSharedCapital']);
        profitAndLossAccountReserve = JsonConverters.toDouble(json['profitAndLossAccountReserve']);
        revaluationReserve = JsonConverters.toDouble(json['revaluationReserve']);
        sundryReserves = JsonConverters.toDouble(json['sundryReserves']);
        shareholderFunds = JsonConverters.toDouble(json['shareholderFunds']);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'calledUpSharedCapital': calledUpSharedCapital,
        'profitAndLossAccountReserve': profitAndLossAccountReserve,
        'revaluationReserve': revaluationReserve,
        'sundryReserves': sundryReserves,
        'shareholderFunds': shareholderFunds
    };

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

class CompanyLookupFinancialOther implements IConvertible
{
    double? netWorth;
    double? netAssets;
    double? workingCapital;
    double? totalAssets;
    double? totalLiabilities;

    CompanyLookupFinancialOther({this.netWorth,this.netAssets,this.workingCapital,this.totalAssets,this.totalLiabilities});
    CompanyLookupFinancialOther.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        netWorth = JsonConverters.toDouble(json['netWorth']);
        netAssets = JsonConverters.toDouble(json['netAssets']);
        workingCapital = JsonConverters.toDouble(json['workingCapital']);
        totalAssets = JsonConverters.toDouble(json['totalAssets']);
        totalLiabilities = JsonConverters.toDouble(json['totalLiabilities']);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'netWorth': netWorth,
        'netAssets': netAssets,
        'workingCapital': workingCapital,
        'totalAssets': totalAssets,
        'totalLiabilities': totalLiabilities
    };

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

class CompanyLookupFinancialCash implements IConvertible
{
    double? netCashFlowFromOperations;
    double? netCashFlowBeforeFinancing;
    double? netCashFlowFromFinancing;
    double? increaseInCash;

    CompanyLookupFinancialCash({this.netCashFlowFromOperations,this.netCashFlowBeforeFinancing,this.netCashFlowFromFinancing,this.increaseInCash});
    CompanyLookupFinancialCash.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        netCashFlowFromOperations = JsonConverters.toDouble(json['netCashFlowFromOperations']);
        netCashFlowBeforeFinancing = JsonConverters.toDouble(json['netCashFlowBeforeFinancing']);
        netCashFlowFromFinancing = JsonConverters.toDouble(json['netCashFlowFromFinancing']);
        increaseInCash = JsonConverters.toDouble(json['increaseInCash']);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'netCashFlowFromOperations': netCashFlowFromOperations,
        'netCashFlowBeforeFinancing': netCashFlowBeforeFinancing,
        'netCashFlowFromFinancing': netCashFlowFromFinancing,
        'increaseInCash': increaseInCash
    };

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

class CompanyLookupFinancialMisc implements IConvertible
{
    String? contingentLiability;
    double? capitalEmployed;
    double? numberOfEmployees;
    String? auditors;
    String? auditorComments;
    String? bankers;
    String? bankBranchCode;

    CompanyLookupFinancialMisc({this.contingentLiability,this.capitalEmployed,this.numberOfEmployees,this.auditors,this.auditorComments,this.bankers,this.bankBranchCode});
    CompanyLookupFinancialMisc.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        contingentLiability = json['contingentLiability'];
        capitalEmployed = JsonConverters.toDouble(json['capitalEmployed']);
        numberOfEmployees = JsonConverters.toDouble(json['numberOfEmployees']);
        auditors = json['auditors'];
        auditorComments = json['auditorComments'];
        bankers = json['bankers'];
        bankBranchCode = json['bankBranchCode'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'contingentLiability': contingentLiability,
        'capitalEmployed': capitalEmployed,
        'numberOfEmployees': numberOfEmployees,
        'auditors': auditors,
        'auditorComments': auditorComments,
        'bankers': bankers,
        'bankBranchCode': bankBranchCode
    };

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

class CompanyLookupFinancialRatios implements IConvertible
{
    double? preTaxProfitMargin;
    double? currentRatio;
    double? salesNetworkingCapital;
    double? gearing;
    double? equity;
    double? creditorDays;
    double? debtorDays;
    double? liquidityAcidTest;
    double? returnOnCapitalEmployed;
    double? returnOnNetAssetsEmployed;
    double? returnOnTotalAssetsEmployed;
    double? currentDebtRatio;
    double? totalDebtRatio;
    double? stockTurnoverRatio;

    CompanyLookupFinancialRatios({this.preTaxProfitMargin,this.currentRatio,this.salesNetworkingCapital,this.gearing,this.equity,this.creditorDays,this.debtorDays,this.liquidityAcidTest,this.returnOnCapitalEmployed,this.returnOnNetAssetsEmployed,this.returnOnTotalAssetsEmployed,this.currentDebtRatio,this.totalDebtRatio,this.stockTurnoverRatio});
    CompanyLookupFinancialRatios.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        preTaxProfitMargin = JsonConverters.toDouble(json['preTaxProfitMargin']);
        currentRatio = JsonConverters.toDouble(json['currentRatio']);
        salesNetworkingCapital = JsonConverters.toDouble(json['salesNetworkingCapital']);
        gearing = JsonConverters.toDouble(json['gearing']);
        equity = JsonConverters.toDouble(json['equity']);
        creditorDays = JsonConverters.toDouble(json['creditorDays']);
        debtorDays = JsonConverters.toDouble(json['debtorDays']);
        liquidityAcidTest = JsonConverters.toDouble(json['liquidityAcidTest']);
        returnOnCapitalEmployed = JsonConverters.toDouble(json['returnOnCapitalEmployed']);
        returnOnNetAssetsEmployed = JsonConverters.toDouble(json['returnOnNetAssetsEmployed']);
        returnOnTotalAssetsEmployed = JsonConverters.toDouble(json['returnOnTotalAssetsEmployed']);
        currentDebtRatio = JsonConverters.toDouble(json['currentDebtRatio']);
        totalDebtRatio = JsonConverters.toDouble(json['totalDebtRatio']);
        stockTurnoverRatio = JsonConverters.toDouble(json['stockTurnoverRatio']);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'preTaxProfitMargin': preTaxProfitMargin,
        'currentRatio': currentRatio,
        'salesNetworkingCapital': salesNetworkingCapital,
        'gearing': gearing,
        'equity': equity,
        'creditorDays': creditorDays,
        'debtorDays': debtorDays,
        'liquidityAcidTest': liquidityAcidTest,
        'returnOnCapitalEmployed': returnOnCapitalEmployed,
        'returnOnNetAssetsEmployed': returnOnNetAssetsEmployed,
        'returnOnTotalAssetsEmployed': returnOnTotalAssetsEmployed,
        'currentDebtRatio': currentDebtRatio,
        'totalDebtRatio': totalDebtRatio,
        'stockTurnoverRatio': stockTurnoverRatio
    };

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

class CompanyLookupEnhancedFinancialStatement implements IConvertible
{
    int? yearEndDateOrder;
    DateTime? yearEndDate;
    int? summaryNumberOfWeeks;
    String? summaryCurrency;
    String? summaryConsolidatedAccount;
    CompanyLookupFinancialProfit? profitAndLoss;
    CompanyLookupFinancialBalance? balanceSheet;
    CompanyLookupFinancialCapital? capitalAndReserves;
    CompanyLookupFinancialOther? other;
    CompanyLookupFinancialCash? cash;
    CompanyLookupFinancialMisc? misc;
    CompanyLookupFinancialRatios? ratios;

    CompanyLookupEnhancedFinancialStatement({this.yearEndDateOrder,this.yearEndDate,this.summaryNumberOfWeeks,this.summaryCurrency,this.summaryConsolidatedAccount,this.profitAndLoss,this.balanceSheet,this.capitalAndReserves,this.other,this.cash,this.misc,this.ratios});
    CompanyLookupEnhancedFinancialStatement.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        yearEndDateOrder = json['yearEndDateOrder'];
        yearEndDate = JsonConverters.fromJson(json['yearEndDate'],'DateTime',context!);
        summaryNumberOfWeeks = json['summaryNumberOfWeeks'];
        summaryCurrency = json['summaryCurrency'];
        summaryConsolidatedAccount = json['summaryConsolidatedAccount'];
        profitAndLoss = JsonConverters.fromJson(json['profitAndLoss'],'CompanyLookupFinancialProfit',context!);
        balanceSheet = JsonConverters.fromJson(json['balanceSheet'],'CompanyLookupFinancialBalance',context!);
        capitalAndReserves = JsonConverters.fromJson(json['capitalAndReserves'],'CompanyLookupFinancialCapital',context!);
        other = JsonConverters.fromJson(json['other'],'CompanyLookupFinancialOther',context!);
        cash = JsonConverters.fromJson(json['cash'],'CompanyLookupFinancialCash',context!);
        misc = JsonConverters.fromJson(json['misc'],'CompanyLookupFinancialMisc',context!);
        ratios = JsonConverters.fromJson(json['ratios'],'CompanyLookupFinancialRatios',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'yearEndDateOrder': yearEndDateOrder,
        'yearEndDate': JsonConverters.toJson(yearEndDate,'DateTime',context!),
        'summaryNumberOfWeeks': summaryNumberOfWeeks,
        'summaryCurrency': summaryCurrency,
        'summaryConsolidatedAccount': summaryConsolidatedAccount,
        'profitAndLoss': JsonConverters.toJson(profitAndLoss,'CompanyLookupFinancialProfit',context!),
        'balanceSheet': JsonConverters.toJson(balanceSheet,'CompanyLookupFinancialBalance',context!),
        'capitalAndReserves': JsonConverters.toJson(capitalAndReserves,'CompanyLookupFinancialCapital',context!),
        'other': JsonConverters.toJson(other,'CompanyLookupFinancialOther',context!),
        'cash': JsonConverters.toJson(cash,'CompanyLookupFinancialCash',context!),
        'misc': JsonConverters.toJson(misc,'CompanyLookupFinancialMisc',context!),
        'ratios': JsonConverters.toJson(ratios,'CompanyLookupFinancialRatios',context!)
    };

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

class CompanyLookupEnhanced implements IConvertible
{
    CompanyLookupEnhancedSummary? summary;
    CompanyLookupEnhancedContactInfo? contactInformation;
    List<CompanyLookupEnhancedSicCode>? sicCodes;
    List<CompanyLookupEnhancedPreviousName>? previousNames;
    CompanyLookupEnhancedShareStructure? shareStructure;
    CompanyLookupEnhancedDirectors? directors;
    CompanyLookupEnhancedStructure? groupStructure;
    CompanyLookupEnhancedCCJs? countyCourtJudgements;
    List<CompanyLookupEnhancedEvent>? eventHistory;
    List<CompanyLookupEnhancedCommentary>? commentaries;
    CompanyLookupEnhancedCreditAccount? creditAccounts;
    List<CompanyLookupEnhancedFinancialStatement>? financialStatements;

    CompanyLookupEnhanced({this.summary,this.contactInformation,this.sicCodes,this.previousNames,this.shareStructure,this.directors,this.groupStructure,this.countyCourtJudgements,this.eventHistory,this.commentaries,this.creditAccounts,this.financialStatements});
    CompanyLookupEnhanced.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        summary = JsonConverters.fromJson(json['summary'],'CompanyLookupEnhancedSummary',context!);
        contactInformation = JsonConverters.fromJson(json['contactInformation'],'CompanyLookupEnhancedContactInfo',context!);
        sicCodes = JsonConverters.fromJson(json['sicCodes'],'List<CompanyLookupEnhancedSicCode>',context!);
        previousNames = JsonConverters.fromJson(json['previousNames'],'List<CompanyLookupEnhancedPreviousName>',context!);
        shareStructure = JsonConverters.fromJson(json['shareStructure'],'CompanyLookupEnhancedShareStructure',context!);
        directors = JsonConverters.fromJson(json['directors'],'CompanyLookupEnhancedDirectors',context!);
        groupStructure = JsonConverters.fromJson(json['groupStructure'],'CompanyLookupEnhancedStructure',context!);
        countyCourtJudgements = JsonConverters.fromJson(json['countyCourtJudgements'],'CompanyLookupEnhancedCCJs',context!);
        eventHistory = JsonConverters.fromJson(json['eventHistory'],'List<CompanyLookupEnhancedEvent>',context!);
        commentaries = JsonConverters.fromJson(json['commentaries'],'List<CompanyLookupEnhancedCommentary>',context!);
        creditAccounts = JsonConverters.fromJson(json['creditAccounts'],'CompanyLookupEnhancedCreditAccount',context!);
        financialStatements = JsonConverters.fromJson(json['financialStatements'],'List<CompanyLookupEnhancedFinancialStatement>',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'summary': JsonConverters.toJson(summary,'CompanyLookupEnhancedSummary',context!),
        'contactInformation': JsonConverters.toJson(contactInformation,'CompanyLookupEnhancedContactInfo',context!),
        'sicCodes': JsonConverters.toJson(sicCodes,'List<CompanyLookupEnhancedSicCode>',context!),
        'previousNames': JsonConverters.toJson(previousNames,'List<CompanyLookupEnhancedPreviousName>',context!),
        'shareStructure': JsonConverters.toJson(shareStructure,'CompanyLookupEnhancedShareStructure',context!),
        'directors': JsonConverters.toJson(directors,'CompanyLookupEnhancedDirectors',context!),
        'groupStructure': JsonConverters.toJson(groupStructure,'CompanyLookupEnhancedStructure',context!),
        'countyCourtJudgements': JsonConverters.toJson(countyCourtJudgements,'CompanyLookupEnhancedCCJs',context!),
        'eventHistory': JsonConverters.toJson(eventHistory,'List<CompanyLookupEnhancedEvent>',context!),
        'commentaries': JsonConverters.toJson(commentaries,'List<CompanyLookupEnhancedCommentary>',context!),
        'creditAccounts': JsonConverters.toJson(creditAccounts,'CompanyLookupEnhancedCreditAccount',context!),
        'financialStatements': JsonConverters.toJson(financialStatements,'List<CompanyLookupEnhancedFinancialStatement>',context!)
    };

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

class CompanyLookupSearchRecord implements IConvertible
{
    int? id;
    SearchCriteria? searchCriteria;
    ArrayOfLists? selectedLists;
    DateTime? date;
    bool? hasCompanyId;
    bool? hasCompanyDetails;
    bool? hasStartedSearches;
    bool? hasCompletedSearches;
    List<CompanyDirectorOrShareholder>? companyDirectorsAndShareholders;
    SearchListItem? companySearchRecord;
    bool? hasEnhancedInformation;
    CompanyLookupEnhanced? enhancedInformation;

    CompanyLookupSearchRecord({this.id,this.searchCriteria,this.selectedLists,this.date,this.hasCompanyId,this.hasCompanyDetails,this.hasStartedSearches,this.hasCompletedSearches,this.companyDirectorsAndShareholders,this.companySearchRecord,this.hasEnhancedInformation,this.enhancedInformation});
    CompanyLookupSearchRecord.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        id = json['id'];
        searchCriteria = JsonConverters.fromJson(json['searchCriteria'],'SearchCriteria',context!);
        selectedLists = JsonConverters.fromJson(json['selectedLists'],'ArrayOfLists',context!);
        date = JsonConverters.fromJson(json['date'],'DateTime',context!);
        hasCompanyId = json['hasCompanyId'];
        hasCompanyDetails = json['hasCompanyDetails'];
        hasStartedSearches = json['hasStartedSearches'];
        hasCompletedSearches = json['hasCompletedSearches'];
        companyDirectorsAndShareholders = JsonConverters.fromJson(json['companyDirectorsAndShareholders'],'List<CompanyDirectorOrShareholder>',context!);
        companySearchRecord = JsonConverters.fromJson(json['companySearchRecord'],'SearchListItem',context!);
        hasEnhancedInformation = json['hasEnhancedInformation'];
        enhancedInformation = JsonConverters.fromJson(json['enhancedInformation'],'CompanyLookupEnhanced',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'id': id,
        'searchCriteria': JsonConverters.toJson(searchCriteria,'SearchCriteria',context!),
        'selectedLists': JsonConverters.toJson(selectedLists,'ArrayOfLists',context!),
        'date': JsonConverters.toJson(date,'DateTime',context!),
        'hasCompanyId': hasCompanyId,
        'hasCompanyDetails': hasCompanyDetails,
        'hasStartedSearches': hasStartedSearches,
        'hasCompletedSearches': hasCompletedSearches,
        'companyDirectorsAndShareholders': JsonConverters.toJson(companyDirectorsAndShareholders,'List<CompanyDirectorOrShareholder>',context!),
        'companySearchRecord': JsonConverters.toJson(companySearchRecord,'SearchListItem',context!),
        'hasEnhancedInformation': hasEnhancedInformation,
        'enhancedInformation': JsonConverters.toJson(enhancedInformation,'CompanyLookupEnhanced',context!)
    };

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

class AddCompanyLookupData extends BaseResponse implements IBaseSearchResponse, IConvertible
{
    ArrayOfLinkedTo? linkedTo;
    CompanyLookupSearchRecord? searchRecord;

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

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

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

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

abstract class IBaseDataResponse
{
    ResponseStatus? responseStatus;
}

abstract class IHasResponseStatus
{
    ResponseStatus? responseStatus;
}

abstract class IBaseSearchResponse extends IBaseDataResponse
{
    ArrayOfLinkedTo? linkedTo;
}

// @DataContract
class AddCompanyLookupResponse implements IConvertible
{
    // @DataMember
    AddCompanyLookupData? data;

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

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

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

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

// @Route("/companylookups/create", "POST")
// @DataContract
class AddCompanyLookup extends BaseRequest implements IReturn<AddCompanyLookupResponse>, IConvertible, IPost
{
    // @DataMember
    AddCompanyLookupRequest? request;

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

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

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

    createResponse() => AddCompanyLookupResponse();
    getResponseTypeName() => "AddCompanyLookupResponse";
    getTypeName() => "AddCompanyLookup";
    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),
    'ArrayOfLists': TypeInfo(TypeOf.Class, create:() => ArrayOfLists()),
    'LinkedTo': TypeInfo(TypeOf.Class, create:() => LinkedTo()),
    'ArrayOfLinkedTo': TypeInfo(TypeOf.Class, create:() => ArrayOfLinkedTo()),
    'AddCompanyLookupRequest': TypeInfo(TypeOf.Class, create:() => AddCompanyLookupRequest()),
    'BaseResponse': TypeInfo(TypeOf.Class, create:() => BaseResponse()),
    'SearchCriteria': TypeInfo(TypeOf.Class, create:() => SearchCriteria()),
    'CompanyDirectorOrShareholder': TypeInfo(TypeOf.Class, create:() => CompanyDirectorOrShareholder()),
    'SearchSource': TypeInfo(TypeOf.Class, create:() => SearchSource()),
    'SearchListItem': TypeInfo(TypeOf.Class, create:() => SearchListItem()),
    'List<SearchSource>': TypeInfo(TypeOf.Class, create:() => <SearchSource>[]),
    'CompanyLookupEnhancedLatestAccounts': TypeInfo(TypeOf.Class, create:() => CompanyLookupEnhancedLatestAccounts()),
    'CompanyLookupEnhancedSummary': TypeInfo(TypeOf.Class, create:() => CompanyLookupEnhancedSummary()),
    'CompanyLookupEnhancedAddress': TypeInfo(TypeOf.Class, create:() => CompanyLookupEnhancedAddress()),
    'CompanyLookupEnhancedWebsite': TypeInfo(TypeOf.Class, create:() => CompanyLookupEnhancedWebsite()),
    'CompanyLookupEnhancedAdditionalContact': TypeInfo(TypeOf.Class, create:() => CompanyLookupEnhancedAdditionalContact()),
    'CompanyLookupEnhancedContactInfo': TypeInfo(TypeOf.Class, create:() => CompanyLookupEnhancedContactInfo()),
    'List<CompanyLookupEnhancedAddress>': TypeInfo(TypeOf.Class, create:() => <CompanyLookupEnhancedAddress>[]),
    'List<CompanyLookupEnhancedWebsite>': TypeInfo(TypeOf.Class, create:() => <CompanyLookupEnhancedWebsite>[]),
    'CompanyLookupEnhancedSicCode': TypeInfo(TypeOf.Class, create:() => CompanyLookupEnhancedSicCode()),
    'CompanyLookupEnhancedPreviousName': TypeInfo(TypeOf.Class, create:() => CompanyLookupEnhancedPreviousName()),
    'CompanyLookupEnhancedShareholder': TypeInfo(TypeOf.Class, create:() => CompanyLookupEnhancedShareholder()),
    'CompanyLookupEnhancedShareStructure': TypeInfo(TypeOf.Class, create:() => CompanyLookupEnhancedShareStructure()),
    'List<CompanyLookupEnhancedShareholder>': TypeInfo(TypeOf.Class, create:() => <CompanyLookupEnhancedShareholder>[]),
    'CompanyLookupEnhancedDirector': TypeInfo(TypeOf.Class, create:() => CompanyLookupEnhancedDirector()),
    'CompanyLookupEnhancedDirectors': TypeInfo(TypeOf.Class, create:() => CompanyLookupEnhancedDirectors()),
    'List<CompanyLookupEnhancedDirector>': TypeInfo(TypeOf.Class, create:() => <CompanyLookupEnhancedDirector>[]),
    'CompanyLookupEnhancedCompany': TypeInfo(TypeOf.Class, create:() => CompanyLookupEnhancedCompany()),
    'CompanyLookupEnhancedStructure': TypeInfo(TypeOf.Class, create:() => CompanyLookupEnhancedStructure()),
    'List<CompanyLookupEnhancedCompany>': TypeInfo(TypeOf.Class, create:() => <CompanyLookupEnhancedCompany>[]),
    'CompanyLookupEnhancedCCJ': TypeInfo(TypeOf.Class, create:() => CompanyLookupEnhancedCCJ()),
    'CompanyLookupEnhancedCCJs': TypeInfo(TypeOf.Class, create:() => CompanyLookupEnhancedCCJs()),
    'List<CompanyLookupEnhancedCCJ>': TypeInfo(TypeOf.Class, create:() => <CompanyLookupEnhancedCCJ>[]),
    'CompanyLookupEnhancedEvent': TypeInfo(TypeOf.Class, create:() => CompanyLookupEnhancedEvent()),
    'CompanyLookupEnhancedCommentary': TypeInfo(TypeOf.Class, create:() => CompanyLookupEnhancedCommentary()),
    'CompanyLookupEnhancedCreditLimit': TypeInfo(TypeOf.Class, create:() => CompanyLookupEnhancedCreditLimit()),
    'CompanyLookupEnhancedCreditRating': TypeInfo(TypeOf.Class, create:() => CompanyLookupEnhancedCreditRating()),
    'CompanyLookupEnhancedCreditAccount': TypeInfo(TypeOf.Class, create:() => CompanyLookupEnhancedCreditAccount()),
    'List<CompanyLookupEnhancedCreditLimit>': TypeInfo(TypeOf.Class, create:() => <CompanyLookupEnhancedCreditLimit>[]),
    'List<CompanyLookupEnhancedCreditRating>': TypeInfo(TypeOf.Class, create:() => <CompanyLookupEnhancedCreditRating>[]),
    'CompanyLookupFinancialProfit': TypeInfo(TypeOf.Class, create:() => CompanyLookupFinancialProfit()),
    'CompanyLookupFinancialBalance': TypeInfo(TypeOf.Class, create:() => CompanyLookupFinancialBalance()),
    'CompanyLookupFinancialCapital': TypeInfo(TypeOf.Class, create:() => CompanyLookupFinancialCapital()),
    'CompanyLookupFinancialOther': TypeInfo(TypeOf.Class, create:() => CompanyLookupFinancialOther()),
    'CompanyLookupFinancialCash': TypeInfo(TypeOf.Class, create:() => CompanyLookupFinancialCash()),
    'CompanyLookupFinancialMisc': TypeInfo(TypeOf.Class, create:() => CompanyLookupFinancialMisc()),
    'CompanyLookupFinancialRatios': TypeInfo(TypeOf.Class, create:() => CompanyLookupFinancialRatios()),
    'CompanyLookupEnhancedFinancialStatement': TypeInfo(TypeOf.Class, create:() => CompanyLookupEnhancedFinancialStatement()),
    'CompanyLookupEnhanced': TypeInfo(TypeOf.Class, create:() => CompanyLookupEnhanced()),
    'List<CompanyLookupEnhancedSicCode>': TypeInfo(TypeOf.Class, create:() => <CompanyLookupEnhancedSicCode>[]),
    'List<CompanyLookupEnhancedPreviousName>': TypeInfo(TypeOf.Class, create:() => <CompanyLookupEnhancedPreviousName>[]),
    'List<CompanyLookupEnhancedEvent>': TypeInfo(TypeOf.Class, create:() => <CompanyLookupEnhancedEvent>[]),
    'List<CompanyLookupEnhancedCommentary>': TypeInfo(TypeOf.Class, create:() => <CompanyLookupEnhancedCommentary>[]),
    'List<CompanyLookupEnhancedFinancialStatement>': TypeInfo(TypeOf.Class, create:() => <CompanyLookupEnhancedFinancialStatement>[]),
    'CompanyLookupSearchRecord': TypeInfo(TypeOf.Class, create:() => CompanyLookupSearchRecord()),
    'List<CompanyDirectorOrShareholder>': TypeInfo(TypeOf.Class, create:() => <CompanyDirectorOrShareholder>[]),
    'AddCompanyLookupData': TypeInfo(TypeOf.Class, create:() => AddCompanyLookupData()),
    'IBaseDataResponse': TypeInfo(TypeOf.Interface),
    'IHasResponseStatus': TypeInfo(TypeOf.Interface),
    'IBaseSearchResponse': TypeInfo(TypeOf.Interface),
    'AddCompanyLookupResponse': TypeInfo(TypeOf.Class, create:() => AddCompanyLookupResponse()),
    'AddCompanyLookup': TypeInfo(TypeOf.Class, create:() => AddCompanyLookup()),
});