/* Options:
Date: 2024-07-06 13:27:39
Version: 5.140
Tip: To override a DTO option, remove "//" prefix before updating
BaseUrl: http://abservice-featuretest.worldpay.com

//GlobalNamespace: 
//AddServiceStackTypes: True
//AddResponseStatus: False
//AddImplicitVersion: 
//AddDescriptionAsComments: True
IncludeTypes: ApplicationBoarding.*
//ExcludeTypes: 
//DefaultImports: package:servicestack/servicestack.dart
*/

import 'package:servicestack/servicestack.dart';

enum SourceSystemType
{
    MARS,
    ASA,
    OLS,
    INASA,
}

enum CustomerType
{
    New,
    Existing,
    None,
}

class Partner implements IConvertible
{
    String? partnerName;
    String? partnerId;

    Partner({this.partnerName,this.partnerId});
    Partner.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

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

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

enum PricingPackageType
{
    CustomUk,
    MonthlyUk,
    SimplicityUk,
    PaygUk,
    CustomRoi,
    PaygeComUK,
    None,
}

enum PreferredContactMethodType
{
    Email,
    Telephone,
    Any,
}

class ContactPerson implements IConvertible
{
    String? title;
    String? firstName;
    String? middleName;
    String? lastName;
    String? telephoneNumber;
    String? altTelephoneNumber;
    String? email;
    String? position;
    PreferredContactMethodType? preferredContactMethod;
    String? preferredContactBestTime;

    ContactPerson({this.title,this.firstName,this.middleName,this.lastName,this.telephoneNumber,this.altTelephoneNumber,this.email,this.position,this.preferredContactMethod,this.preferredContactBestTime});
    ContactPerson.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        title = json['title'];
        firstName = json['firstName'];
        middleName = json['middleName'];
        lastName = json['lastName'];
        telephoneNumber = json['telephoneNumber'];
        altTelephoneNumber = json['altTelephoneNumber'];
        email = json['email'];
        position = json['position'];
        preferredContactMethod = JsonConverters.fromJson(json['preferredContactMethod'],'PreferredContactMethodType',context!);
        preferredContactBestTime = json['preferredContactBestTime'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'title': title,
        'firstName': firstName,
        'middleName': middleName,
        'lastName': lastName,
        'telephoneNumber': telephoneNumber,
        'altTelephoneNumber': altTelephoneNumber,
        'email': email,
        'position': position,
        'preferredContactMethod': JsonConverters.toJson(preferredContactMethod,'PreferredContactMethodType',context!),
        'preferredContactBestTime': preferredContactBestTime
    };

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

class AuthorisedSigner extends Contact implements IConvertible
{
    DateTime? dateOfBirth;
    String? countryCode;

    AuthorisedSigner({this.dateOfBirth,this.countryCode});
    AuthorisedSigner.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

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

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

class AccessibilityOptions implements IConvertible
{
    bool? audiotapeRequired;
    bool? largePrintRequired;
    bool? uncontractedBrailleGrade1Required;
    bool? uncontractedBrailleGrade2Required;
    bool? nextGenerationTextRequired;

    AccessibilityOptions({this.audiotapeRequired,this.largePrintRequired,this.uncontractedBrailleGrade1Required,this.uncontractedBrailleGrade2Required,this.nextGenerationTextRequired});
    AccessibilityOptions.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        audiotapeRequired = json['audiotapeRequired'];
        largePrintRequired = json['largePrintRequired'];
        uncontractedBrailleGrade1Required = json['uncontractedBrailleGrade1Required'];
        uncontractedBrailleGrade2Required = json['uncontractedBrailleGrade2Required'];
        nextGenerationTextRequired = json['nextGenerationTextRequired'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'audiotapeRequired': audiotapeRequired,
        'largePrintRequired': largePrintRequired,
        'uncontractedBrailleGrade1Required': uncontractedBrailleGrade1Required,
        'uncontractedBrailleGrade2Required': uncontractedBrailleGrade2Required,
        'nextGenerationTextRequired': nextGenerationTextRequired
    };

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

class ApplicationDetails implements IConvertible
{
    SourceSystemType? sourceSystem;
    String? sourceSystemIdentifier;
    CustomerType? customerType;
    String? csr;
    Partner? partner;
    String? sellerCode;
    PricingPackageType? pricingPackage;
    AuthorisedSigner? contactPerson;
    String? specialInstructions;
    String? offerDetails;
    DateTime? dateContractAccepted;
    bool? worldpayBusinessFinanceInterest;
    bool? sar;
    String? sellerEmail;
    DateTime? anticipatedGoLiveDate;
    AccessibilityOptions? accessibilityOptions;
    String? ultimateParentId;

    ApplicationDetails({this.sourceSystem,this.sourceSystemIdentifier,this.customerType,this.csr,this.partner,this.sellerCode,this.pricingPackage,this.contactPerson,this.specialInstructions,this.offerDetails,this.dateContractAccepted,this.worldpayBusinessFinanceInterest,this.sar,this.sellerEmail,this.anticipatedGoLiveDate,this.accessibilityOptions,this.ultimateParentId});
    ApplicationDetails.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        sourceSystem = JsonConverters.fromJson(json['sourceSystem'],'SourceSystemType',context!);
        sourceSystemIdentifier = json['sourceSystemIdentifier'];
        customerType = JsonConverters.fromJson(json['customerType'],'CustomerType',context!);
        csr = json['csr'];
        partner = JsonConverters.fromJson(json['partner'],'Partner',context!);
        sellerCode = json['sellerCode'];
        pricingPackage = JsonConverters.fromJson(json['pricingPackage'],'PricingPackageType',context!);
        contactPerson = JsonConverters.fromJson(json['contactPerson'],'AuthorisedSigner',context!);
        specialInstructions = json['specialInstructions'];
        offerDetails = json['offerDetails'];
        dateContractAccepted = JsonConverters.fromJson(json['dateContractAccepted'],'DateTime',context!);
        worldpayBusinessFinanceInterest = json['worldpayBusinessFinanceInterest'];
        sar = json['sar'];
        sellerEmail = json['sellerEmail'];
        anticipatedGoLiveDate = JsonConverters.fromJson(json['anticipatedGoLiveDate'],'DateTime',context!);
        accessibilityOptions = JsonConverters.fromJson(json['accessibilityOptions'],'AccessibilityOptions',context!);
        ultimateParentId = json['ultimateParentId'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'sourceSystem': JsonConverters.toJson(sourceSystem,'SourceSystemType',context!),
        'sourceSystemIdentifier': sourceSystemIdentifier,
        'customerType': JsonConverters.toJson(customerType,'CustomerType',context!),
        'csr': csr,
        'partner': JsonConverters.toJson(partner,'Partner',context!),
        'sellerCode': sellerCode,
        'pricingPackage': JsonConverters.toJson(pricingPackage,'PricingPackageType',context!),
        'contactPerson': JsonConverters.toJson(contactPerson,'AuthorisedSigner',context!),
        'specialInstructions': specialInstructions,
        'offerDetails': offerDetails,
        'dateContractAccepted': JsonConverters.toJson(dateContractAccepted,'DateTime',context!),
        'worldpayBusinessFinanceInterest': worldpayBusinessFinanceInterest,
        'sar': sar,
        'sellerEmail': sellerEmail,
        'anticipatedGoLiveDate': JsonConverters.toJson(anticipatedGoLiveDate,'DateTime',context!),
        'accessibilityOptions': JsonConverters.toJson(accessibilityOptions,'AccessibilityOptions',context!),
        'ultimateParentId': ultimateParentId
    };

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

class Address implements IConvertible
{
    String? address1;
    String? address2;
    String? address3;
    String? postcode;
    String? city;
    String? state;
    String? countryCode;

