| POST | /OrderBoarding |
|---|
import 'package:servicestack/servicestack.dart';
// @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 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;
}
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;
}
class Person implements IConvertible
{
String? title;
String? firstName;
String? middleName;
String? lastName;
Person({this.title,this.firstName,this.middleName,this.lastName});
Person.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
title = json['title'];
firstName = json['firstName'];
middleName = json['middleName'];
lastName = json['lastName'];
return this;
}
Map<String, dynamic> toJson() => {
'title': title,
'firstName': firstName,
'middleName': middleName,
'lastName': lastName
};
getTypeName() => "Person";
TypeContext? context = _ctx;
}
class Contact extends Person implements IConvertible
{
String? idpGuid;
String? telephoneNumber;
String? altTelephoneNumber;
String? email;
String? position;
String? preferredContactMethod;
String? preferredContactBestTime;
Contact({this.idpGuid,this.telephoneNumber,this.altTelephoneNumber,this.email,this.position,this.preferredContactMethod,this.preferredContactBestTime});
Contact.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
super.fromMap(json);
idpGuid = json['idpGuid'];
telephoneNumber = json['telephoneNumber'];
altTelephoneNumber = json['altTelephoneNumber'];
email = json['email'];
position = json['position'];
preferredContactMethod = json['preferredContactMethod'];
preferredContactBestTime = json['preferredContactBestTime'];
return this;
}
Map<String, dynamic> toJson() => super.toJson()..addAll({
'idpGuid': idpGuid,
'telephoneNumber': telephoneNumber,
'altTelephoneNumber': altTelephoneNumber,
'email': email,
'position': position,
'preferredContactMethod': preferredContactMethod,
'preferredContactBestTime': preferredContactBestTime
});
getTypeName() => "Contact";
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 OrderMeta implements IConvertible
{
String? sourceSystem;
String? sourceSystemIdentifier;
String? csr;
String? ultimateParentId;
String? orderType;
String? customerType;
Partner? partner;
String? sellerCode;
String? sellerEmail;
String? specialInstructions;
AuthorisedSigner? contact;
String? offerDetails;
DateTime? dateContractAccepted;
bool? worldpayBusinessFinanceInterest;
bool? sar;
bool? hasSupportingFiles;
OrderMeta({this.sourceSystem,this.sourceSystemIdentifier,this.csr,this.ultimateParentId,this.orderType,this.customerType,this.partner,this.sellerCode,this.sellerEmail,this.specialInstructions,this.contact,this.offerDetails,this.dateContractAccepted,this.worldpayBusinessFinanceInterest,this.sar,this.hasSupportingFiles});
OrderMeta.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
sourceSystem = json['sourceSystem'];
sourceSystemIdentifier = json['sourceSystemIdentifier'];
csr = json['csr'];
ultimateParentId = json['ultimateParentId'];
orderType = json['orderType'];
customerType = json['customerType'];
partner = JsonConverters.fromJson(json['partner'],'Partner',context!);
sellerCode = json['sellerCode'];
sellerEmail = json['sellerEmail'];
specialInstructions = json['specialInstructions'];
contact = JsonConverters.fromJson(json['contact'],'AuthorisedSigner',context!);
offerDetails = json['offerDetails'];
dateContractAccepted = JsonConverters.fromJson(json['dateContractAccepted'],'DateTime',context!);
worldpayBusinessFinanceInterest = json['worldpayBusinessFinanceInterest'];
sar = json['sar'];
hasSupportingFiles = json['hasSupportingFiles'];
return this;
}
Map<String, dynamic> toJson() => {
'sourceSystem': sourceSystem,
'sourceSystemIdentifier': sourceSystemIdentifier,
'csr': csr,
'ultimateParentId': ultimateParentId,
'orderType': orderType,
'customerType': customerType,
'partner': JsonConverters.toJson(partner,'Partner',context!),
'sellerCode': sellerCode,
'sellerEmail': sellerEmail,
'specialInstructions': specialInstructions,
'contact': JsonConverters.toJson(contact,'AuthorisedSigner',context!),
'offerDetails': offerDetails,
'dateContractAccepted': JsonConverters.toJson(dateContractAccepted,'DateTime',context!),
'worldpayBusinessFinanceInterest': worldpayBusinessFinanceInterest,
'sar': sar,
'hasSupportingFiles': hasSupportingFiles
};
getTypeName() => "OrderMeta";
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 MerchantAddress extends Address implements IConvertible
{
String? addressType;
bool? isCommercial;
MerchantAddress({this.addressType,this.isCommercial});
MerchantAddress.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
super.fromMap(json);
addressType = json['addressType'];
isCommercial = json['isCommercial'];
return this;
}
Map<String, dynamic> toJson() => super.toJson()..addAll({
'addressType': addressType,
'isCommercial': isCommercial
});
getTypeName() => "MerchantAddress";
TypeContext? context = _ctx;
}
class InvoiceContact extends Person implements IConvertible
{
String? email;
String? position;
InvoiceContact({this.email,this.position});
InvoiceContact.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
super.fromMap(json);
email = json['email'];
position = json['position'];
return this;
}
Map<String, dynamic> toJson() => super.toJson()..addAll({
'email': email,
'position': position
});
getTypeName() => "InvoiceContact";
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 MerchantCategory implements IConvertible
{
String? merchantCategoryCode;
String? merchantCategoryDescription;
String? descriptionOfGoodsAndServices;
MerchantCategory({this.merchantCategoryCode,this.merchantCategoryDescription,this.descriptionOfGoodsAndServices});
MerchantCategory.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
merchantCategoryCode = json['merchantCategoryCode'];
merchantCategoryDescription = json['merchantCategoryDescription'];
descriptionOfGoodsAndServices = json['descriptionOfGoodsAndServices'];
return this;
}
Map<String, dynamic> toJson() => {
'merchantCategoryCode': merchantCategoryCode,
'merchantCategoryDescription': merchantCategoryDescription,
'descriptionOfGoodsAndServices': descriptionOfGoodsAndServices
};
getTypeName() => "MerchantCategory";
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 PrincipalAddress extends Address implements IConvertible
{
DateTime? startDate;
DateTime? endDate;
PrincipalAddress({this.startDate,this.endDate});
PrincipalAddress.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
super.fromMap(json);
startDate = JsonConverters.fromJson(json['startDate'],'DateTime',context!);
endDate = JsonConverters.fromJson(json['endDate'],'DateTime',context!);
return this;
}
Map<String, dynamic> toJson() => super.toJson()..addAll({
'startDate': JsonConverters.toJson(startDate,'DateTime',context!),
'endDate': JsonConverters.toJson(endDate,'DateTime',context!)
});
getTypeName() => "PrincipalAddress";
TypeContext? context = _ctx;
}
enum PositionType
{
SoleTrader,
Partner,
Director,
CompanySecretary,
ChiefFinancialOfficer,
Chairman,
DesignatedBoardMember,
Settlor,
Treasurer,
Trustee,
ChiefExecutive,
AuthorisedPersonWithConsent,
NonExecutiveDirector,
ContactPerson,
Shareholder,
}
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 Deposits implements IConvertible
{
int? perOfSalesWhereInitialDepositTaken;
int? sizePerTotalValue;
int? avgTimeBeforeDeliveryDepositTaken;
int? avgTimeBeforeDeliveryBalanceTaken;
Deposits({this.perOfSalesWhereInitialDepositTaken,this.sizePerTotalValue,this.avgTimeBeforeDeliveryDepositTaken,this.avgTimeBeforeDeliveryBalanceTaken});
Deposits.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
perOfSalesWhereInitialDepositTaken = json['perOfSalesWhereInitialDepositTaken'];
sizePerTotalValue = json['sizePerTotalValue'];
avgTimeBeforeDeliveryDepositTaken = json['avgTimeBeforeDeliveryDepositTaken'];
avgTimeBeforeDeliveryBalanceTaken = json['avgTimeBeforeDeliveryBalanceTaken'];
return this;
}
Map<String, dynamic> toJson() => {
'perOfSalesWhereInitialDepositTaken': perOfSalesWhereInitialDepositTaken,
'sizePerTotalValue': sizePerTotalValue,
'avgTimeBeforeDeliveryDepositTaken': avgTimeBeforeDeliveryDepositTaken,
'avgTimeBeforeDeliveryBalanceTaken': avgTimeBeforeDeliveryBalanceTaken
};
getTypeName() => "Deposits";
TypeContext? context = _ctx;
}
class WarrantiesAndGuarantees implements IConvertible
{
int? percCardTurnover;
int? avgLengthInMonths;
int? percGoodsReturned;
String? thirdPartyProviders;
WarrantiesAndGuarantees({this.percCardTurnover,this.avgLengthInMonths,this.percGoodsReturned,this.thirdPartyProviders});
WarrantiesAndGuarantees.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
percCardTurnover = json['percCardTurnover'];
avgLengthInMonths = json['avgLengthInMonths'];
percGoodsReturned = json['percGoodsReturned'];
thirdPartyProviders = json['thirdPartyProviders'];
return this;
}
Map<String, dynamic> toJson() => {
'percCardTurnover': percCardTurnover,
'avgLengthInMonths': avgLengthInMonths,
'percGoodsReturned': percGoodsReturned,
'thirdPartyProviders': thirdPartyProviders
};
getTypeName() => "WarrantiesAndGuarantees";
TypeContext? context = _ctx;
}
class Prepayments implements IConvertible
{
int? percGoodsWherePaymentTakenPriorToDelivery;
int? avgDaysPaymentTakenInAdvance;
Prepayments({this.percGoodsWherePaymentTakenPriorToDelivery,this.avgDaysPaymentTakenInAdvance});
Prepayments.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
percGoodsWherePaymentTakenPriorToDelivery = json['percGoodsWherePaymentTakenPriorToDelivery'];
avgDaysPaymentTakenInAdvance = json['avgDaysPaymentTakenInAdvance'];
return this;
}
Map<String, dynamic> toJson() => {
'percGoodsWherePaymentTakenPriorToDelivery': percGoodsWherePaymentTakenPriorToDelivery,
'avgDaysPaymentTakenInAdvance': avgDaysPaymentTakenInAdvance
};
getTypeName() => "Prepayments";
TypeContext? context = _ctx;
}
class MembershipsSubscriptionAndInsurancePremiums implements IConvertible
{
int? percCardTurnover;
int? avgLengthInMonths;
double? membershipCost;
MembershipsSubscriptionAndInsurancePremiums({this.percCardTurnover,this.avgLengthInMonths,this.membershipCost});
MembershipsSubscriptionAndInsurancePremiums.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
percCardTurnover = json['percCardTurnover'];
avgLengthInMonths = json['avgLengthInMonths'];
membershipCost = JsonConverters.toDouble(json['membershipCost']);
return this;
}
Map<String, dynamic> toJson() => {
'percCardTurnover': percCardTurnover,
'avgLengthInMonths': avgLengthInMonths,
'membershipCost': membershipCost
};
getTypeName() => "MembershipsSubscriptionAndInsurancePremiums";
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 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 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;
}
enum CardType
{
VisaDebit,
VisaCredit,
VisaCommercial,
MastercardDebit,
MastercardCredit,
MastercardCommercial,
MastercardWorldSignia,
JcbCredit,
JcbDebit,
JcbCommercial,
DinersDiscoverCredit,
DinersDiscoverDebit,
DinersDiscoverCommercial,
Amex,
ChinaUnionPayCredit,
ChinaUnionPayDebit,
ChinaUnionPayCommercial,
VisaBusinessDebit,
MastercardBusiness,
}
class RateChargePair implements IConvertible
{
double? percent;
double? cost;
RateChargePair({this.percent,this.cost});
RateChargePair.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
percent = JsonConverters.toDouble(json['percent']);
cost = JsonConverters.toDouble(json['cost']);
return this;
}
Map<String, dynamic> toJson() => {
'percent': percent,
'cost': cost
};
getTypeName() => "RateChargePair";
TypeContext? context = _ctx;
}
class CardCharge implements IConvertible
{
CardType? cardType;
RateChargePair? purchase;
RateChargePair? refund;
CardCharge({this.cardType,this.purchase,this.refund});
CardCharge.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
cardType = JsonConverters.fromJson(json['cardType'],'CardType',context!);
purchase = JsonConverters.fromJson(json['purchase'],'RateChargePair',context!);
refund = JsonConverters.fromJson(json['refund'],'RateChargePair',context!);
return this;
}
Map<String, dynamic> toJson() => {
'cardType': JsonConverters.toJson(cardType,'CardType',context!),
'purchase': JsonConverters.toJson(purchase,'RateChargePair',context!),
'refund': JsonConverters.toJson(refund,'RateChargePair',context!)
};
getTypeName() => "CardCharge";
TypeContext? context = _ctx;
}
enum PremiumTransactionChargeType
{
Magstripe,
CnpMoto,
Paper,
PanKeyEntry,
SecureEcom,
NonSecureEcom,
InterRegional,
IntraRegional,
NonAuth,
}
class PremiumTransactionCharge implements IConvertible
{
PremiumTransactionChargeType? type;
RateChargePair? creditCard;
RateChargePair? debitCard;
PremiumTransactionCharge({this.type,this.creditCard,this.debitCard});
PremiumTransactionCharge.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
type = JsonConverters.fromJson(json['type'],'PremiumTransactionChargeType',context!);
creditCard = JsonConverters.fromJson(json['creditCard'],'RateChargePair',context!);
debitCard = JsonConverters.fromJson(json['debitCard'],'RateChargePair',context!);
return this;
}
Map<String, dynamic> toJson() => {
'type': JsonConverters.toJson(type,'PremiumTransactionChargeType',context!),
'creditCard': JsonConverters.toJson(creditCard,'RateChargePair',context!),
'debitCard': JsonConverters.toJson(debitCard,'RateChargePair',context!)
};
getTypeName() => "PremiumTransactionCharge";
TypeContext? context = _ctx;
}
class AdditionalTariff implements IConvertible
{
String? type;
double? cost;
AdditionalTariff({this.type,this.cost});
AdditionalTariff.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
type = json['type'];
cost = JsonConverters.toDouble(json['cost']);
return this;
}
Map<String, dynamic> toJson() => {
'type': type,
'cost': cost
};
getTypeName() => "AdditionalTariff";
TypeContext? context = _ctx;
}
class Rates implements IConvertible
{
List<CardCharge>? cardCharges;
List<PremiumTransactionCharge>? premiumTransactionCharges;
List<AdditionalTariff>? additionalTariffs;
Rates({this.cardCharges,this.premiumTransactionCharges,this.additionalTariffs});
Rates.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
cardCharges = JsonConverters.fromJson(json['cardCharges'],'List<CardCharge>',context!);
premiumTransactionCharges = JsonConverters.fromJson(json['premiumTransactionCharges'],'List<PremiumTransactionCharge>',context!);
additionalTariffs = JsonConverters.fromJson(json['additionalTariffs'],'List<AdditionalTariff>',context!);
return this;
}
Map<String, dynamic> toJson() => {
'cardCharges': JsonConverters.toJson(cardCharges,'List<CardCharge>',context!),
'premiumTransactionCharges': JsonConverters.toJson(premiumTransactionCharges,'List<PremiumTransactionCharge>',context!),
'additionalTariffs': JsonConverters.toJson(additionalTariffs,'List<AdditionalTariff>',context!)
};
getTypeName() => "Rates";
TypeContext? context = _ctx;
}
enum CurrencyCodeType
{
GBP,
EUR,
USD,
AED,
AFN,
ALL,
AMD,
ANG,
AOA,
ARS,
AUD,
AWG,
AZN,
BAM,
BBD,
BDT,
BGN,
BHD,
BIF,
BMD,
BND,
BOB,
BRL,
BSD,
BTN,
BWP,
BYR,
BZD,
CAD,
CDF,
CHF,
CLP,
CNY,
COP,
COU,
CRC,
CUC,
CUP,
CVE,
CZK,
DJF,
DKK,
DOP,
DZD,
EEK,
EGP,
ERN,
ETB,
FJD,
FKP,
GEL,
GHS,
GIP,
GMD,
GNF,
GTQ,
GYD,
HKD,
HNL,
HRK,
HTG,
HUF,
IDR,
ILS,
INR,
IQD,
IRR,
ISK,
JMD,
JOD,
JPY,
KES,
KGS,
KHR,
KMF,
KPW,
KRW,
KWD,
KYD,
KZT,
LAK,
LBP,
LKR,
LRD,
LSL,
LTL,
LVL,
LYD,
MAD,
MDL,
MGA,
MKD,
MMK,
MNT,
MOP,
MRO,
MUR,
MVR,
MWK,
MXN,
MYR,
MZN,
NAD,
NGN,
NIO,
NOK,
NPR,
NZD,
OMR,
PAB,
PEN,
PGK,
PHP,
PKR,
PLN,
PYG,
QAR,
RON,
RSD,
RUB,
RWF,
SAR,
SBD,
SCR,
SDG,
SEK,
SGD,
SHP,
SLL,
SOS,
SRD,
STD,
SYP,
SZL,
THB,
TJS,
TMT,
TND,
TOP,
TRY,
TTD,
TWD,
TZS,
UAH,
UGX,
UYU,
UZS,
VEF,
VND,
VUV,
WST,
YER,
ZAR,
ZMK,
ZWL,
}
class TradingCurrency implements IConvertible
{
List<CurrencyCodeType>? transactionCurrencies;
CurrencyCodeType? settlementCurrency;
String? settlementBankSwift;
String? settlementBankIban;
TradingCurrency({this.transactionCurrencies,this.settlementCurrency,this.settlementBankSwift,this.settlementBankIban});
TradingCurrency.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
transactionCurrencies = JsonConverters.fromJson(json['transactionCurrencies'],'List<CurrencyCodeType>',context!);
settlementCurrency = JsonConverters.fromJson(json['settlementCurrency'],'CurrencyCodeType',context!);
settlementBankSwift = json['settlementBankSwift'];
settlementBankIban = json['settlementBankIban'];
return this;
}
Map<String, dynamic> toJson() => {
'transactionCurrencies': JsonConverters.toJson(transactionCurrencies,'List<CurrencyCodeType>',context!),
'settlementCurrency': JsonConverters.toJson(settlementCurrency,'CurrencyCodeType',context!),
'settlementBankSwift': settlementBankSwift,
'settlementBankIban': settlementBankIban
};
getTypeName() => "TradingCurrency";
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 ProductFeeType
{
HireCost,
TransactionCost,
ServiceFee,
ManagedServiceSetup,
ManagedServiceMonthly,
}
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 ProductOption implements IConvertible
{
String? type;
String? value;
ProductOption({this.type,this.value});
ProductOption.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
type = json['type'];
value = json['value'];
return this;
}
Map<String, dynamic> toJson() => {
'type': type,
'value': value
};
getTypeName() => "ProductOption";
TypeContext? context = _ctx;
}
class Product implements IConvertible
{
String? name;
String? type;
String? variant;
int? quantity;
List<ProductFee>? relatedFees;
List<ProductOption>? options;
Product({this.name,this.type,this.variant,this.quantity,this.relatedFees,this.options});
Product.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
name = json['name'];
type = json['type'];
variant = json['variant'];
quantity = json['quantity'];
relatedFees = JsonConverters.fromJson(json['relatedFees'],'List<ProductFee>',context!);
options = JsonConverters.fromJson(json['options'],'List<ProductOption>',context!);
return this;
}
Map<String, dynamic> toJson() => {
'name': name,
'type': type,
'variant': variant,
'quantity': quantity,
'relatedFees': JsonConverters.toJson(relatedFees,'List<ProductFee>',context!),
'options': JsonConverters.toJson(options,'List<ProductOption>',context!)
};
getTypeName() => "Product";
TypeContext? context = _ctx;
}
class Subscription implements IConvertible
{
String? proposition;
String? pricingPackage;
int? term;
int? renewalLength;
Acquiring? acquiring;
List<Product>? products;
Subscription({this.proposition,this.pricingPackage,this.term,this.renewalLength,this.acquiring,this.products});
Subscription.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
proposition = json['proposition'];
pricingPackage = json['pricingPackage'];
term = json['term'];
renewalLength = json['renewalLength'];
acquiring = JsonConverters.fromJson(json['acquiring'],'Acquiring',context!);
products = JsonConverters.fromJson(json['products'],'List<Product>',context!);
return this;
}
Map<String, dynamic> toJson() => {
'proposition': proposition,
'pricingPackage': pricingPackage,
'term': term,
'renewalLength': renewalLength,
'acquiring': JsonConverters.toJson(acquiring,'Acquiring',context!),
'products': JsonConverters.toJson(products,'List<Product>',context!)
};
getTypeName() => "Subscription";
TypeContext? context = _ctx;
}
class OrderPayload implements IConvertible
{
String? partyId;
String? parentPartyId;
String? legalName;
String? tradingName;
List<MerchantAddress>? addresses;
Contact? tradingContact;
InvoiceContact? invoiceContact;
BankAccount? settlementBankAccount;
BankAccount? chargesBankAccount;
String? directDebitCorrespondenceEmail;
String? websiteAddress;
String? companyType;
String? companyTypeOther;
String? companyRegistrationNumber;
String? charityNumber;
List<MerchantCategory>? merchantCategories;
String? vatNumber;
DateTime? dateStartedTrading;
DateTime? anticipatedGoLiveDate;
String? countryOfIncorporation;
String? regionOfIncorporation;
Financials? financials;
bool? newToCards;
TradeAssociation? tradeAssociation;
List<Principal>? principals;
GoodsAndServices? goodsAndServices;
AccessibilityOptions? accessibilityOptions;
ClearingDetails? clearingDetails;
Acquiring? acquiring;
List<Subscription>? subscriptions;
List<OrderPayload>? children;
OrderPayload({this.partyId,this.parentPartyId,this.legalName,this.tradingName,this.addresses,this.tradingContact,this.invoiceContact,this.settlementBankAccount,this.chargesBankAccount,this.directDebitCorrespondenceEmail,this.websiteAddress,this.companyType,this.companyTypeOther,this.companyRegistrationNumber,this.charityNumber,this.merchantCategories,this.vatNumber,this.dateStartedTrading,this.anticipatedGoLiveDate,this.countryOfIncorporation,this.regionOfIncorporation,this.financials,this.newToCards,this.tradeAssociation,this.principals,this.goodsAndServices,this.accessibilityOptions,this.clearingDetails,this.acquiring,this.subscriptions,this.children});
OrderPayload.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
partyId = json['partyId'];
parentPartyId = json['parentPartyId'];
legalName = json['legalName'];
tradingName = json['tradingName'];
addresses = JsonConverters.fromJson(json['addresses'],'List<MerchantAddress>',context!);
tradingContact = JsonConverters.fromJson(json['tradingContact'],'Contact',context!);
invoiceContact = JsonConverters.fromJson(json['invoiceContact'],'InvoiceContact',context!);
settlementBankAccount = JsonConverters.fromJson(json['settlementBankAccount'],'BankAccount',context!);
chargesBankAccount = JsonConverters.fromJson(json['chargesBankAccount'],'BankAccount',context!);
directDebitCorrespondenceEmail = json['directDebitCorrespondenceEmail'];
websiteAddress = json['websiteAddress'];
companyType = json['companyType'];
companyTypeOther = json['companyTypeOther'];
companyRegistrationNumber = json['companyRegistrationNumber'];
charityNumber = json['charityNumber'];
merchantCategories = JsonConverters.fromJson(json['merchantCategories'],'List<MerchantCategory>',context!);
vatNumber = json['vatNumber'];
dateStartedTrading = JsonConverters.fromJson(json['dateStartedTrading'],'DateTime',context!);
anticipatedGoLiveDate = JsonConverters.fromJson(json['anticipatedGoLiveDate'],'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!);
principals = JsonConverters.fromJson(json['principals'],'List<Principal>',context!);
goodsAndServices = JsonConverters.fromJson(json['goodsAndServices'],'GoodsAndServices',context!);
accessibilityOptions = JsonConverters.fromJson(json['accessibilityOptions'],'AccessibilityOptions',context!);
clearingDetails = JsonConverters.fromJson(json['clearingDetails'],'ClearingDetails',context!);
acquiring = JsonConverters.fromJson(json['acquiring'],'Acquiring',context!);
subscriptions = JsonConverters.fromJson(json['subscriptions'],'List<Subscription>',context!);
children = JsonConverters.fromJson(json['children'],'List<OrderPayload>',context!);
return this;
}
Map<String, dynamic> toJson() => {
'partyId': partyId,
'parentPartyId': parentPartyId,
'legalName': legalName,
'tradingName': tradingName,
'addresses': JsonConverters.toJson(addresses,'List<MerchantAddress>',context!),
'tradingContact': JsonConverters.toJson(tradingContact,'Contact',context!),
'invoiceContact': JsonConverters.toJson(invoiceContact,'InvoiceContact',context!),
'settlementBankAccount': JsonConverters.toJson(settlementBankAccount,'BankAccount',context!),
'chargesBankAccount': JsonConverters.toJson(chargesBankAccount,'BankAccount',context!),
'directDebitCorrespondenceEmail': directDebitCorrespondenceEmail,
'websiteAddress': websiteAddress,
'companyType': companyType,
'companyTypeOther': companyTypeOther,
'companyRegistrationNumber': companyRegistrationNumber,
'charityNumber': charityNumber,
'merchantCategories': JsonConverters.toJson(merchantCategories,'List<MerchantCategory>',context!),
'vatNumber': vatNumber,
'dateStartedTrading': JsonConverters.toJson(dateStartedTrading,'DateTime',context!),
'anticipatedGoLiveDate': JsonConverters.toJson(anticipatedGoLiveDate,'DateTime',context!),
'countryOfIncorporation': countryOfIncorporation,
'regionOfIncorporation': regionOfIncorporation,
'financials': JsonConverters.toJson(financials,'Financials',context!),
'newToCards': newToCards,
'tradeAssociation': JsonConverters.toJson(tradeAssociation,'TradeAssociation',context!),
'principals': JsonConverters.toJson(principals,'List<Principal>',context!),
'goodsAndServices': JsonConverters.toJson(goodsAndServices,'GoodsAndServices',context!),
'accessibilityOptions': JsonConverters.toJson(accessibilityOptions,'AccessibilityOptions',context!),
'clearingDetails': JsonConverters.toJson(clearingDetails,'ClearingDetails',context!),
'acquiring': JsonConverters.toJson(acquiring,'Acquiring',context!),
'subscriptions': JsonConverters.toJson(subscriptions,'List<Subscription>',context!),
'children': JsonConverters.toJson(children,'List<OrderPayload>',context!)
};
getTypeName() => "OrderPayload";
TypeContext? context = _ctx;
}
class Order implements IConvertible
{
OrderMeta? meta;
OrderPayload? payload;
Order({this.meta,this.payload});
Order.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
meta = JsonConverters.fromJson(json['meta'],'OrderMeta',context!);
payload = JsonConverters.fromJson(json['payload'],'OrderPayload',context!);
return this;
}
Map<String, dynamic> toJson() => {
'meta': JsonConverters.toJson(meta,'OrderMeta',context!),
'payload': JsonConverters.toJson(payload,'OrderPayload',context!)
};
getTypeName() => "Order";
TypeContext? context = _ctx;
}
class OrderBoardingRequest implements IConvertible
{
// @ApiMember(IsRequired=true)
String? correlationId;
// @ApiMember(IsRequired=true)
Order? orderJson;
String? onboardingRequestId;
String? localEnterpriseId;
String? audience;
OrderBoardingRequest({this.correlationId,this.orderJson,this.onboardingRequestId,this.localEnterpriseId,this.audience});
OrderBoardingRequest.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
correlationId = json['correlationId'];
orderJson = JsonConverters.fromJson(json['orderJson'],'Order',context!);
onboardingRequestId = json['onboardingRequestId'];
localEnterpriseId = json['localEnterpriseId'];
audience = json['audience'];
return this;
}
Map<String, dynamic> toJson() => {
'correlationId': correlationId,
'orderJson': JsonConverters.toJson(orderJson,'Order',context!),
'onboardingRequestId': onboardingRequestId,
'localEnterpriseId': localEnterpriseId,
'audience': audience
};
getTypeName() => "OrderBoardingRequest";
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;
}
TypeContext _ctx = TypeContext(library: 'abservice_featuretest.worldpay.com', types: <String, TypeInfo> {
'ApplicationQueueStatus': TypeInfo(TypeOf.Enum, enumValues:ApplicationQueueStatus.values),
'ApplicationBoardingStatus': TypeInfo(TypeOf.Enum, enumValues:ApplicationBoardingStatus.values),
'InitiateBoardingResponse': TypeInfo(TypeOf.Class, create:() => InitiateBoardingResponse()),
'Partner': TypeInfo(TypeOf.Class, create:() => Partner()),
'Person': TypeInfo(TypeOf.Class, create:() => Person()),
'Contact': TypeInfo(TypeOf.Class, create:() => Contact()),
'AuthorisedSigner': TypeInfo(TypeOf.Class, create:() => AuthorisedSigner()),
'OrderMeta': TypeInfo(TypeOf.Class, create:() => OrderMeta()),
'Address': TypeInfo(TypeOf.Class, create:() => Address()),
'MerchantAddress': TypeInfo(TypeOf.Class, create:() => MerchantAddress()),
'InvoiceContact': TypeInfo(TypeOf.Class, create:() => InvoiceContact()),
'BankAccount': TypeInfo(TypeOf.Class, create:() => BankAccount()),
'MerchantCategory': TypeInfo(TypeOf.Class, create:() => MerchantCategory()),
'Financials': TypeInfo(TypeOf.Class, create:() => Financials()),
'TradeAssociation': TypeInfo(TypeOf.Class, create:() => TradeAssociation()),
'PrincipalAddress': TypeInfo(TypeOf.Class, create:() => PrincipalAddress()),
'PositionType': TypeInfo(TypeOf.Enum, enumValues:PositionType.values),
'Principal': TypeInfo(TypeOf.Class, create:() => Principal()),
'List<PrincipalAddress>': TypeInfo(TypeOf.Class, create:() => <PrincipalAddress>[]),
'Deposits': TypeInfo(TypeOf.Class, create:() => Deposits()),
'WarrantiesAndGuarantees': TypeInfo(TypeOf.Class, create:() => WarrantiesAndGuarantees()),
'Prepayments': TypeInfo(TypeOf.Class, create:() => Prepayments()),
'MembershipsSubscriptionAndInsurancePremiums': TypeInfo(TypeOf.Class, create:() => MembershipsSubscriptionAndInsurancePremiums()),
'GoodsAndServices': TypeInfo(TypeOf.Class, create:() => GoodsAndServices()),
'AccessibilityOptions': TypeInfo(TypeOf.Class, create:() => AccessibilityOptions()),
'ClearingDetails': TypeInfo(TypeOf.Class, create:() => ClearingDetails()),
'CardType': TypeInfo(TypeOf.Enum, enumValues:CardType.values),
'RateChargePair': TypeInfo(TypeOf.Class, create:() => RateChargePair()),
'CardCharge': TypeInfo(TypeOf.Class, create:() => CardCharge()),
'PremiumTransactionChargeType': TypeInfo(TypeOf.Enum, enumValues:PremiumTransactionChargeType.values),
'PremiumTransactionCharge': TypeInfo(TypeOf.Class, create:() => PremiumTransactionCharge()),
'AdditionalTariff': TypeInfo(TypeOf.Class, create:() => AdditionalTariff()),
'Rates': TypeInfo(TypeOf.Class, create:() => Rates()),
'List<CardCharge>': TypeInfo(TypeOf.Class, create:() => <CardCharge>[]),
'List<PremiumTransactionCharge>': TypeInfo(TypeOf.Class, create:() => <PremiumTransactionCharge>[]),
'List<AdditionalTariff>': TypeInfo(TypeOf.Class, create:() => <AdditionalTariff>[]),
'CurrencyCodeType': TypeInfo(TypeOf.Enum, enumValues:CurrencyCodeType.values),
'TradingCurrency': TypeInfo(TypeOf.Class, create:() => TradingCurrency()),
'List<CurrencyCodeType>': TypeInfo(TypeOf.Class, create:() => <CurrencyCodeType>[]),
'Acquiring': TypeInfo(TypeOf.Class, create:() => Acquiring()),
'List<TradingCurrency>': TypeInfo(TypeOf.Class, create:() => <TradingCurrency>[]),
'ProductFeeType': TypeInfo(TypeOf.Enum, enumValues:ProductFeeType.values),
'ProductFee': TypeInfo(TypeOf.Class, create:() => ProductFee()),
'ProductOption': TypeInfo(TypeOf.Class, create:() => ProductOption()),
'Product': TypeInfo(TypeOf.Class, create:() => Product()),
'List<ProductFee>': TypeInfo(TypeOf.Class, create:() => <ProductFee>[]),
'List<ProductOption>': TypeInfo(TypeOf.Class, create:() => <ProductOption>[]),
'Subscription': TypeInfo(TypeOf.Class, create:() => Subscription()),
'List<Product>': TypeInfo(TypeOf.Class, create:() => <Product>[]),
'OrderPayload': TypeInfo(TypeOf.Class, create:() => OrderPayload()),
'List<MerchantAddress>': TypeInfo(TypeOf.Class, create:() => <MerchantAddress>[]),
'List<MerchantCategory>': TypeInfo(TypeOf.Class, create:() => <MerchantCategory>[]),
'List<Principal>': TypeInfo(TypeOf.Class, create:() => <Principal>[]),
'List<Subscription>': TypeInfo(TypeOf.Class, create:() => <Subscription>[]),
'List<OrderPayload>': TypeInfo(TypeOf.Class, create:() => <OrderPayload>[]),
'Order': TypeInfo(TypeOf.Class, create:() => Order()),
'OrderBoardingRequest': TypeInfo(TypeOf.Class, create:() => OrderBoardingRequest()),
});
Dart OrderBoardingRequest DTOs
To override the Content-type in your clients, use the HTTP Accept Header, append the .xml suffix or ?format=xml
The following are sample HTTP requests and responses. The placeholders shown need to be replaced with actual values.
POST /OrderBoarding HTTP/1.1
Host: abservice-featuretest.worldpay.com
Accept: application/xml
Content-Type: application/xml
Content-Length: length
<OrderBoardingRequest xmlns:i="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://schemas.datacontract.org/2004/07/Autoboarding.Common.Requests">
<Audience>String</Audience>
<CorrelationId>00000000-0000-0000-0000-000000000000</CorrelationId>
<LocalEnterpriseId>00000000-0000-0000-0000-000000000000</LocalEnterpriseId>
<OnboardingRequestId>00000000-0000-0000-0000-000000000000</OnboardingRequestId>
<OrderJson xmlns:d2p1="http://schemas.datacontract.org/2004/07/BoardingGateway.Common.Requests.Orders">
<d2p1:Meta>
<d2p1:Contact>
<d2p1:FirstName>String</d2p1:FirstName>
<d2p1:LastName>String</d2p1:LastName>
<d2p1:MiddleName>String</d2p1:MiddleName>
<d2p1:Title>String</d2p1:Title>
<d2p1:AltTelephoneNumber>String</d2p1:AltTelephoneNumber>
<d2p1:Email>String</d2p1:Email>
<d2p1:IdpGuid>00000000-0000-0000-0000-000000000000</d2p1:IdpGuid>
<d2p1:Position>String</d2p1:Position>
<d2p1:PreferredContactBestTime>String</d2p1:PreferredContactBestTime>
<d2p1:PreferredContactMethod>String</d2p1:PreferredContactMethod>
<d2p1:TelephoneNumber>String</d2p1:TelephoneNumber>
<d2p1:CountryCode>String</d2p1:CountryCode>
<d2p1:DateOfBirth>0001-01-01T00:00:00</d2p1:DateOfBirth>
</d2p1:Contact>
<d2p1:Csr>String</d2p1:Csr>
<d2p1:CustomerType>String</d2p1:CustomerType>
<d2p1:DateContractAccepted>0001-01-01T00:00:00</d2p1:DateContractAccepted>
<d2p1:HasSupportingFiles>false</d2p1:HasSupportingFiles>
<d2p1:OfferDetails>String</d2p1:OfferDetails>
<d2p1:OrderType>String</d2p1:OrderType>
<d2p1:Partner>
<d2p1:PartnerId>String</d2p1:PartnerId>
<d2p1:PartnerName>String</d2p1:PartnerName>
</d2p1:Partner>
<d2p1:Sar>false</d2p1:Sar>
<d2p1:SellerCode>String</d2p1:SellerCode>
<d2p1:SellerEmail>String</d2p1:SellerEmail>
<d2p1:SourceSystem>String</d2p1:SourceSystem>
<d2p1:SourceSystemIdentifier>String</d2p1:SourceSystemIdentifier>
<d2p1:SpecialInstructions>String</d2p1:SpecialInstructions>
<d2p1:UltimateParentId>String</d2p1:UltimateParentId>
<d2p1:WorldpayBusinessFinanceInterest>false</d2p1:WorldpayBusinessFinanceInterest>
</d2p1:Meta>
<d2p1:Payload>
<d2p1:AccessibilityOptions>
<d2p1:AudiotapeRequired>false</d2p1:AudiotapeRequired>
<d2p1:LargePrintRequired>false</d2p1:LargePrintRequired>
<d2p1:NextGenerationTextRequired>false</d2p1:NextGenerationTextRequired>
<d2p1:UncontractedBrailleGrade1Required>false</d2p1:UncontractedBrailleGrade1Required>
<d2p1:UncontractedBrailleGrade2Required>false</d2p1:UncontractedBrailleGrade2Required>
</d2p1:AccessibilityOptions>
<d2p1:Acquiring>
<d2p1:FundingMode>String</d2p1:FundingMode>
<d2p1:Rates>
<d2p1:AdditionalTariffs i:nil="true" />
<d2p1:CardCharges i:nil="true" />
<d2p1:PremiumTransactionCharges i:nil="true" />
</d2p1:Rates>
<d2p1:SettlementPeriod>0</d2p1:SettlementPeriod>
<d2p1:TradingCurrencies i:nil="true" />
</d2p1:Acquiring>
<d2p1:Addresses i:nil="true" />
<d2p1:AnticipatedGoLiveDate>0001-01-01T00:00:00</d2p1:AnticipatedGoLiveDate>
<d2p1:ChargesBankAccount>
<d2p1:AccountNumber>String</d2p1:AccountNumber>
<d2p1:BankAccountName>String</d2p1:BankAccountName>
<d2p1:BankName>String</d2p1:BankName>
<d2p1:InternationalBankAccountNumber>String</d2p1:InternationalBankAccountNumber>
<d2p1:SortCode>String</d2p1:SortCode>
<d2p1:SwiftCode>String</d2p1:SwiftCode>
</d2p1:ChargesBankAccount>
<d2p1:CharityNumber>String</d2p1:CharityNumber>
<d2p1:Children i:nil="true" />
<d2p1:ClearingDetails>
<d2p1:Email>String</d2p1:Email>
<d2p1:MerchantUrl>String</d2p1:MerchantUrl>
<d2p1:Telephone>String</d2p1:Telephone>
</d2p1:ClearingDetails>
<d2p1:CompanyRegistrationNumber>String</d2p1:CompanyRegistrationNumber>
<d2p1:CompanyType>String</d2p1:CompanyType>
<d2p1:CompanyTypeOther>String</d2p1:CompanyTypeOther>
<d2p1:CountryOfIncorporation>String</d2p1:CountryOfIncorporation>
<d2p1:DateStartedTrading>0001-01-01T00:00:00</d2p1:DateStartedTrading>
<d2p1:DirectDebitCorrespondenceEmail>String</d2p1:DirectDebitCorrespondenceEmail>
<d2p1:Financials>
<d2p1:Annual>0</d2p1:Annual>
<d2p1:AverageTransactionValue>0</d2p1:AverageTransactionValue>
<d2p1:CardNotPresentPercentage>0</d2p1:CardNotPresentPercentage>
<d2p1:CardPercentage>0</d2p1:CardPercentage>
<d2p1:CreditCardPercentage>0</d2p1:CreditCardPercentage>
</d2p1:Financials>
<d2p1:GoodsAndServices>
<d2p1:Deposits>
<d2p1:AvgTimeBeforeDeliveryBalanceTaken>0</d2p1:AvgTimeBeforeDeliveryBalanceTaken>
<d2p1:AvgTimeBeforeDeliveryDepositTaken>0</d2p1:AvgTimeBeforeDeliveryDepositTaken>
<d2p1:PerOfSalesWhereInitialDepositTaken>0</d2p1:PerOfSalesWhereInitialDepositTaken>
<d2p1:SizePerTotalValue>0</d2p1:SizePerTotalValue>
</d2p1:Deposits>
<d2p1:GoodsProvidedByThirdParty>false</d2p1:GoodsProvidedByThirdParty>
<d2p1:MembershipsSubscriptionAndInsurancePremiums>
<d2p1:AvgLengthInMonths>0</d2p1:AvgLengthInMonths>
<d2p1:MembershipCost>0</d2p1:MembershipCost>
<d2p1:PercCardTurnover>0</d2p1:PercCardTurnover>
</d2p1:MembershipsSubscriptionAndInsurancePremiums>
<d2p1:Prepayments>
<d2p1:AvgDaysPaymentTakenInAdvance>0</d2p1:AvgDaysPaymentTakenInAdvance>
<d2p1:PercGoodsWherePaymentTakenPriorToDelivery>0</d2p1:PercGoodsWherePaymentTakenPriorToDelivery>
</d2p1:Prepayments>
<d2p1:StockHeldAtAnotherAddressLocation>
<d2p1:Address1>String</d2p1:Address1>
<d2p1:Address2>String</d2p1:Address2>
<d2p1:Address3>String</d2p1:Address3>
<d2p1:City>String</d2p1:City>
<d2p1:CountryCode>String</d2p1:CountryCode>
<d2p1:Postcode>String</d2p1:Postcode>
<d2p1:State>String</d2p1:State>
</d2p1:StockHeldAtAnotherAddressLocation>
<d2p1:WarrantiesAndGuarantees>
<d2p1:AvgLengthInMonths>0</d2p1:AvgLengthInMonths>
<d2p1:PercCardTurnover>0</d2p1:PercCardTurnover>
<d2p1:PercGoodsReturned>0</d2p1:PercGoodsReturned>
<d2p1:ThirdPartyProviders>String</d2p1:ThirdPartyProviders>
</d2p1:WarrantiesAndGuarantees>
</d2p1:GoodsAndServices>
<d2p1:InvoiceContact>
<d2p1:FirstName>String</d2p1:FirstName>
<d2p1:LastName>String</d2p1:LastName>
<d2p1:MiddleName>String</d2p1:MiddleName>
<d2p1:Title>String</d2p1:Title>
<d2p1:Email>String</d2p1:Email>
<d2p1:Position>String</d2p1:Position>
</d2p1:InvoiceContact>
<d2p1:LegalName>String</d2p1:LegalName>
<d2p1:MerchantCategories i:nil="true" />
<d2p1:NewToCards>false</d2p1:NewToCards>
<d2p1:ParentPartyId>String</d2p1:ParentPartyId>
<d2p1:PartyId>String</d2p1:PartyId>
<d2p1:Principals i:nil="true" />
<d2p1:RegionOfIncorporation>String</d2p1:RegionOfIncorporation>
<d2p1:SettlementBankAccount>
<d2p1:AccountNumber>String</d2p1:AccountNumber>
<d2p1:BankAccountName>String</d2p1:BankAccountName>
<d2p1:BankName>String</d2p1:BankName>
<d2p1:InternationalBankAccountNumber>String</d2p1:InternationalBankAccountNumber>
<d2p1:SortCode>String</d2p1:SortCode>
<d2p1:SwiftCode>String</d2p1:SwiftCode>
</d2p1:SettlementBankAccount>
<d2p1:Subscriptions i:nil="true" />
<d2p1:TradeAssociation>
<d2p1:GroupName>String</d2p1:GroupName>
<d2p1:MemberNumber>String</d2p1:MemberNumber>
</d2p1:TradeAssociation>
<d2p1:TradingContact>
<d2p1:FirstName>String</d2p1:FirstName>
<d2p1:LastName>String</d2p1:LastName>
<d2p1:MiddleName>String</d2p1:MiddleName>
<d2p1:Title>String</d2p1:Title>
<d2p1:AltTelephoneNumber>String</d2p1:AltTelephoneNumber>
<d2p1:Email>String</d2p1:Email>
<d2p1:IdpGuid>00000000-0000-0000-0000-000000000000</d2p1:IdpGuid>
<d2p1:Position>String</d2p1:Position>
<d2p1:PreferredContactBestTime>String</d2p1:PreferredContactBestTime>
<d2p1:PreferredContactMethod>String</d2p1:PreferredContactMethod>
<d2p1:TelephoneNumber>String</d2p1:TelephoneNumber>
</d2p1:TradingContact>
<d2p1:TradingName>String</d2p1:TradingName>
<d2p1:VatNumber>String</d2p1:VatNumber>
<d2p1:WebsiteAddress>String</d2p1:WebsiteAddress>
</d2p1:Payload>
</OrderJson>
</OrderBoardingRequest>
HTTP/1.1 200 OK
Content-Type: application/xml
Content-Length: length
<InitiateBoardingResponse xmlns:i="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://schemas.datacontract.org/2004/07/Autoboarding.Common.Responses">
<ApplicationGuid>00000000-0000-0000-0000-000000000000</ApplicationGuid>
<ApplicationQueueGuid>00000000-0000-0000-0000-000000000000</ApplicationQueueGuid>
<BoardingStatus>PENDING</BoardingStatus>
<CSR>0</CSR>
<ErrorMessages xmlns:d2p1="http://schemas.microsoft.com/2003/10/Serialization/Arrays">
<d2p1:string>String</d2p1:string>
</ErrorMessages>
<QueueStatus>Queued</QueueStatus>
</InitiateBoardingResponse>