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

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

import 'package:servicestack/servicestack.dart';

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

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

class ApplicationDetails implements IConvertible
{
    String? specialInstructions;
    bool? typeAcquiring;
    bool? typePOS_F2F;
    bool? typePOS_MOTO;
    bool? typeOnlinePayments;
    bool? typeVirtualTerminal;
    String? sellerCode;
    int? numOutlets;
    String? mccCode;
    String? offerDescription;
    String? pricingPackage;
    int? contractLength;
    String? settlementPeriodTPlus;
    String? ecomPSP;
    String? posPSP;

    ApplicationDetails({this.specialInstructions,this.typeAcquiring,this.typePOS_F2F,this.typePOS_MOTO,this.typeOnlinePayments,this.typeVirtualTerminal,this.sellerCode,this.numOutlets,this.mccCode,this.offerDescription,this.pricingPackage,this.contractLength,this.settlementPeriodTPlus,this.ecomPSP,this.posPSP});
    ApplicationDetails.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        specialInstructions = json['specialInstructions'];
        typeAcquiring = json['typeAcquiring'];
        typePOS_F2F = json['typePOS_F2F'];
        typePOS_MOTO = json['typePOS_MOTO'];
        typeOnlinePayments = json['typeOnlinePayments'];
        typeVirtualTerminal = json['typeVirtualTerminal'];
        sellerCode = json['sellerCode'];
        numOutlets = json['numOutlets'];
        mccCode = json['mccCode'];
        offerDescription = json['offerDescription'];
        pricingPackage = json['pricingPackage'];
        contractLength = json['contractLength'];
        settlementPeriodTPlus = json['settlementPeriodTPlus'];
        ecomPSP = json['ecomPSP'];
        posPSP = json['posPSP'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'specialInstructions': specialInstructions,
        'typeAcquiring': typeAcquiring,
        'typePOS_F2F': typePOS_F2F,
        'typePOS_MOTO': typePOS_MOTO,
        'typeOnlinePayments': typeOnlinePayments,
        'typeVirtualTerminal': typeVirtualTerminal,
        'sellerCode': sellerCode,
        'numOutlets': numOutlets,
        'mccCode': mccCode,
        'offerDescription': offerDescription,
        'pricingPackage': pricingPackage,
        'contractLength': contractLength,
        'settlementPeriodTPlus': settlementPeriodTPlus,
        'ecomPSP': ecomPSP,
        'posPSP': posPSP
    };

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

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 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 StandardResponse implements IConvertible
{
    int? Status;
    String? CorrelationId;
    String? Message;

    StandardResponse({this.Status,this.CorrelationId,this.Message});
    StandardResponse.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

    Map<String, dynamic> toJson() => {
        'Status': Status,
        'CorrelationId': CorrelationId,
        'Message': Message
    };

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

// @Route("/allchecks/submit/json", "POST")
class AllChecksApplicationDataRequest implements IReturn<StandardResponse>, IConvertible
{
    Application? Application;
    String? CorrelationId;
    String? NapPartyId;
    String? LEID;
    String? OrderId;
    List<String>? PartyIndividuals;

    AllChecksApplicationDataRequest({this.Application,this.CorrelationId,this.NapPartyId,this.LEID,this.OrderId,this.PartyIndividuals});
    AllChecksApplicationDataRequest.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Application = JsonConverters.fromJson(json['Application'],'Application',context!);
        CorrelationId = json['CorrelationId'];
        NapPartyId = json['NapPartyId'];
        LEID = json['LEID'];
        OrderId = json['OrderId'];
        PartyIndividuals = JsonConverters.fromJson(json['PartyIndividuals'],'List<String>',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'Application': JsonConverters.toJson(Application,'Application',context!),
        'CorrelationId': CorrelationId,
        'NapPartyId': NapPartyId,
        'LEID': LEID,
        'OrderId': OrderId,
        'PartyIndividuals': JsonConverters.toJson(PartyIndividuals,'List<String>',context!)
    };

    createResponse() => StandardResponse();
    getResponseTypeName() => "StandardResponse";
    getTypeName() => "AllChecksApplicationDataRequest";
    TypeContext? context = _ctx;
}

TypeContext _ctx = TypeContext(library: 'wpcdd_featuretest_ws.worldpay.com', types: <String, TypeInfo> {
    'ApplicationDetails': TypeInfo(TypeOf.Class, create:() => ApplicationDetails()),
    'SourceSystemType': TypeInfo(TypeOf.Class, create:() => SourceSystemType()),
    'CustomerType': TypeInfo(TypeOf.Class, create:() => CustomerType()),
    'Partner': TypeInfo(TypeOf.Class, create:() => Partner()),
    'PricingPackageType': TypeInfo(TypeOf.Class, create:() => PricingPackageType()),
    'AuthorisedSigner': TypeInfo(TypeOf.Class, create:() => AuthorisedSigner()),
    'AccessibilityOptions': TypeInfo(TypeOf.Class, create:() => AccessibilityOptions()),
    '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()),
    'PreferredContactMethodType': TypeInfo(TypeOf.Enum, enumValues:PreferredContactMethodType.values),
    'ContactPerson': TypeInfo(TypeOf.Class, create:() => ContactPerson()),
    '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()),
    'Services': TypeInfo(TypeOf.Class, create:() => Services()),
    'PositionType': TypeInfo(TypeOf.Class, create:() => PositionType()),
    'ProductFeeType': TypeInfo(TypeOf.Class, create:() => ProductFeeType()),
    'StandardResponse': TypeInfo(TypeOf.Class, create:() => StandardResponse()),
    'AllChecksApplicationDataRequest': TypeInfo(TypeOf.Class, create:() => AllChecksApplicationDataRequest()),
});