    Address({this.address1,this.address2,this.address3,this.postcode,this.city,this.state,this.countryCode});
    Address.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        address1 = json['address1'];
        address2 = json['address2'];
        address3 = json['address3'];
        postcode = json['postcode'];
        city = json['city'];
        state = json['state'];
        countryCode = json['countryCode'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'address1': address1,
        'address2': address2,
        'address3': address3,
        'postcode': postcode,
        'city': city,
        'state': state,
        'countryCode': countryCode
    };

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

class BusinessAddress extends Address implements IConvertible
{
    bool? isCommercial;

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

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

    Map<String, dynamic> toJson() => super.toJson()..addAll({
        'isCommercial': isCommercial
    });

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

enum CompanyType
{
    SoleTrader,
    Partnership,
    LimitedCompany,
    Trust,
    RegisteredCharity,
    PublicLimitedCompany,
    LimitedByGuarantee,
    ClubSocietyAssociation,
    CommunityInterestCompanyOrIndustrialProvident,
    LimitedLiabilityPartnership,
    Other,
}

class Financials implements IConvertible
{
    double? annual;
    double? cardPercentage;
    double? creditCardPercentage;
    double? averageTransactionValue;

    Financials({this.annual,this.cardPercentage,this.creditCardPercentage,this.averageTransactionValue});
    Financials.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        annual = JsonConverters.toDouble(json['annual']);
        cardPercentage = JsonConverters.toDouble(json['cardPercentage']);
        creditCardPercentage = JsonConverters.toDouble(json['creditCardPercentage']);
        averageTransactionValue = JsonConverters.toDouble(json['averageTransactionValue']);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'annual': annual,
        'cardPercentage': cardPercentage,
        'creditCardPercentage': creditCardPercentage,
        'averageTransactionValue': averageTransactionValue
    };

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

class TradeAssociation implements IConvertible
{
    String? groupName;
    String? memberNumber;

    TradeAssociation({this.groupName,this.memberNumber});
    TradeAssociation.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

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

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

class Business implements IConvertible
{
    String? legalName;
    BusinessAddress? legalAddress;
    String? websiteAddress;
    CompanyType? companyType;
    String? companyTypeOther;
    String? companyRegistrationNumber;
    String? charityNumber;
    String? merchantCategoryCode;
    String? merchantCategoryDescription;
    String? descriptionOfGoodsAndServices;
    String? vatNumber;
    DateTime? dateStartedTrading;
    String? countryOfIncorporation;
    String? regionOfIncorporation;
    Financials? financials;
    bool? newToCards;
    TradeAssociation? tradeAssociation;

    Business({this.legalName,this.legalAddress,this.websiteAddress,this.companyType,this.companyTypeOther,this.companyRegistrationNumber,this.charityNumber,this.merchantCategoryCode,this.merchantCategoryDescription,this.descriptionOfGoodsAndServices,this.vatNumber,this.dateStartedTrading,this.countryOfIncorporation,this.regionOfIncorporation,this.financials,this.newToCards,this.tradeAssociation});
    Business.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        legalName = json['legalName'];
        legalAddress = JsonConverters.fromJson(json['legalAddress'],'BusinessAddress',context!);
        websiteAddress = json['websiteAddress'];
        companyType = JsonConverters.fromJson(json['companyType'],'CompanyType',context!);
        companyTypeOther = json['companyTypeOther'];
        companyRegistrationNumber = json['companyRegistrationNumber'];
        charityNumber = json['charityNumber'];
        merchantCategoryCode = json['merchantCategoryCode'];
        merchantCategoryDescription = json['merchantCategoryDescription'];
        descriptionOfGoodsAndServices = json['descriptionOfGoodsAndServices'];
        vatNumber = json['vatNumber'];
        dateStartedTrading = JsonConverters.fromJson(json['dateStartedTrading'],'DateTime',context!);
        countryOfIncorporation = json['countryOfIncorporation'];
        regionOfIncorporation = json['regionOfIncorporation'];
        financials = JsonConverters.fromJson(json['financials'],'Financials',context!);
        newToCards = json['newToCards'];
        tradeAssociation = JsonConverters.fromJson(json['tradeAssociation'],'TradeAssociation',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'legalName': legalName,
        'legalAddress': JsonConverters.toJson(legalAddress,'BusinessAddress',context!),
        'websiteAddress': websiteAddress,
        'companyType': JsonConverters.toJson(companyType,'CompanyType',context!),
        'companyTypeOther': companyTypeOther,
        'companyRegistrationNumber': companyRegistrationNumber,
        'charityNumber': charityNumber,
        'merchantCategoryCode': merchantCategoryCode,
        'merchantCategoryDescription': merchantCategoryDescription,
        'descriptionOfGoodsAndServices': descriptionOfGoodsAndServices,
        'vatNumber': vatNumber,
        'dateStartedTrading': JsonConverters.toJson(dateStartedTrading,'DateTime',context!),
        'countryOfIncorporation': countryOfIncorporation,
        'regionOfIncorporation': regionOfIncorporation,
        'financials': JsonConverters.toJson(financials,'Financials',context!),
        'newToCards': newToCards,
        'tradeAssociation': JsonConverters.toJson(tradeAssociation,'TradeAssociation',context!)
    };

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

class Principal extends Person implements IConvertible
{
    String? position;
    bool? isFinancialController;
    DateTime? dateOfBirth;
    String? nationality;
    double? ownershipPercentage;
    List<PrincipalAddress>? homeAddresses;
    List<PrincipalIdDocument>? principalIdDocuments;

    Principal({this.position,this.isFinancialController,this.dateOfBirth,this.nationality,this.ownershipPercentage,this.homeAddresses,this.principalIdDocuments});
    Principal.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        super.fromMap(json);
        position = json['position'];
        isFinancialController = json['isFinancialController'];
        dateOfBirth = JsonConverters.fromJson(json['dateOfBirth'],'DateTime',context!);
        nationality = json['nationality'];
        ownershipPercentage = JsonConverters.toDouble(json['ownershipPercentage']);
        homeAddresses = JsonConverters.fromJson(json['homeAddresses'],'List<PrincipalAddress>',context!);
        principalIdDocuments = JsonConverters.fromJson(json['principalIdDocuments'],'List<PrincipalIdDocument>',context!);
        return this;
    }

    Map<String, dynamic> toJson() => super.toJson()..addAll({
        'position': position,
        'isFinancialController': isFinancialController,
        'dateOfBirth': JsonConverters.toJson(dateOfBirth,'DateTime',context!),
        'nationality': nationality,
        'ownershipPercentage': ownershipPercentage,
        'homeAddresses': JsonConverters.toJson(homeAddresses,'List<PrincipalAddress>',context!),
        'principalIdDocuments': JsonConverters.toJson(principalIdDocuments,'List<PrincipalIdDocument>',context!)
    });

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

class BankAccount implements IConvertible
{
    String? sortCode;
    String? accountNumber;
    String? bankName;
    String? bankAccountName;

    BankAccount({this.sortCode,this.accountNumber,this.bankName,this.bankAccountName});
    BankAccount.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        sortCode = json['sortCode'];
        accountNumber = json['accountNumber'];
        bankName = json['bankName'];
        bankAccountName = json['bankAccountName'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'sortCode': sortCode,
        'accountNumber': accountNumber,
        'bankName': bankName,
        'bankAccountName': bankAccountName
    };

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

class ClearingDetails implements IConvertible
{
    String? merchantUrl;
    String? telephone;
    String? email;

    ClearingDetails({this.merchantUrl,this.telephone,this.email});
    ClearingDetails.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

    Map<String, dynamic> toJson() => {
        'merchantUrl': merchantUrl,
        'telephone': telephone,
        'email': email
    };

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

class OutletAllocatedProduct implements IConvertible
{
    int? id;
    int? quantity;

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

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

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

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

class Outlet implements IConvertible
{
    String? tradingName;
    BusinessAddress? tradingAddress;
    ContactPerson? contactPerson;
    BusinessAddress? terminalDeliveryAddress;
    BusinessAddress? correspondenceAddress;
    BankAccount? settlementBankAccount;
    BankAccount? chargesBankAccount;
    String? directDebitCorrespondenceEmail;
    ClearingDetails? clearingDetails;
    List<OutletAllocatedProduct>? productAllocation;

    Outlet({this.tradingName,this.tradingAddress,this.contactPerson,this.terminalDeliveryAddress,this.correspondenceAddress,this.settlementBankAccount,this.chargesBankAccount,this.directDebitCorrespondenceEmail,this.clearingDetails,this.productAllocation});
    Outlet.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        tradingName = json['tradingName'];
        tradingAddress = JsonConverters.fromJson(json['tradingAddress'],'BusinessAddress',context!);
        contactPerson = JsonConverters.fromJson(json['contactPerson'],'ContactPerson',context!);
        terminalDeliveryAddress = JsonConverters.fromJson(json['terminalDeliveryAddress'],'BusinessAddress',context!);
        correspondenceAddress = JsonConverters.fromJson(json['correspondenceAddress'],'BusinessAddress',context!);
        settlementBankAccount = JsonConverters.fromJson(json['settlementBankAccount'],'BankAccount',context!);
        chargesBankAccount = JsonConverters.fromJson(json['chargesBankAccount'],'BankAccount',context!);
        directDebitCorrespondenceEmail = json['directDebitCorrespondenceEmail'];
        clearingDetails = JsonConverters.fromJson(json['clearingDetails'],'ClearingDetails',context!);
        productAllocation = JsonConverters.fromJson(json['productAllocation'],'List<OutletAllocatedProduct>',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'tradingName': tradingName,
        'tradingAddress': JsonConverters.toJson(tradingAddress,'BusinessAddress',context!),
        'contactPerson': JsonConverters.toJson(contactPerson,'ContactPerson',context!),
        'terminalDeliveryAddress': JsonConverters.toJson(terminalDeliveryAddress,'BusinessAddress',context!),
        'correspondenceAddress': JsonConverters.toJson(correspondenceAddress,'BusinessAddress',context!),
        'settlementBankAccount': JsonConverters.toJson(settlementBankAccount,'BankAccount',context!),
        'chargesBankAccount': JsonConverters.toJson(chargesBankAccount,'BankAccount',context!),
        'directDebitCorrespondenceEmail': directDebitCorrespondenceEmail,
        'clearingDetails': JsonConverters.toJson(clearingDetails,'ClearingDetails',context!),
        'productAllocation': JsonConverters.toJson(productAllocation,'List<OutletAllocatedProduct>',context!)
    };

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

class GoodsAndServices implements IConvertible
{
    bool? goodsProvidedByThirdParty;
    Deposits? deposits;
    WarrantiesAndGuarantees? warrantiesAndGuarantees;
    Prepayments? prepayments;
    MembershipsSubscriptionAndInsurancePremiums? membershipsSubscriptionAndInsurancePremiums;
    Address? stockHeldAtAnotherAddressLocation;

    GoodsAndServices({this.goodsProvidedByThirdParty,this.deposits,this.warrantiesAndGuarantees,this.prepayments,this.membershipsSubscriptionAndInsurancePremiums,this.stockHeldAtAnotherAddressLocation});
    GoodsAndServices.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        goodsProvidedByThirdParty = json['goodsProvidedByThirdParty'];
        deposits = JsonConverters.fromJson(json['deposits'],'Deposits',context!);
        warrantiesAndGuarantees = JsonConverters.fromJson(json['warrantiesAndGuarantees'],'WarrantiesAndGuarantees',context!);
        prepayments = JsonConverters.fromJson(json['prepayments'],'Prepayments',context!);
        membershipsSubscriptionAndInsurancePremiums = JsonConverters.fromJson(json['membershipsSubscriptionAndInsurancePremiums'],'MembershipsSubscriptionAndInsurancePremiums',context!);
        stockHeldAtAnotherAddressLocation = JsonConverters.fromJson(json['stockHeldAtAnotherAddressLocation'],'Address',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'goodsProvidedByThirdParty': goodsProvidedByThirdParty,
        'deposits': JsonConverters.toJson(deposits,'Deposits',context!),
        'warrantiesAndGuarantees': JsonConverters.toJson(warrantiesAndGuarantees,'WarrantiesAndGuarantees',context!),
        'prepayments': JsonConverters.toJson(prepayments,'Prepayments',context!),
        'membershipsSubscriptionAndInsurancePremiums': JsonConverters.toJson(membershipsSubscriptionAndInsurancePremiums,'MembershipsSubscriptionAndInsurancePremiums',context!),
        'stockHeldAtAnotherAddressLocation': JsonConverters.toJson(stockHeldAtAnotherAddressLocation,'Address',context!)
    };

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

class MerchantDetails implements IConvertible
{
    Business? business;
    List<Principal>? principals;
    List<Outlet>? outlets;
    GoodsAndServices? goodsAndServices;

    MerchantDetails({this.business,this.principals,this.outlets,this.goodsAndServices});
    MerchantDetails.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        business = JsonConverters.fromJson(json['business'],'Business',context!);
        principals = JsonConverters.fromJson(json['principals'],'List<Principal>',context!);
        outlets = JsonConverters.fromJson(json['outlets'],'List<Outlet>',context!);
        goodsAndServices = JsonConverters.fromJson(json['goodsAndServices'],'GoodsAndServices',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'business': JsonConverters.toJson(business,'Business',context!),
        'principals': JsonConverters.toJson(principals,'List<Principal>',context!),
        'outlets': JsonConverters.toJson(outlets,'List<Outlet>',context!),
        'goodsAndServices': JsonConverters.toJson(goodsAndServices,'GoodsAndServices',context!)
    };

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

class Acquiring implements IConvertible
{
    int? settlementPeriod;
    String? fundingMode;
    Rates? rates;
    List<TradingCurrency>? tradingCurrencies;

    Acquiring({this.settlementPeriod,this.fundingMode,this.rates,this.tradingCurrencies});
    Acquiring.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        settlementPeriod = json['settlementPeriod'];
        fundingMode = json['fundingMode'];
        rates = JsonConverters.fromJson(json['rates'],'Rates',context!);
        tradingCurrencies = JsonConverters.fromJson(json['tradingCurrencies'],'List<TradingCurrency>',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'settlementPeriod': settlementPeriod,
        'fundingMode': fundingMode,
        'rates': JsonConverters.toJson(rates,'Rates',context!),
        'tradingCurrencies': JsonConverters.toJson(tradingCurrencies,'List<TradingCurrency>',context!)
    };

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

enum PosProductType
{
    Mobile,
    Wifi,
    Bluetooth,
    Fixed,
    PosMidOnly,
}

class ProductFee implements IConvertible
{
    String? type;
    double? cost;
    String? billingParty;

    ProductFee({this.type,this.cost,this.billingParty});
    ProductFee.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

    Map<String, dynamic> toJson() => {
        'type': type,
        'cost': cost,
        'billingParty': billingParty
    };

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

enum PosProductOptionType
{
    PSP,
}

class PosProductOption implements IConvertible
{
    PosProductOptionType? type;
    String? value;

    PosProductOption({this.type,this.value});
    PosProductOption.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

    Map<String, dynamic> toJson() => {
        'type': JsonConverters.toJson(type,'PosProductOptionType',context!),
        'value': value
    };

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

class PosProduct implements IConvertible
{
    int? id;
    PosProductType? type;
    int? quantity;
    List<ProductFee>? relatedFees;
    List<PosProductOption>? options;

    PosProduct({this.id,this.type,this.quantity,this.relatedFees,this.options});
    PosProduct.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        id = json['id'];
        type = JsonConverters.fromJson(json['type'],'PosProductType',context!);
        quantity = json['quantity'];
        relatedFees = JsonConverters.fromJson(json['relatedFees'],'List<ProductFee>',context!);
        options = JsonConverters.fromJson(json['options'],'List<PosProductOption>',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'id': id,
        'type': JsonConverters.toJson(type,'PosProductType',context!),
        'quantity': quantity,
        'relatedFees': JsonConverters.toJson(relatedFees,'List<ProductFee>',context!),
        'options': JsonConverters.toJson(options,'List<PosProductOption>',context!)
    };

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

class PosProducts implements IConvertible
{
    int? term;
    int? renewalLength;
    List<PosProduct>? products;

    PosProducts({this.term,this.renewalLength,this.products});
    PosProducts.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        term = json['term'];
        renewalLength = json['renewalLength'];
        products = JsonConverters.fromJson(json['products'],'List<PosProduct>',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'term': term,
        'renewalLength': renewalLength,
        'products': JsonConverters.toJson(products,'List<PosProduct>',context!)
    };

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

enum EcomProductType
{
    Gateway,
    VirtualTerminal,
    PayByLink,
    EcomMidOnly,
}

enum EcomProductOptionType
{
    PSP,
    FreeTransactions,
}

class EcomProductOption implements IConvertible
{
    EcomProductOptionType? type;
    String? value;

    EcomProductOption({this.type,this.value});
    EcomProductOption.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

    Map<String, dynamic> toJson() => {
        'type': JsonConverters.toJson(type,'EcomProductOptionType',context!),
        'value': value
    };

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

class EcomProduct implements IConvertible
{
    int? id;
    EcomProductType? type;
    int? quantity;
    List<ProductFee>? relatedFees;
    List<EcomProductOption>? options;

    EcomProduct({this.id,this.type,this.quantity,this.relatedFees,this.options});
    EcomProduct.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        id = json['id'];
        type = JsonConverters.fromJson(json['type'],'EcomProductType',context!);
        quantity = json['quantity'];
        relatedFees = JsonConverters.fromJson(json['relatedFees'],'List<ProductFee>',context!);
        options = JsonConverters.fromJson(json['options'],'List<EcomProductOption>',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'id': id,
        'type': JsonConverters.toJson(type,'EcomProductType',context!),
        'quantity': quantity,
        'relatedFees': JsonConverters.toJson(relatedFees,'List<ProductFee>',context!),
        'options': JsonConverters.toJson(options,'List<EcomProductOption>',context!)
    };

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

enum EcomOptionType
{
    Paypal,
    FuturePay,
    RMM,
}

class EcomOption implements IConvertible
{
    EcomOptionType? type;
    List<ProductFee>? relatedFees;

    EcomOption({this.type,this.relatedFees});
    EcomOption.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        type = JsonConverters.fromJson(json['type'],'EcomOptionType',context!);
        relatedFees = JsonConverters.fromJson(json['relatedFees'],'List<ProductFee>',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'type': JsonConverters.toJson(type,'EcomOptionType',context!),
        'relatedFees': JsonConverters.toJson(relatedFees,'List<ProductFee>',context!)
    };

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

class EcomProducts implements IConvertible
{
    int? term;
    int? renewalLength;
    List<EcomProduct>? products;
    List<EcomOption>? options;

    EcomProducts({this.term,this.renewalLength,this.products,this.options});
    EcomProducts.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        term = json['term'];
        renewalLength = json['renewalLength'];
        products = JsonConverters.fromJson(json['products'],'List<EcomProduct>',context!);
        options = JsonConverters.fromJson(json['options'],'List<EcomOption>',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'term': term,
        'renewalLength': renewalLength,
        'products': JsonConverters.toJson(products,'List<EcomProduct>',context!),
        'options': JsonConverters.toJson(options,'List<EcomOption>',context!)
    };

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

class IspContact implements IConvertible
{
    String? title;
    String? firstName;
    String? lastName;
    String? position;
    String? emailAddress;

    IspContact({this.title,this.firstName,this.lastName,this.position,this.emailAddress});
    IspContact.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        title = json['title'];
        firstName = json['firstName'];
        lastName = json['lastName'];
        position = json['position'];
        emailAddress = json['emailAddress'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'title': title,
        'firstName': firstName,
        'lastName': lastName,
        'position': position,
        'emailAddress': emailAddress
    };

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

class IntegratedSolutionProvider implements IConvertible
{
    String? name;
    Address? address;
    String? telephone;
    IspContact? primaryContact;
    IspContact? technicalContact;
    String? providerType;
    String? providerSoftware;

    IntegratedSolutionProvider({this.name,this.address,this.telephone,this.primaryContact,this.technicalContact,this.providerType,this.providerSoftware});
    IntegratedSolutionProvider.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        name = json['name'];
        address = JsonConverters.fromJson(json['address'],'Address',context!);
        telephone = json['telephone'];
        primaryContact = JsonConverters.fromJson(json['primaryContact'],'IspContact',context!);
        technicalContact = JsonConverters.fromJson(json['technicalContact'],'IspContact',context!);
        providerType = json['providerType'];
        providerSoftware = json['providerSoftware'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'name': name,
        'address': JsonConverters.toJson(address,'Address',context!),
        'telephone': telephone,
        'primaryContact': JsonConverters.toJson(primaryContact,'IspContact',context!),
        'technicalContact': JsonConverters.toJson(technicalContact,'IspContact',context!),
        'providerType': providerType,
        'providerSoftware': providerSoftware
    };

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

enum WptProductType
{
    VerifoneP400,
    IngenicoWL258,
    VerifoneV240,
}

enum WptVariantType
{
    Serial,
    Usb,
    Ethernet,
    None,
}

class WptProduct implements IConvertible
{
    WptProductType? type;
    int? id;
    WptVariantType? variant;
    int? quantity;
    List<ProductFee>? relatedFees;

    WptProduct({this.type,this.id,this.variant,this.quantity,this.relatedFees});
    WptProduct.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        type = JsonConverters.fromJson(json['type'],'WptProductType',context!);
        id = json['id'];
        variant = JsonConverters.fromJson(json['variant'],'WptVariantType',context!);
        quantity = json['quantity'];
        relatedFees = JsonConverters.fromJson(json['relatedFees'],'List<ProductFee>',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'type': JsonConverters.toJson(type,'WptProductType',context!),
        'id': id,
        'variant': JsonConverters.toJson(variant,'WptVariantType',context!),
        'quantity': quantity,
        'relatedFees': JsonConverters.toJson(relatedFees,'List<ProductFee>',context!)
    };

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

class WptProducts implements IConvertible
{
    int? term;
    int? renewalLength;
    DateTime? posInstallationDate;
    IntegratedSolutionProvider? integratedSolutionProvider;
    List<WptProduct>? products;

    WptProducts({this.term,this.renewalLength,this.posInstallationDate,this.integratedSolutionProvider,this.products});
    WptProducts.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        term = json['term'];
        renewalLength = json['renewalLength'];
        posInstallationDate = JsonConverters.fromJson(json['posInstallationDate'],'DateTime',context!);
        integratedSolutionProvider = JsonConverters.fromJson(json['integratedSolutionProvider'],'IntegratedSolutionProvider',context!);
        products = JsonConverters.fromJson(json['products'],'List<WptProduct>',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'term': term,
        'renewalLength': renewalLength,
        'posInstallationDate': JsonConverters.toJson(posInstallationDate,'DateTime',context!),
        'integratedSolutionProvider': JsonConverters.toJson(integratedSolutionProvider,'IntegratedSolutionProvider',context!),
        'products': JsonConverters.toJson(products,'List<WptProduct>',context!)
    };

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

enum IpProductType
{
    PaxA920,
    MiuraM020,
}

enum IpVariantType
{
    Sdk,
    Cloud,
    None,
}

class IpProduct implements IConvertible
{
    int? id;
    IpProductType? type;
    int? quantity;
    List<ProductFee>? relatedFees;
    IpVariantType? variant;

    IpProduct({this.id,this.type,this.quantity,this.relatedFees,this.variant});
    IpProduct.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        id = json['id'];
        type = JsonConverters.fromJson(json['type'],'IpProductType',context!);
        quantity = json['quantity'];
        relatedFees = JsonConverters.fromJson(json['relatedFees'],'List<ProductFee>',context!);
        variant = JsonConverters.fromJson(json['variant'],'IpVariantType',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'id': id,
        'type': JsonConverters.toJson(type,'IpProductType',context!),
        'quantity': quantity,
        'relatedFees': JsonConverters.toJson(relatedFees,'List<ProductFee>',context!),
        'variant': JsonConverters.toJson(variant,'IpVariantType',context!)
    };

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

class IpProducts implements IConvertible
{
    int? term;
    int? renewalLength;
    IntegratedSolutionProvider? integratedSolutionProvider;
    List<IpProduct>? products;

    IpProducts({this.term,this.renewalLength,this.integratedSolutionProvider,this.products});
    IpProducts.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        term = json['term'];
        renewalLength = json['renewalLength'];
        integratedSolutionProvider = JsonConverters.fromJson(json['integratedSolutionProvider'],'IntegratedSolutionProvider',context!);
        products = JsonConverters.fromJson(json['products'],'List<IpProduct>',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'term': term,
        'renewalLength': renewalLength,
        'integratedSolutionProvider': JsonConverters.toJson(integratedSolutionProvider,'IntegratedSolutionProvider',context!),
        'products': JsonConverters.toJson(products,'List<IpProduct>',context!)
    };

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

class Products implements IConvertible
{
    PosProducts? posProducts;
    EcomProducts? ecomProducts;
    WptProducts? wptProducts;
    IpProducts? ipProducts;

    Products({this.posProducts,this.ecomProducts,this.wptProducts,this.ipProducts});
    Products.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        posProducts = JsonConverters.fromJson(json['posProducts'],'PosProducts',context!);
        ecomProducts = JsonConverters.fromJson(json['ecomProducts'],'EcomProducts',context!);
        wptProducts = JsonConverters.fromJson(json['wptProducts'],'WptProducts',context!);
        ipProducts = JsonConverters.fromJson(json['ipProducts'],'IpProducts',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'posProducts': JsonConverters.toJson(posProducts,'PosProducts',context!),
        'ecomProducts': JsonConverters.toJson(ecomProducts,'EcomProducts',context!),
        'wptProducts': JsonConverters.toJson(wptProducts,'WptProducts',context!),
        'ipProducts': JsonConverters.toJson(ipProducts,'IpProducts',context!)
    };

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

class Application implements IConvertible
{
    ApplicationDetails? applicationDetails;
    MerchantDetails? merchantDetails;
    Acquiring? acquiring;
    Products? products;

    Application({this.applicationDetails,this.merchantDetails,this.acquiring,this.products});
    Application.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        applicationDetails = JsonConverters.fromJson(json['applicationDetails'],'ApplicationDetails',context!);
        merchantDetails = JsonConverters.fromJson(json['merchantDetails'],'MerchantDetails',context!);
        acquiring = JsonConverters.fromJson(json['acquiring'],'Acquiring',context!);
        products = JsonConverters.fromJson(json['products'],'Products',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'applicationDetails': JsonConverters.toJson(applicationDetails,'ApplicationDetails',context!),
        'merchantDetails': JsonConverters.toJson(merchantDetails,'MerchantDetails',context!),
        'acquiring': JsonConverters.toJson(acquiring,'Acquiring',context!),
        'products': JsonConverters.toJson(products,'Products',context!)
    };

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

// @DataContract
enum ApplicationQueueStatus
{
    Queued,
    StandardisedXML,
    ReadyToDistribute,
    AwaitingDistributeResponse,
    ReadyToAutoboard,
    ThrottleCheckPassed,
    EligibilityCheckPassed,
    SentToAutoboardService,
    AutoboardingSuspended,
    SuccessfullyBoarded,
    QueueError,
    ThrottleCheckError,
    XMLStandardisationError,
    EligibilityCheckError,
    AutoboardingError,
    IneligibleThrottleLimit,
    IneligibleApplication,
}

// @DataContract
enum ApplicationBoardingStatus
{
    PENDING,
    IN_PROGRESS,
    FAILED,
    COMPLETED,
}

class Acquiring implements IConvertible
{
    int? settlementPeriodTPlus;
    Rates? rates;
    Services? services;
    List<TradingCurrency>? tradingCurrencies;

    Acquiring({this.settlementPeriodTPlus,this.rates,this.services,this.tradingCurrencies});
    Acquiring.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        settlementPeriodTPlus = json['settlementPeriodTPlus'];
        rates = JsonConverters.fromJson(json['rates'],'Rates',context!);
        services = JsonConverters.fromJson(json['services'],'Services',context!);
        tradingCurrencies = JsonConverters.fromJson(json['tradingCurrencies'],'List<TradingCurrency>',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'settlementPeriodTPlus': settlementPeriodTPlus,
        'rates': JsonConverters.toJson(rates,'Rates',context!),
        'services': JsonConverters.toJson(services,'Services',context!),
        'tradingCurrencies': JsonConverters.toJson(tradingCurrencies,'List<TradingCurrency>',context!)
    };

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

class Partner implements IConvertible
{
    String? partnerId;
    String? partnerName;

    Partner({this.partnerId,this.partnerName});
    Partner.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

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

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

class AuthorisedSigner extends ContactPerson implements IConvertible
{
    DateTime? dateOfBirth;
    String? countryCode;

    AuthorisedSigner({this.dateOfBirth,this.countryCode});
    AuthorisedSigner.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

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

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

class AccessibilityOptions implements IConvertible
{
    bool? audiotapeRequired;
    bool? largePrintRequired;
    bool? uncontractedBrailleGrade1Required;
    bool? uncontractedBrailleGrade2Required;
    bool? nextGenerationTextRequired;

    AccessibilityOptions({this.audiotapeRequired,this.largePrintRequired,this.uncontractedBrailleGrade1Required,this.uncontractedBrailleGrade2Required,this.nextGenerationTextRequired});
    AccessibilityOptions.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        audiotapeRequired = json['audiotapeRequired'];
        largePrintRequired = json['largePrintRequired'];
        uncontractedBrailleGrade1Required = json['uncontractedBrailleGrade1Required'];
        uncontractedBrailleGrade2Required = json['uncontractedBrailleGrade2Required'];
        nextGenerationTextRequired = json['nextGenerationTextRequired'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'audiotapeRequired': audiotapeRequired,
        'largePrintRequired': largePrintRequired,
        'uncontractedBrailleGrade1Required': uncontractedBrailleGrade1Required,
        'uncontractedBrailleGrade2Required': uncontractedBrailleGrade2Required,
        'nextGenerationTextRequired': nextGenerationTextRequired
    };

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

class Principal implements IConvertible
{
    String? title;
    String? firstName;
    String? middleName;
    String? lastName;
    DateTime? dateOfBirth;
    String? nationality;
    List<PrincipalAddress>? homeAddresses;
    double? ownershipPercentage;
    PositionType? position;
    bool? isFinancialController;

    Principal({this.title,this.firstName,this.middleName,this.lastName,this.dateOfBirth,this.nationality,this.homeAddresses,this.ownershipPercentage,this.position,this.isFinancialController});
    Principal.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        title = json['title'];
        firstName = json['firstName'];
        middleName = json['middleName'];
        lastName = json['lastName'];
        dateOfBirth = JsonConverters.fromJson(json['dateOfBirth'],'DateTime',context!);
        nationality = json['nationality'];
        homeAddresses = JsonConverters.fromJson(json['homeAddresses'],'List<PrincipalAddress>',context!);
        ownershipPercentage = JsonConverters.toDouble(json['ownershipPercentage']);
        position = JsonConverters.fromJson(json['position'],'PositionType',context!);
        isFinancialController = json['isFinancialController'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'title': title,
        'firstName': firstName,
        'middleName': middleName,
        'lastName': lastName,
        'dateOfBirth': JsonConverters.toJson(dateOfBirth,'DateTime',context!),
        'nationality': nationality,
        'homeAddresses': JsonConverters.toJson(homeAddresses,'List<PrincipalAddress>',context!),
        'ownershipPercentage': ownershipPercentage,
        'position': JsonConverters.toJson(position,'PositionType',context!),
        'isFinancialController': isFinancialController
    };

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

class GoodsAndServices implements IConvertible
{
    bool? goodsProvidedByThirdParty;
    Deposits? deposits;
    WarrantiesAndGuarantees? warrantiesAndGuarantees;
    Prepayments? prepayments;
    MembershipsSubscriptionAndInsurancePremiums? membershipsSubscriptionAndInsurancePremiums;
    Address? stockHeldAtAnotherAddressLocation;

    GoodsAndServices({this.goodsProvidedByThirdParty,this.deposits,this.warrantiesAndGuarantees,this.prepayments,this.membershipsSubscriptionAndInsurancePremiums,this.stockHeldAtAnotherAddressLocation});
    GoodsAndServices.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        goodsProvidedByThirdParty = json['goodsProvidedByThirdParty'];
        deposits = JsonConverters.fromJson(json['deposits'],'Deposits',context!);
        warrantiesAndGuarantees = JsonConverters.fromJson(json['warrantiesAndGuarantees'],'WarrantiesAndGuarantees',context!);
        prepayments = JsonConverters.fromJson(json['prepayments'],'Prepayments',context!);
        membershipsSubscriptionAndInsurancePremiums = JsonConverters.fromJson(json['membershipsSubscriptionAndInsurancePremiums'],'MembershipsSubscriptionAndInsurancePremiums',context!);
        stockHeldAtAnotherAddressLocation = JsonConverters.fromJson(json['stockHeldAtAnotherAddressLocation'],'Address',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'goodsProvidedByThirdParty': goodsProvidedByThirdParty,
        'deposits': JsonConverters.toJson(deposits,'Deposits',context!),
        'warrantiesAndGuarantees': JsonConverters.toJson(warrantiesAndGuarantees,'WarrantiesAndGuarantees',context!),
        'prepayments': JsonConverters.toJson(prepayments,'Prepayments',context!),
        'membershipsSubscriptionAndInsurancePremiums': JsonConverters.toJson(membershipsSubscriptionAndInsurancePremiums,'MembershipsSubscriptionAndInsurancePremiums',context!),
        'stockHeldAtAnotherAddressLocation': JsonConverters.toJson(stockHeldAtAnotherAddressLocation,'Address',context!)
    };

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

class BankAccount implements IConvertible
{
    String? sortCode;
    String? accountNumber;
    String? bankName;
    String? bankAccountName;
    String? swiftCode;
    String? internationalBankAccountNumber;

    BankAccount({this.sortCode,this.accountNumber,this.bankName,this.bankAccountName,this.swiftCode,this.internationalBankAccountNumber});
    BankAccount.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        sortCode = json['sortCode'];
        accountNumber = json['accountNumber'];
        bankName = json['bankName'];
        bankAccountName = json['bankAccountName'];
        swiftCode = json['swiftCode'];
        internationalBankAccountNumber = json['internationalBankAccountNumber'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'sortCode': sortCode,
        'accountNumber': accountNumber,
        'bankName': bankName,
        'bankAccountName': bankAccountName,
        'swiftCode': swiftCode,
        'internationalBankAccountNumber': internationalBankAccountNumber
    };

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

class Financials implements IConvertible
{
    double? annual;
    double? cardPercentage;
    double? creditCardPercentage;
    double? averageTransactionValue;
    double? cardNotPresentPercentage;

    Financials({this.annual,this.cardPercentage,this.creditCardPercentage,this.averageTransactionValue,this.cardNotPresentPercentage});
    Financials.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        annual = JsonConverters.toDouble(json['annual']);
        cardPercentage = JsonConverters.toDouble(json['cardPercentage']);
        creditCardPercentage = JsonConverters.toDouble(json['creditCardPercentage']);
        averageTransactionValue = JsonConverters.toDouble(json['averageTransactionValue']);
        cardNotPresentPercentage = JsonConverters.toDouble(json['cardNotPresentPercentage']);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'annual': annual,
        'cardPercentage': cardPercentage,
        'creditCardPercentage': creditCardPercentage,
        'averageTransactionValue': averageTransactionValue,
        'cardNotPresentPercentage': cardNotPresentPercentage
    };

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

class TradeAssociation implements IConvertible
{
    String? groupName;
    String? memberNumber;

    TradeAssociation({this.groupName,this.memberNumber});
    TradeAssociation.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

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

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

class ClearingDetails implements IConvertible
{
    String? merchantUrl;
    String? telephone;
    String? email;

    ClearingDetails({this.merchantUrl,this.telephone,this.email});
    ClearingDetails.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

    Map<String, dynamic> toJson() => {
        'merchantUrl': merchantUrl,
        'telephone': telephone,
        'email': email
    };

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

class Address implements IConvertible
{
    String? address1;
    String? address2;
    String? address3;
    String? postcode;
    String? city;
    String? state;
    String? countrycode;

    Address({this.address1,this.address2,this.address3,this.postcode,this.city,this.state,this.countrycode});
    Address.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        address1 = json['address1'];
        address2 = json['address2'];
        address3 = json['address3'];
        postcode = json['postcode'];
        city = json['city'];
        state = json['state'];
        countrycode = json['countrycode'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'address1': address1,
        'address2': address2,
        'address3': address3,
        'postcode': postcode,
        'city': city,
        'state': state,
        'countrycode': countrycode
    };

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

class ProductFee implements IConvertible
{
    ProductFeeType? type;
    double? cost;

    ProductFee({this.type,this.cost});
    ProductFee.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

    Map<String, dynamic> toJson() => {
        'type': JsonConverters.toJson(type,'ProductFeeType',context!),
        'cost': cost
    };

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

class InitiateBoardingResponse implements IConvertible
{
    String? applicationGuid;
    int? csr;
    String? applicationQueueGuid;
    ApplicationQueueStatus? queueStatus;
    ApplicationBoardingStatus? boardingStatus;
    List<String>? errorMessages;

    InitiateBoardingResponse({this.applicationGuid,this.csr,this.applicationQueueGuid,this.queueStatus,this.boardingStatus,this.errorMessages});
    InitiateBoardingResponse.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        applicationGuid = json['applicationGuid'];
        csr = json['csr'];
        applicationQueueGuid = json['applicationQueueGuid'];
        queueStatus = JsonConverters.fromJson(json['queueStatus'],'ApplicationQueueStatus',context!);
        boardingStatus = JsonConverters.fromJson(json['boardingStatus'],'ApplicationBoardingStatus',context!);
        errorMessages = JsonConverters.fromJson(json['errorMessages'],'List<String>',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'applicationGuid': applicationGuid,
        'csr': csr,
        'applicationQueueGuid': applicationQueueGuid,
        'queueStatus': JsonConverters.toJson(queueStatus,'ApplicationQueueStatus',context!),
        'boardingStatus': JsonConverters.toJson(boardingStatus,'ApplicationBoardingStatus',context!),
        'errorMessages': JsonConverters.toJson(errorMessages,'List<String>',context!)
    };

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

// @Route("/ApplicationBoarding", "POST")
class ApplicationBoarding implements IReturn<InitiateBoardingResponse>, IConvertible
{
    String? correlationId;
    int? csr;
    String? sellerCode;
    String? sellerEmail;
    int? applicationSource;
    Application? applicationJson;

    ApplicationBoarding({this.correlationId,this.csr,this.sellerCode,this.sellerEmail,this.applicationSource,this.applicationJson});
    ApplicationBoarding.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        correlationId = json['correlationId'];
        csr = json['csr'];
        sellerCode = json['sellerCode'];
        sellerEmail = json['sellerEmail'];
        applicationSource = json['applicationSource'];
        applicationJson = JsonConverters.fromJson(json['applicationJson'],'Application',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'correlationId': correlationId,
        'csr': csr,
        'sellerCode': sellerCode,
        'sellerEmail': sellerEmail,
        'applicationSource': applicationSource,
        'applicationJson': JsonConverters.toJson(applicationJson,'Application',context!)
    };

    createResponse() => InitiateBoardingResponse();
    getResponseTypeName() => "InitiateBoardingResponse";
    getTypeName() => "ApplicationBoarding";
    TypeContext? context = _ctx;
}

TypeContext _ctx = TypeContext(library: 'abservice_featuretest.worldpay.com', types: <String, TypeInfo> {
    'SourceSystemType': TypeInfo(TypeOf.Enum, enumValues:SourceSystemType.values),
    'CustomerType': TypeInfo(TypeOf.Enum, enumValues:CustomerType.values),
    'Partner': TypeInfo(TypeOf.Class, create:() => Partner()),
    'PricingPackageType': TypeInfo(TypeOf.Enum, enumValues:PricingPackageType.values),
    'PreferredContactMethodType': TypeInfo(TypeOf.Enum, enumValues:PreferredContactMethodType.values),
    'ContactPerson': TypeInfo(TypeOf.Class, create:() => ContactPerson()),
    'AuthorisedSigner': TypeInfo(TypeOf.Class, create:() => AuthorisedSigner()),
    'AccessibilityOptions': TypeInfo(TypeOf.Class, create:() => AccessibilityOptions()),
    'ApplicationDetails': TypeInfo(TypeOf.Class, create:() => ApplicationDetails()),
    'Address': TypeInfo(TypeOf.Class, create:() => Address()),
    'BusinessAddress': TypeInfo(TypeOf.Class, create:() => BusinessAddress()),
    'CompanyType': TypeInfo(TypeOf.Enum, enumValues:CompanyType.values),
    'Financials': TypeInfo(TypeOf.Class, create:() => Financials()),
    'TradeAssociation': TypeInfo(TypeOf.Class, create:() => TradeAssociation()),
    'Business': TypeInfo(TypeOf.Class, create:() => Business()),
    'Principal': TypeInfo(TypeOf.Class, create:() => Principal()),
    'List<PrincipalAddress>': TypeInfo(TypeOf.Class, create:() => <PrincipalAddress>[]),
    'PrincipalAddress': TypeInfo(TypeOf.Class, create:() => PrincipalAddress()),
    'List<PrincipalIdDocument>': TypeInfo(TypeOf.Class, create:() => <PrincipalIdDocument>[]),
    'PrincipalIdDocument': TypeInfo(TypeOf.Class, create:() => PrincipalIdDocument()),
    'BankAccount': TypeInfo(TypeOf.Class, create:() => BankAccount()),
    'ClearingDetails': TypeInfo(TypeOf.Class, create:() => ClearingDetails()),
    'OutletAllocatedProduct': TypeInfo(TypeOf.Class, create:() => OutletAllocatedProduct()),
    'Outlet': TypeInfo(TypeOf.Class, create:() => Outlet()),
    'List<OutletAllocatedProduct>': TypeInfo(TypeOf.Class, create:() => <OutletAllocatedProduct>[]),
    'GoodsAndServices': TypeInfo(TypeOf.Class, create:() => GoodsAndServices()),
    'Deposits': TypeInfo(TypeOf.Class, create:() => Deposits()),
    'WarrantiesAndGuarantees': TypeInfo(TypeOf.Class, create:() => WarrantiesAndGuarantees()),
    'Prepayments': TypeInfo(TypeOf.Class, create:() => Prepayments()),
    'MembershipsSubscriptionAndInsurancePremiums': TypeInfo(TypeOf.Class, create:() => MembershipsSubscriptionAndInsurancePremiums()),
    'MerchantDetails': TypeInfo(TypeOf.Class, create:() => MerchantDetails()),
    'List<Principal>': TypeInfo(TypeOf.Class, create:() => <Principal>[]),
    'List<Outlet>': TypeInfo(TypeOf.Class, create:() => <Outlet>[]),
    'Acquiring': TypeInfo(TypeOf.Class, create:() => Acquiring()),
    'Rates': TypeInfo(TypeOf.Class, create:() => Rates()),
    'List<TradingCurrency>': TypeInfo(TypeOf.Class, create:() => <TradingCurrency>[]),
    'TradingCurrency': TypeInfo(TypeOf.Class, create:() => TradingCurrency()),
    'PosProductType': TypeInfo(TypeOf.Enum, enumValues:PosProductType.values),
    'ProductFee': TypeInfo(TypeOf.Class, create:() => ProductFee()),
    'PosProductOptionType': TypeInfo(TypeOf.Enum, enumValues:PosProductOptionType.values),
    'PosProductOption': TypeInfo(TypeOf.Class, create:() => PosProductOption()),
    'PosProduct': TypeInfo(TypeOf.Class, create:() => PosProduct()),
    'List<ProductFee>': TypeInfo(TypeOf.Class, create:() => <ProductFee>[]),
    'List<PosProductOption>': TypeInfo(TypeOf.Class, create:() => <PosProductOption>[]),
    'PosProducts': TypeInfo(TypeOf.Class, create:() => PosProducts()),
    'List<PosProduct>': TypeInfo(TypeOf.Class, create:() => <PosProduct>[]),
    'EcomProductType': TypeInfo(TypeOf.Enum, enumValues:EcomProductType.values),
    'EcomProductOptionType': TypeInfo(TypeOf.Enum, enumValues:EcomProductOptionType.values),
    'EcomProductOption': TypeInfo(TypeOf.Class, create:() => EcomProductOption()),
    'EcomProduct': TypeInfo(TypeOf.Class, create:() => EcomProduct()),
    'List<EcomProductOption>': TypeInfo(TypeOf.Class, create:() => <EcomProductOption>[]),
    'EcomOptionType': TypeInfo(TypeOf.Enum, enumValues:EcomOptionType.values),
    'EcomOption': TypeInfo(TypeOf.Class, create:() => EcomOption()),
    'EcomProducts': TypeInfo(TypeOf.Class, create:() => EcomProducts()),
    'List<EcomProduct>': TypeInfo(TypeOf.Class, create:() => <EcomProduct>[]),
    'List<EcomOption>': TypeInfo(TypeOf.Class, create:() => <EcomOption>[]),
    'IspContact': TypeInfo(TypeOf.Class, create:() => IspContact()),
    'IntegratedSolutionProvider': TypeInfo(TypeOf.Class, create:() => IntegratedSolutionProvider()),
    'WptProductType': TypeInfo(TypeOf.Enum, enumValues:WptProductType.values),
    'WptVariantType': TypeInfo(TypeOf.Enum, enumValues:WptVariantType.values),
    'WptProduct': TypeInfo(TypeOf.Class, create:() => WptProduct()),
    'WptProducts': TypeInfo(TypeOf.Class, create:() => WptProducts()),
    'List<WptProduct>': TypeInfo(TypeOf.Class, create:() => <WptProduct>[]),
    'IpProductType': TypeInfo(TypeOf.Enum, enumValues:IpProductType.values),
    'IpVariantType': TypeInfo(TypeOf.Enum, enumValues:IpVariantType.values),
    'IpProduct': TypeInfo(TypeOf.Class, create:() => IpProduct()),
    'IpProducts': TypeInfo(TypeOf.Class, create:() => IpProducts()),
    'List<IpProduct>': TypeInfo(TypeOf.Class, create:() => <IpProduct>[]),
    'Products': TypeInfo(TypeOf.Class, create:() => Products()),
    'Application': TypeInfo(TypeOf.Class, create:() => Application()),
    'ApplicationQueueStatus': TypeInfo(TypeOf.Enum, enumValues:ApplicationQueueStatus.values),
    'ApplicationBoardingStatus': TypeInfo(TypeOf.Enum, enumValues:ApplicationBoardingStatus.values),
    'Services': TypeInfo(TypeOf.Class, create:() => Services()),
    'PositionType': TypeInfo(TypeOf.Class, create:() => PositionType()),
    'ProductFeeType': TypeInfo(TypeOf.Class, create:() => ProductFeeType()),
    'InitiateBoardingResponse': TypeInfo(TypeOf.Class, create:() => InitiateBoardingResponse()),
    'ApplicationBoarding': TypeInfo(TypeOf.Class, create:() => ApplicationBoarding()),
});