| POST | /api/receivingAdvice | Add new ReceivingAdvice |
|---|
import 'package:servicestack/servicestack.dart';
class TokenDto implements ICommandResponse, IConvertible
{
String token = "";
TokenDto({this.token});
TokenDto.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
token = json['token'];
return this;
}
Map<String, dynamic> toJson() => {
'token': token
};
getTypeName() => "TokenDto";
TypeContext? context = _ctx;
}
// @DataContract
class DocumentIdentification implements IConvertible
{
// @DataMember(Name="identifier")
String identifier = "";
// @DataMember(Name="type")
String type = "";
// @DataMember(Name="creationDateAndTime")
DateTime creationDateAndTime = DateTime(0);
DocumentIdentification({this.identifier,this.type,this.creationDateAndTime});
DocumentIdentification.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
identifier = json['identifier'];
type = json['type'];
creationDateAndTime = JsonConverters.fromJson(json['creationDateAndTime'],'DateTime',context!);
return this;
}
Map<String, dynamic> toJson() => {
'identifier': identifier,
'type': type,
'creationDateAndTime': JsonConverters.toJson(creationDateAndTime,'DateTime',context!)
};
getTypeName() => "DocumentIdentification";
TypeContext? context = _ctx;
}
// @DataContract
class Identifier implements IConvertible
{
// @DataMember(Name="authority")
String authority = "";
// @DataMember(Name="text")
String text = "";
Identifier({this.authority,this.text});
Identifier.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
authority = json['authority'];
text = json['text'];
return this;
}
Map<String, dynamic> toJson() => {
'authority': authority,
'text': text
};
getTypeName() => "Identifier";
TypeContext? context = _ctx;
}
// @DataContract
class ContactInformation implements IConvertible
{
ContactInformation();
ContactInformation.fromJson(Map<String, dynamic> json) : super();
fromMap(Map<String, dynamic> json) {
return this;
}
Map<String, dynamic> toJson() => {};
getTypeName() => "ContactInformation";
TypeContext? context = _ctx;
}
// @DataContract
class Partner implements IConvertible
{
// @DataMember(Name="identifier")
Identifier identifier;
// @DataMember(Name="contactInformation")
List<ContactInformation> contactInformation = [];
Partner({this.identifier,this.contactInformation});
Partner.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
identifier = JsonConverters.fromJson(json['identifier'],'Identifier',context!);
contactInformation = JsonConverters.fromJson(json['contactInformation'],'List<ContactInformation>',context!);
return this;
}
Map<String, dynamic> toJson() => {
'identifier': JsonConverters.toJson(identifier,'Identifier',context!),
'contactInformation': JsonConverters.toJson(contactInformation,'List<ContactInformation>',context!)
};
getTypeName() => "Partner";
TypeContext? context = _ctx;
}
// @DataContract
class Header implements IConvertible
{
// @DataMember(Name="documentIdentification")
DocumentIdentification documentIdentification;
// @DataMember(Name="sender")
Partner sender;
// @DataMember(Name="receiver")
Partner receiver;
Header({this.documentIdentification,this.sender,this.receiver});
Header.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
documentIdentification = JsonConverters.fromJson(json['documentIdentification'],'DocumentIdentification',context!);
sender = JsonConverters.fromJson(json['sender'],'Partner',context!);
receiver = JsonConverters.fromJson(json['receiver'],'Partner',context!);
return this;
}
Map<String, dynamic> toJson() => {
'documentIdentification': JsonConverters.toJson(documentIdentification,'DocumentIdentification',context!),
'sender': JsonConverters.toJson(sender,'Partner',context!),
'receiver': JsonConverters.toJson(receiver,'Partner',context!)
};
getTypeName() => "Header";
TypeContext? context = _ctx;
}
enum DocumentAction
{
ADD,
CHANGE_BY_REFRESH,
DELETE,
REJECTED,
}
enum DocumentStatus
{
ADDITIONAL_TRANSMISSION,
COPY,
ORIGINAL,
}
class AvpList implements IConvertible
{
String code = "";
String value = "";
AvpList({this.code,this.value});
AvpList.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
code = json['code'];
value = json['value'];
return this;
}
Map<String, dynamic> toJson() => {
'code': code,
'value': value
};
getTypeName() => "AvpList";
TypeContext? context = _ctx;
}
class BaseDocument implements IConvertible
{
String currencyCode = "";
DateTime creationDateTime = DateTime(0);
DocumentAction documentActionCode;
DocumentStatus documentStatusCode;
String documentStructureVersion = "";
DateTime? lastUpdateDateTime;
int? revisionNumber;
List<AvpList> avpList = [];
BaseDocument({this.currencyCode,this.creationDateTime,this.documentActionCode,this.documentStatusCode,this.documentStructureVersion,this.lastUpdateDateTime,this.revisionNumber,this.avpList});
BaseDocument.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
currencyCode = json['currencyCode'];
creationDateTime = JsonConverters.fromJson(json['creationDateTime'],'DateTime',context!);
documentActionCode = JsonConverters.fromJson(json['documentActionCode'],'DocumentAction',context!);
documentStatusCode = JsonConverters.fromJson(json['documentStatusCode'],'DocumentStatus',context!);
documentStructureVersion = json['documentStructureVersion'];
lastUpdateDateTime = JsonConverters.fromJson(json['lastUpdateDateTime'],'DateTime',context!);
revisionNumber = json['revisionNumber'];
avpList = JsonConverters.fromJson(json['avpList'],'List<AvpList>',context!);
return this;
}
Map<String, dynamic> toJson() => {
'currencyCode': currencyCode,
'creationDateTime': JsonConverters.toJson(creationDateTime,'DateTime',context!),
'documentActionCode': JsonConverters.toJson(documentActionCode,'DocumentAction',context!),
'documentStatusCode': JsonConverters.toJson(documentStatusCode,'DocumentStatus',context!),
'documentStructureVersion': documentStructureVersion,
'lastUpdateDateTime': JsonConverters.toJson(lastUpdateDateTime,'DateTime',context!),
'revisionNumber': revisionNumber,
'avpList': JsonConverters.toJson(avpList,'List<AvpList>',context!)
};
getTypeName() => "BaseDocument";
TypeContext? context = _ctx;
}
class CommunicationChannel implements IConvertible
{
String communicationChannelCode = "";
String communicationChannelName = "";
String communicationValue = "";
CommunicationChannel({this.communicationChannelCode,this.communicationChannelName,this.communicationValue});
CommunicationChannel.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
communicationChannelCode = json['communicationChannelCode'];
communicationChannelName = json['communicationChannelName'];
communicationValue = json['communicationValue'];
return this;
}
Map<String, dynamic> toJson() => {
'communicationChannelCode': communicationChannelCode,
'communicationChannelName': communicationChannelName,
'communicationValue': communicationValue
};
getTypeName() => "CommunicationChannel";
TypeContext? context = _ctx;
}
class Contact implements IConvertible
{
String contactTypeCode = "";
String personName = "";
String departmentName = "";
String jobTitle = "";
String responsibility = "";
List<CommunicationChannel> communicationChannel = [];
Contact({this.contactTypeCode,this.personName,this.departmentName,this.jobTitle,this.responsibility,this.communicationChannel});
Contact.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
contactTypeCode = json['contactTypeCode'];
personName = json['personName'];
departmentName = json['departmentName'];
jobTitle = json['jobTitle'];
responsibility = json['responsibility'];
communicationChannel = JsonConverters.fromJson(json['communicationChannel'],'List<CommunicationChannel>',context!);
return this;
}
Map<String, dynamic> toJson() => {
'contactTypeCode': contactTypeCode,
'personName': personName,
'departmentName': departmentName,
'jobTitle': jobTitle,
'responsibility': responsibility,
'communicationChannel': JsonConverters.toJson(communicationChannel,'List<CommunicationChannel>',context!)
};
getTypeName() => "Contact";
TypeContext? context = _ctx;
}
class IdentityDocument implements IConvertible
{
String identityDocumentIssuer = "";
String identityDocumentNumber = "";
String identityDocumentType = "";
IdentityDocument({this.identityDocumentIssuer,this.identityDocumentNumber,this.identityDocumentType});
IdentityDocument.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
identityDocumentIssuer = json['identityDocumentIssuer'];
identityDocumentNumber = json['identityDocumentNumber'];
identityDocumentType = json['identityDocumentType'];
return this;
}
Map<String, dynamic> toJson() => {
'identityDocumentIssuer': identityDocumentIssuer,
'identityDocumentNumber': identityDocumentNumber,
'identityDocumentType': identityDocumentType
};
getTypeName() => "IdentityDocument";
TypeContext? context = _ctx;
}
class Person implements IConvertible
{
DateTime? dateOfBirth;
String gender = "";
String nationality = "";
String personName = "";
List<IdentityDocument> identityDocument = [];
Person({this.dateOfBirth,this.gender,this.nationality,this.personName,this.identityDocument});
Person.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
dateOfBirth = JsonConverters.fromJson(json['dateOfBirth'],'DateTime',context!);
gender = json['gender'];
nationality = json['nationality'];
personName = json['personName'];
identityDocument = JsonConverters.fromJson(json['identityDocument'],'List<IdentityDocument>',context!);
return this;
}
Map<String, dynamic> toJson() => {
'dateOfBirth': JsonConverters.toJson(dateOfBirth,'DateTime',context!),
'gender': gender,
'nationality': nationality,
'personName': personName,
'identityDocument': JsonConverters.toJson(identityDocument,'List<IdentityDocument>',context!)
};
getTypeName() => "Person";
TypeContext? context = _ctx;
}
class ReceivingAdviceTransportInformation implements IConvertible
{
Identifier routeID;
Identifier transportMeansID;
String transportMeansName = "";
Contact driver;
Person driverID;
Contact receiver;
Person receiverID;
ReceivingAdviceTransportInformation({this.routeID,this.transportMeansID,this.transportMeansName,this.driver,this.driverID,this.receiver,this.receiverID});
ReceivingAdviceTransportInformation.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
routeID = JsonConverters.fromJson(json['routeID'],'Identifier',context!);
transportMeansID = JsonConverters.fromJson(json['transportMeansID'],'Identifier',context!);
transportMeansName = json['transportMeansName'];
driver = JsonConverters.fromJson(json['driver'],'Contact',context!);
driverID = JsonConverters.fromJson(json['driverID'],'Person',context!);
receiver = JsonConverters.fromJson(json['receiver'],'Contact',context!);
receiverID = JsonConverters.fromJson(json['receiverID'],'Person',context!);
return this;
}
Map<String, dynamic> toJson() => {
'routeID': JsonConverters.toJson(routeID,'Identifier',context!),
'transportMeansID': JsonConverters.toJson(transportMeansID,'Identifier',context!),
'transportMeansName': transportMeansName,
'driver': JsonConverters.toJson(driver,'Contact',context!),
'driverID': JsonConverters.toJson(driverID,'Person',context!),
'receiver': JsonConverters.toJson(receiver,'Contact',context!),
'receiverID': JsonConverters.toJson(receiverID,'Person',context!)
};
getTypeName() => "ReceivingAdviceTransportInformation";
TypeContext? context = _ctx;
}
class DocumentReference implements IConvertible
{
DateTime? creationDateTime;
int? revisionNumber;
int? lineItemNumber;
String entityIdentification = "";
DocumentReference({this.creationDateTime,this.revisionNumber,this.lineItemNumber,this.entityIdentification});
DocumentReference.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
creationDateTime = JsonConverters.fromJson(json['creationDateTime'],'DateTime',context!);
revisionNumber = json['revisionNumber'];
lineItemNumber = json['lineItemNumber'];
entityIdentification = json['entityIdentification'];
return this;
}
Map<String, dynamic> toJson() => {
'creationDateTime': JsonConverters.toJson(creationDateTime,'DateTime',context!),
'revisionNumber': revisionNumber,
'lineItemNumber': lineItemNumber,
'entityIdentification': entityIdentification
};
getTypeName() => "DocumentReference";
TypeContext? context = _ctx;
}
class Ecom_PartyIdentificationType implements IConvertible
{
String gln = "";
String name = "";
List<AvpList> additionalPartyIdentification = [];
Ecom_PartyIdentificationType({this.gln,this.name,this.additionalPartyIdentification});
Ecom_PartyIdentificationType.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
gln = json['gln'];
name = json['name'];
additionalPartyIdentification = JsonConverters.fromJson(json['additionalPartyIdentification'],'List<AvpList>',context!);
return this;
}
Map<String, dynamic> toJson() => {
'gln': gln,
'name': name,
'additionalPartyIdentification': JsonConverters.toJson(additionalPartyIdentification,'List<AvpList>',context!)
};
getTypeName() => "Ecom_PartyIdentificationType";
TypeContext? context = _ctx;
}
class Address implements IConvertible
{
String streetAddressOne = "";
String streetAddressTwo = "";
String streetAddressThree = "";
String city = "";
String postalCode = "";
String provinceCode = "";
String countryCode = "";
Address({this.streetAddressOne,this.streetAddressTwo,this.streetAddressThree,this.city,this.postalCode,this.provinceCode,this.countryCode});
Address.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
streetAddressOne = json['streetAddressOne'];
streetAddressTwo = json['streetAddressTwo'];
streetAddressThree = json['streetAddressThree'];
city = json['city'];
postalCode = json['postalCode'];
provinceCode = json['provinceCode'];
countryCode = json['countryCode'];
return this;
}
Map<String, dynamic> toJson() => {
'streetAddressOne': streetAddressOne,
'streetAddressTwo': streetAddressTwo,
'streetAddressThree': streetAddressThree,
'city': city,
'postalCode': postalCode,
'provinceCode': provinceCode,
'countryCode': countryCode
};
getTypeName() => "Address";
TypeContext? context = _ctx;
}
class FinancialRoutingNumber implements IConvertible
{
String number = "";
String numberTypeCode = "";
FinancialRoutingNumber({this.number,this.numberTypeCode});
FinancialRoutingNumber.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
number = json['number'];
numberTypeCode = json['numberTypeCode'];
return this;
}
Map<String, dynamic> toJson() => {
'number': number,
'numberTypeCode': numberTypeCode
};
getTypeName() => "FinancialRoutingNumber";
TypeContext? context = _ctx;
}
class FinancialAccount implements IConvertible
{
String number = "";
String numberTypeCode = "";
String name = "";
FinancialAccount({this.number,this.numberTypeCode,this.name});
FinancialAccount.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
number = json['number'];
numberTypeCode = json['numberTypeCode'];
name = json['name'];
return this;
}
Map<String, dynamic> toJson() => {
'number': number,
'numberTypeCode': numberTypeCode,
'name': name
};
getTypeName() => "FinancialAccount";
TypeContext? context = _ctx;
}
class FinancialInstitutionInformation implements IConvertible
{
String financialInstitutionBranchName = "";
String financialInstitutionName = "";
FinancialRoutingNumber financialRoutingNumber;
FinancialAccount financialAccount;
String swiftCode = "";
String exportersCode = "";
FinancialInstitutionInformation({this.financialInstitutionBranchName,this.financialInstitutionName,this.financialRoutingNumber,this.financialAccount,this.swiftCode,this.exportersCode});
FinancialInstitutionInformation.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
financialInstitutionBranchName = json['financialInstitutionBranchName'];
financialInstitutionName = json['financialInstitutionName'];
financialRoutingNumber = JsonConverters.fromJson(json['financialRoutingNumber'],'FinancialRoutingNumber',context!);
financialAccount = JsonConverters.fromJson(json['financialAccount'],'FinancialAccount',context!);
swiftCode = json['swiftCode'];
exportersCode = json['exportersCode'];
return this;
}
Map<String, dynamic> toJson() => {
'financialInstitutionBranchName': financialInstitutionBranchName,
'financialInstitutionName': financialInstitutionName,
'financialRoutingNumber': JsonConverters.toJson(financialRoutingNumber,'FinancialRoutingNumber',context!),
'financialAccount': JsonConverters.toJson(financialAccount,'FinancialAccount',context!),
'swiftCode': swiftCode,
'exportersCode': exportersCode
};
getTypeName() => "FinancialInstitutionInformation";
TypeContext? context = _ctx;
}
class TransactionalParty extends Ecom_PartyIdentificationType implements IConvertible
{
List<Contact> contact = [];
Address address;
List<AvpList> communicationChannel = [];
FinancialInstitutionInformation financialInstitutionInformation;
String dutyFeeTaxRegistration = "";
String entityIdentification = "";
TransactionalParty({this.contact,this.address,this.communicationChannel,this.financialInstitutionInformation,this.dutyFeeTaxRegistration,this.entityIdentification});
TransactionalParty.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
super.fromMap(json);
contact = JsonConverters.fromJson(json['contact'],'List<Contact>',context!);
address = JsonConverters.fromJson(json['address'],'Address',context!);
communicationChannel = JsonConverters.fromJson(json['communicationChannel'],'List<AvpList>',context!);
financialInstitutionInformation = JsonConverters.fromJson(json['financialInstitutionInformation'],'FinancialInstitutionInformation',context!);
dutyFeeTaxRegistration = json['dutyFeeTaxRegistration'];
entityIdentification = json['entityIdentification'];
return this;
}
Map<String, dynamic> toJson() => super.toJson()..addAll({
'contact': JsonConverters.toJson(contact,'List<Contact>',context!),
'address': JsonConverters.toJson(address,'Address',context!),
'communicationChannel': JsonConverters.toJson(communicationChannel,'List<AvpList>',context!),
'financialInstitutionInformation': JsonConverters.toJson(financialInstitutionInformation,'FinancialInstitutionInformation',context!),
'dutyFeeTaxRegistration': dutyFeeTaxRegistration,
'entityIdentification': entityIdentification
});
getTypeName() => "TransactionalParty";
TypeContext? context = _ctx;
}
class AdditionalConsignmentIdentification implements IConvertible
{
String text = "";
String additionalConsignmentIdentificationTypeCode = "";
AdditionalConsignmentIdentification({this.text,this.additionalConsignmentIdentificationTypeCode});
AdditionalConsignmentIdentification.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
text = json['text'];
additionalConsignmentIdentificationTypeCode = json['additionalConsignmentIdentificationTypeCode'];
return this;
}
Map<String, dynamic> toJson() => {
'text': text,
'additionalConsignmentIdentificationTypeCode': additionalConsignmentIdentificationTypeCode
};
getTypeName() => "AdditionalConsignmentIdentification";
TypeContext? context = _ctx;
}
class ConsignmentIdentification implements IConvertible
{
String ginc = "";
AdditionalConsignmentIdentification additionalConsignmentIdentification;
ConsignmentIdentification({this.ginc,this.additionalConsignmentIdentification});
ConsignmentIdentification.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
ginc = json['ginc'];
additionalConsignmentIdentification = JsonConverters.fromJson(json['additionalConsignmentIdentification'],'AdditionalConsignmentIdentification',context!);
return this;
}
Map<String, dynamic> toJson() => {
'ginc': ginc,
'additionalConsignmentIdentification': JsonConverters.toJson(additionalConsignmentIdentification,'AdditionalConsignmentIdentification',context!)
};
getTypeName() => "ConsignmentIdentification";
TypeContext? context = _ctx;
}
class Measurement implements IConvertible
{
double? value;
String codeListVersion = "";
String measurementUnitCode = "";
Measurement({this.value,this.codeListVersion,this.measurementUnitCode});
Measurement.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
value = JsonConverters.toDouble(json['value']);
codeListVersion = json['codeListVersion'];
measurementUnitCode = json['measurementUnitCode'];
return this;
}
Map<String, dynamic> toJson() => {
'value': value,
'codeListVersion': codeListVersion,
'measurementUnitCode': measurementUnitCode
};
getTypeName() => "Measurement";
TypeContext? context = _ctx;
}
class Dimension implements IConvertible
{
Measurement depth;
Measurement height;
Measurement width;
Dimension({this.depth,this.height,this.width});
Dimension.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
depth = JsonConverters.fromJson(json['depth'],'Measurement',context!);
height = JsonConverters.fromJson(json['height'],'Measurement',context!);
width = JsonConverters.fromJson(json['width'],'Measurement',context!);
return this;
}
Map<String, dynamic> toJson() => {
'depth': JsonConverters.toJson(depth,'Measurement',context!),
'height': JsonConverters.toJson(height,'Measurement',context!),
'width': JsonConverters.toJson(width,'Measurement',context!)
};
getTypeName() => "Dimension";
TypeContext? context = _ctx;
}
class UnitMeasurement implements IConvertible
{
String measurementType = "";
Measurement measurementValue;
UnitMeasurement({this.measurementType,this.measurementValue});
UnitMeasurement.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
measurementType = json['measurementType'];
measurementValue = JsonConverters.fromJson(json['measurementValue'],'Measurement',context!);
return this;
}
Map<String, dynamic> toJson() => {
'measurementType': measurementType,
'measurementValue': JsonConverters.toJson(measurementValue,'Measurement',context!)
};
getTypeName() => "UnitMeasurement";
TypeContext? context = _ctx;
}
class LogisticUnitMeasurement implements IConvertible
{
Dimension dimension;
UnitMeasurement unitMeasurement;
LogisticUnitMeasurement({this.dimension,this.unitMeasurement});
LogisticUnitMeasurement.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
dimension = JsonConverters.fromJson(json['dimension'],'Dimension',context!);
unitMeasurement = JsonConverters.fromJson(json['unitMeasurement'],'UnitMeasurement',context!);
return this;
}
Map<String, dynamic> toJson() => {
'dimension': JsonConverters.toJson(dimension,'Dimension',context!),
'unitMeasurement': JsonConverters.toJson(unitMeasurement,'UnitMeasurement',context!)
};
getTypeName() => "LogisticUnitMeasurement";
TypeContext? context = _ctx;
}
class AdditionalReturnableAssetIdentification implements IConvertible
{
String value = "";
String additionalReturnableAssetIdentificationTypeCode = "";
AdditionalReturnableAssetIdentification({this.value,this.additionalReturnableAssetIdentificationTypeCode});
AdditionalReturnableAssetIdentification.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
value = json['value'];
additionalReturnableAssetIdentificationTypeCode = json['additionalReturnableAssetIdentificationTypeCode'];
return this;
}
Map<String, dynamic> toJson() => {
'value': value,
'additionalReturnableAssetIdentificationTypeCode': additionalReturnableAssetIdentificationTypeCode
};
getTypeName() => "AdditionalReturnableAssetIdentification";
TypeContext? context = _ctx;
}
class ReturnableAssetIdentification implements IConvertible
{
List<AdditionalReturnableAssetIdentification> additionalReturnableAssetIdentification = [];
String grai = "";
ReturnableAssetIdentification({this.additionalReturnableAssetIdentification,this.grai});
ReturnableAssetIdentification.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
additionalReturnableAssetIdentification = JsonConverters.fromJson(json['additionalReturnableAssetIdentification'],'List<AdditionalReturnableAssetIdentification>',context!);
grai = json['grai'];
return this;
}
Map<String, dynamic> toJson() => {
'additionalReturnableAssetIdentification': JsonConverters.toJson(additionalReturnableAssetIdentification,'List<AdditionalReturnableAssetIdentification>',context!),
'grai': grai
};
getTypeName() => "ReturnableAssetIdentification";
TypeContext? context = _ctx;
}
class ReturnablePackaging implements IConvertible
{
Identifier currentHolderRegistration;
Identifier newHolderRegistration;
String packagingConditionCode = "";
int? packagingQuantity;
List<ReturnableAssetIdentification> individualReturnableAssetIdentification = [];
ReturnableAssetIdentification returnableAssetIdentification;
ReturnablePackaging({this.currentHolderRegistration,this.newHolderRegistration,this.packagingConditionCode,this.packagingQuantity,this.individualReturnableAssetIdentification,this.returnableAssetIdentification});
ReturnablePackaging.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
currentHolderRegistration = JsonConverters.fromJson(json['currentHolderRegistration'],'Identifier',context!);
newHolderRegistration = JsonConverters.fromJson(json['newHolderRegistration'],'Identifier',context!);
packagingConditionCode = json['packagingConditionCode'];
packagingQuantity = json['packagingQuantity'];
individualReturnableAssetIdentification = JsonConverters.fromJson(json['individualReturnableAssetIdentification'],'List<ReturnableAssetIdentification>',context!);
returnableAssetIdentification = JsonConverters.fromJson(json['returnableAssetIdentification'],'ReturnableAssetIdentification',context!);
return this;
}
Map<String, dynamic> toJson() => {
'currentHolderRegistration': JsonConverters.toJson(currentHolderRegistration,'Identifier',context!),
'newHolderRegistration': JsonConverters.toJson(newHolderRegistration,'Identifier',context!),
'packagingConditionCode': packagingConditionCode,
'packagingQuantity': packagingQuantity,
'individualReturnableAssetIdentification': JsonConverters.toJson(individualReturnableAssetIdentification,'List<ReturnableAssetIdentification>',context!),
'returnableAssetIdentification': JsonConverters.toJson(returnableAssetIdentification,'ReturnableAssetIdentification',context!)
};
getTypeName() => "ReturnablePackaging";
TypeContext? context = _ctx;
}
class CarrierTrackAndTraceInformation implements IConvertible
{
String carrierTrackAndTraceURL = "";
String packageTrackingNumber = "";
CarrierTrackAndTraceInformation({this.carrierTrackAndTraceURL,this.packageTrackingNumber});
CarrierTrackAndTraceInformation.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
carrierTrackAndTraceURL = json['carrierTrackAndTraceURL'];
packageTrackingNumber = json['packageTrackingNumber'];
return this;
}
Map<String, dynamic> toJson() => {
'carrierTrackAndTraceURL': carrierTrackAndTraceURL,
'packageTrackingNumber': packageTrackingNumber
};
getTypeName() => "CarrierTrackAndTraceInformation";
TypeContext? context = _ctx;
}
class AdditionalIndividualAssetIdentification implements IConvertible
{
double? value;
String additionalIndividualAssetIdentificationTypeCode = "";
AdditionalIndividualAssetIdentification({this.value,this.additionalIndividualAssetIdentificationTypeCode});
AdditionalIndividualAssetIdentification.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
value = JsonConverters.toDouble(json['value']);
additionalIndividualAssetIdentificationTypeCode = json['additionalIndividualAssetIdentificationTypeCode'];
return this;
}
Map<String, dynamic> toJson() => {
'value': value,
'additionalIndividualAssetIdentificationTypeCode': additionalIndividualAssetIdentificationTypeCode
};
getTypeName() => "AdditionalIndividualAssetIdentification";
TypeContext? context = _ctx;
}
class Ecom_IndividualAssetIdentification implements IConvertible
{
List<AdditionalIndividualAssetIdentification> additionalIndividualAssetIdentification = [];
String giai = "";
Ecom_IndividualAssetIdentification({this.additionalIndividualAssetIdentification,this.giai});
Ecom_IndividualAssetIdentification.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
additionalIndividualAssetIdentification = JsonConverters.fromJson(json['additionalIndividualAssetIdentification'],'List<AdditionalIndividualAssetIdentification>',context!);
giai = json['giai'];
return this;
}
Map<String, dynamic> toJson() => {
'additionalIndividualAssetIdentification': JsonConverters.toJson(additionalIndividualAssetIdentification,'List<AdditionalIndividualAssetIdentification>',context!),
'giai': giai
};
getTypeName() => "Ecom_IndividualAssetIdentification";
TypeContext? context = _ctx;
}
class AdditionalLogisticUnitIdentification implements IConvertible
{
double? value;
String additionalLogisticUnitIdentificationTypeCode = "";
AdditionalLogisticUnitIdentification({this.value,this.additionalLogisticUnitIdentificationTypeCode});
AdditionalLogisticUnitIdentification.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
value = JsonConverters.toDouble(json['value']);
additionalLogisticUnitIdentificationTypeCode = json['additionalLogisticUnitIdentificationTypeCode'];
return this;
}
Map<String, dynamic> toJson() => {
'value': value,
'additionalLogisticUnitIdentificationTypeCode': additionalLogisticUnitIdentificationTypeCode
};
getTypeName() => "AdditionalLogisticUnitIdentification";
TypeContext? context = _ctx;
}
class Ecom_LogisticUnitIdentification implements IConvertible
{
List<AdditionalLogisticUnitIdentification> additionalLogisiticUnitIdentification = [];
String sscc = "";
Ecom_LogisticUnitIdentification({this.additionalLogisiticUnitIdentification,this.sscc});
Ecom_LogisticUnitIdentification.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
additionalLogisiticUnitIdentification = JsonConverters.fromJson(json['additionalLogisiticUnitIdentification'],'List<AdditionalLogisticUnitIdentification>',context!);
sscc = json['sscc'];
return this;
}
Map<String, dynamic> toJson() => {
'additionalLogisiticUnitIdentification': JsonConverters.toJson(additionalLogisiticUnitIdentification,'List<AdditionalLogisticUnitIdentification>',context!),
'sscc': sscc
};
getTypeName() => "Ecom_LogisticUnitIdentification";
TypeContext? context = _ctx;
}
class LogisticUnits implements IConvertible
{
String childPackageTypeCode = "";
int? levelIdentification;
String packageTypeCode = "";
int? parentLevelIdentification;
int? quantityOfChildren;
int? quantityOfLogisticUnits;
LogisticUnitMeasurement logisticUnitMeasurement;
List<ReturnablePackaging> returnablePackaging = [];
CarrierTrackAndTraceInformation carrierTrackAndTraceInformation;
AvpList avpList;
List<Ecom_IndividualAssetIdentification> individualAssetIdentification = [];
Ecom_LogisticUnitIdentification logisticUnitIdentification;
LogisticUnits({this.childPackageTypeCode,this.levelIdentification,this.packageTypeCode,this.parentLevelIdentification,this.quantityOfChildren,this.quantityOfLogisticUnits,this.logisticUnitMeasurement,this.returnablePackaging,this.carrierTrackAndTraceInformation,this.avpList,this.individualAssetIdentification,this.logisticUnitIdentification});
LogisticUnits.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
childPackageTypeCode = json['childPackageTypeCode'];
levelIdentification = json['levelIdentification'];
packageTypeCode = json['packageTypeCode'];
parentLevelIdentification = json['parentLevelIdentification'];
quantityOfChildren = json['quantityOfChildren'];
quantityOfLogisticUnits = json['quantityOfLogisticUnits'];
logisticUnitMeasurement = JsonConverters.fromJson(json['logisticUnitMeasurement'],'LogisticUnitMeasurement',context!);
returnablePackaging = JsonConverters.fromJson(json['returnablePackaging'],'List<ReturnablePackaging>',context!);
carrierTrackAndTraceInformation = JsonConverters.fromJson(json['carrierTrackAndTraceInformation'],'CarrierTrackAndTraceInformation',context!);
avpList = JsonConverters.fromJson(json['avpList'],'AvpList',context!);
individualAssetIdentification = JsonConverters.fromJson(json['individualAssetIdentification'],'List<Ecom_IndividualAssetIdentification>',context!);
logisticUnitIdentification = JsonConverters.fromJson(json['logisticUnitIdentification'],'Ecom_LogisticUnitIdentification',context!);
return this;
}
Map<String, dynamic> toJson() => {
'childPackageTypeCode': childPackageTypeCode,
'levelIdentification': levelIdentification,
'packageTypeCode': packageTypeCode,
'parentLevelIdentification': parentLevelIdentification,
'quantityOfChildren': quantityOfChildren,
'quantityOfLogisticUnits': quantityOfLogisticUnits,
'logisticUnitMeasurement': JsonConverters.toJson(logisticUnitMeasurement,'LogisticUnitMeasurement',context!),
'returnablePackaging': JsonConverters.toJson(returnablePackaging,'List<ReturnablePackaging>',context!),
'carrierTrackAndTraceInformation': JsonConverters.toJson(carrierTrackAndTraceInformation,'CarrierTrackAndTraceInformation',context!),
'avpList': JsonConverters.toJson(avpList,'AvpList',context!),
'individualAssetIdentification': JsonConverters.toJson(individualAssetIdentification,'List<Ecom_IndividualAssetIdentification>',context!),
'logisticUnitIdentification': JsonConverters.toJson(logisticUnitIdentification,'Ecom_LogisticUnitIdentification',context!)
};
getTypeName() => "LogisticUnits";
TypeContext? context = _ctx;
}
class Quantity implements IConvertible
{
double? value;
String measurementUnitCode = "";
String codeListVersion = "";
Quantity({this.value,this.measurementUnitCode,this.codeListVersion});
Quantity.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
value = JsonConverters.toDouble(json['value']);
measurementUnitCode = json['measurementUnitCode'];
codeListVersion = json['codeListVersion'];
return this;
}
Map<String, dynamic> toJson() => {
'value': value,
'measurementUnitCode': measurementUnitCode,
'codeListVersion': codeListVersion
};
getTypeName() => "Quantity";
TypeContext? context = _ctx;
}
class ReceivingConditionInformation implements IConvertible
{
String receivedGoodsDisposition = "";
String receivingConditionCode = "";
Quantity receivingConditionQuantity;
ReceivingConditionInformation({this.receivedGoodsDisposition,this.receivingConditionCode,this.receivingConditionQuantity});
ReceivingConditionInformation.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
receivedGoodsDisposition = json['receivedGoodsDisposition'];
receivingConditionCode = json['receivingConditionCode'];
receivingConditionQuantity = JsonConverters.fromJson(json['receivingConditionQuantity'],'Quantity',context!);
return this;
}
Map<String, dynamic> toJson() => {
'receivedGoodsDisposition': receivedGoodsDisposition,
'receivingConditionCode': receivingConditionCode,
'receivingConditionQuantity': JsonConverters.toJson(receivingConditionQuantity,'Quantity',context!)
};
getTypeName() => "ReceivingConditionInformation";
TypeContext? context = _ctx;
}
class TransactionalItem implements IConvertible
{
String measurementUnitCode = "";
String measurementType = "";
String measurementValue = "";
TransactionalItem({this.measurementUnitCode,this.measurementType,this.measurementValue});
TransactionalItem.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
measurementUnitCode = json['measurementUnitCode'];
measurementType = json['measurementType'];
measurementValue = json['measurementValue'];
return this;
}
Map<String, dynamic> toJson() => {
'measurementUnitCode': measurementUnitCode,
'measurementType': measurementType,
'measurementValue': measurementValue
};
getTypeName() => "TransactionalItem";
TypeContext? context = _ctx;
}
class SerialNumberRange implements IConvertible
{
String maximumValue = "";
String minimumValue = "";
SerialNumberRange({this.maximumValue,this.minimumValue});
SerialNumberRange.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
maximumValue = json['maximumValue'];
minimumValue = json['minimumValue'];
return this;
}
Map<String, dynamic> toJson() => {
'maximumValue': maximumValue,
'minimumValue': minimumValue
};
getTypeName() => "SerialNumberRange";
TypeContext? context = _ctx;
}
class TransactionalItemDimension implements IConvertible
{
String measurementUnitCode = "";
String depth = "";
String height = "";
String width = "";
TransactionalItemDimension({this.measurementUnitCode,this.depth,this.height,this.width});
TransactionalItemDimension.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
measurementUnitCode = json['measurementUnitCode'];
depth = json['depth'];
height = json['height'];
width = json['width'];
return this;
}
Map<String, dynamic> toJson() => {
'measurementUnitCode': measurementUnitCode,
'depth': depth,
'height': height,
'width': width
};
getTypeName() => "TransactionalItemDimension";
TypeContext? context = _ctx;
}
class TransactionalItemLogisticUnitInformation implements IConvertible
{
int? numberOfLayers;
int? numberOfUnitsPerLayer;
int? numberOfUnitsPerPallet;
String packagingTerms = "";
String packageTypeCode = "";
int? maximumStackingFactor;
String returnablePackageTransportCostPayment = "";
List<TransactionalItemDimension> dimensionsOfLogisticUnit = [];
TransactionalItemLogisticUnitInformation({this.numberOfLayers,this.numberOfUnitsPerLayer,this.numberOfUnitsPerPallet,this.packagingTerms,this.packageTypeCode,this.maximumStackingFactor,this.returnablePackageTransportCostPayment,this.dimensionsOfLogisticUnit});
TransactionalItemLogisticUnitInformation.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
numberOfLayers = json['numberOfLayers'];
numberOfUnitsPerLayer = json['numberOfUnitsPerLayer'];
numberOfUnitsPerPallet = json['numberOfUnitsPerPallet'];
packagingTerms = json['packagingTerms'];
packageTypeCode = json['packageTypeCode'];
maximumStackingFactor = json['maximumStackingFactor'];
returnablePackageTransportCostPayment = json['returnablePackageTransportCostPayment'];
dimensionsOfLogisticUnit = JsonConverters.fromJson(json['dimensionsOfLogisticUnit'],'List<TransactionalItemDimension>',context!);
return this;
}
Map<String, dynamic> toJson() => {
'numberOfLayers': numberOfLayers,
'numberOfUnitsPerLayer': numberOfUnitsPerLayer,
'numberOfUnitsPerPallet': numberOfUnitsPerPallet,
'packagingTerms': packagingTerms,
'packageTypeCode': packageTypeCode,
'maximumStackingFactor': maximumStackingFactor,
'returnablePackageTransportCostPayment': returnablePackageTransportCostPayment,
'dimensionsOfLogisticUnit': JsonConverters.toJson(dimensionsOfLogisticUnit,'List<TransactionalItemDimension>',context!)
};
getTypeName() => "TransactionalItemLogisticUnitInformation";
TypeContext? context = _ctx;
}
class TransactionalItemDataCarrierAndIdentification implements IConvertible
{
String gs1TransactionalItemIdentificationKey = "";
String dataCarrier = "";
TransactionalItemDataCarrierAndIdentification({this.gs1TransactionalItemIdentificationKey,this.dataCarrier});
TransactionalItemDataCarrierAndIdentification.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
gs1TransactionalItemIdentificationKey = json['gs1TransactionalItemIdentificationKey'];
dataCarrier = json['dataCarrier'];
return this;
}
Map<String, dynamic> toJson() => {
'gs1TransactionalItemIdentificationKey': gs1TransactionalItemIdentificationKey,
'dataCarrier': dataCarrier
};
getTypeName() => "TransactionalItemDataCarrierAndIdentification";
TypeContext? context = _ctx;
}
class TradeItemWaste implements IConvertible
{
String wasteIdentification = "";
List<AvpList> typeOfWaste = [];
TradeItemWaste({this.wasteIdentification,this.typeOfWaste});
TradeItemWaste.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
wasteIdentification = json['wasteIdentification'];
typeOfWaste = JsonConverters.fromJson(json['typeOfWaste'],'List<AvpList>',context!);
return this;
}
Map<String, dynamic> toJson() => {
'wasteIdentification': wasteIdentification,
'typeOfWaste': JsonConverters.toJson(typeOfWaste,'List<AvpList>',context!)
};
getTypeName() => "TradeItemWaste";
TypeContext? context = _ctx;
}
class TransactionalItemOrganicInformation implements IConvertible
{
bool? isTradeItemOrganic;
String organicCertification = "";
TransactionalItemOrganicInformation({this.isTradeItemOrganic,this.organicCertification});
TransactionalItemOrganicInformation.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
isTradeItemOrganic = json['isTradeItemOrganic'];
organicCertification = json['organicCertification'];
return this;
}
Map<String, dynamic> toJson() => {
'isTradeItemOrganic': isTradeItemOrganic,
'organicCertification': organicCertification
};
getTypeName() => "TransactionalItemOrganicInformation";
TypeContext? context = _ctx;
}
class TransactionalItemData implements IConvertible
{
DateTime? availableForSaleDate;
String batchNumber = "";
DateTime? bestBeforeDate;
String countryOfOrigin = "";
DateTime? itemExpirationDate;
String lotNumber = "";
DateTime? packagingDate;
DateTime? productionDate;
String productQualityIndication = "";
DateTime? sellByDate;
List<String> serialNumber = [];
String shelfLife = "";
int? tradeItemQuantity;
bool? itemInContactWithFoodProduct;
List<TransactionalItem> transactionalItemWeight = [];
List<TransactionalItem> transactionalItemVolume = [];
List<SerialNumberRange> serialNumberRange = [];
List<TransactionalItemDimension> transactionalItemDimensions = [];
TransactionalItemLogisticUnitInformation transactionalItemLogisticUnitInformation;
TransactionalItemDataCarrierAndIdentification transactionalItemDataCarrierAndIdentification;
List<TradeItemWaste> tradeItemWaste = [];
TransactionalItemOrganicInformation transactionalItemOrganicInformation;
List<AvpList> avpList = [];
TransactionalItemData({this.availableForSaleDate,this.batchNumber,this.bestBeforeDate,this.countryOfOrigin,this.itemExpirationDate,this.lotNumber,this.packagingDate,this.productionDate,this.productQualityIndication,this.sellByDate,this.serialNumber,this.shelfLife,this.tradeItemQuantity,this.itemInContactWithFoodProduct,this.transactionalItemWeight,this.transactionalItemVolume,this.serialNumberRange,this.transactionalItemDimensions,this.transactionalItemLogisticUnitInformation,this.transactionalItemDataCarrierAndIdentification,this.tradeItemWaste,this.transactionalItemOrganicInformation,this.avpList});
TransactionalItemData.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
availableForSaleDate = JsonConverters.fromJson(json['availableForSaleDate'],'DateTime',context!);
batchNumber = json['batchNumber'];
bestBeforeDate = JsonConverters.fromJson(json['bestBeforeDate'],'DateTime',context!);
countryOfOrigin = json['countryOfOrigin'];
itemExpirationDate = JsonConverters.fromJson(json['itemExpirationDate'],'DateTime',context!);
lotNumber = json['lotNumber'];
packagingDate = JsonConverters.fromJson(json['packagingDate'],'DateTime',context!);
productionDate = JsonConverters.fromJson(json['productionDate'],'DateTime',context!);
productQualityIndication = json['productQualityIndication'];
sellByDate = JsonConverters.fromJson(json['sellByDate'],'DateTime',context!);
serialNumber = JsonConverters.fromJson(json['serialNumber'],'List<String>',context!);
shelfLife = json['shelfLife'];
tradeItemQuantity = json['tradeItemQuantity'];
itemInContactWithFoodProduct = json['itemInContactWithFoodProduct'];
transactionalItemWeight = JsonConverters.fromJson(json['transactionalItemWeight'],'List<TransactionalItem>',context!);
transactionalItemVolume = JsonConverters.fromJson(json['transactionalItemVolume'],'List<TransactionalItem>',context!);
serialNumberRange = JsonConverters.fromJson(json['serialNumberRange'],'List<SerialNumberRange>',context!);
transactionalItemDimensions = JsonConverters.fromJson(json['transactionalItemDimensions'],'List<TransactionalItemDimension>',context!);
transactionalItemLogisticUnitInformation = JsonConverters.fromJson(json['transactionalItemLogisticUnitInformation'],'TransactionalItemLogisticUnitInformation',context!);
transactionalItemDataCarrierAndIdentification = JsonConverters.fromJson(json['transactionalItemDataCarrierAndIdentification'],'TransactionalItemDataCarrierAndIdentification',context!);
tradeItemWaste = JsonConverters.fromJson(json['tradeItemWaste'],'List<TradeItemWaste>',context!);
transactionalItemOrganicInformation = JsonConverters.fromJson(json['transactionalItemOrganicInformation'],'TransactionalItemOrganicInformation',context!);
avpList = JsonConverters.fromJson(json['avpList'],'List<AvpList>',context!);
return this;
}
Map<String, dynamic> toJson() => {
'availableForSaleDate': JsonConverters.toJson(availableForSaleDate,'DateTime',context!),
'batchNumber': batchNumber,
'bestBeforeDate': JsonConverters.toJson(bestBeforeDate,'DateTime',context!),
'countryOfOrigin': countryOfOrigin,
'itemExpirationDate': JsonConverters.toJson(itemExpirationDate,'DateTime',context!),
'lotNumber': lotNumber,
'packagingDate': JsonConverters.toJson(packagingDate,'DateTime',context!),
'productionDate': JsonConverters.toJson(productionDate,'DateTime',context!),
'productQualityIndication': productQualityIndication,
'sellByDate': JsonConverters.toJson(sellByDate,'DateTime',context!),
'serialNumber': JsonConverters.toJson(serialNumber,'List<String>',context!),
'shelfLife': shelfLife,
'tradeItemQuantity': tradeItemQuantity,
'itemInContactWithFoodProduct': itemInContactWithFoodProduct,
'transactionalItemWeight': JsonConverters.toJson(transactionalItemWeight,'List<TransactionalItem>',context!),
'transactionalItemVolume': JsonConverters.toJson(transactionalItemVolume,'List<TransactionalItem>',context!),
'serialNumberRange': JsonConverters.toJson(serialNumberRange,'List<SerialNumberRange>',context!),
'transactionalItemDimensions': JsonConverters.toJson(transactionalItemDimensions,'List<TransactionalItemDimension>',context!),
'transactionalItemLogisticUnitInformation': JsonConverters.toJson(transactionalItemLogisticUnitInformation,'TransactionalItemLogisticUnitInformation',context!),
'transactionalItemDataCarrierAndIdentification': JsonConverters.toJson(transactionalItemDataCarrierAndIdentification,'TransactionalItemDataCarrierAndIdentification',context!),
'tradeItemWaste': JsonConverters.toJson(tradeItemWaste,'List<TradeItemWaste>',context!),
'transactionalItemOrganicInformation': JsonConverters.toJson(transactionalItemOrganicInformation,'TransactionalItemOrganicInformation',context!),
'avpList': JsonConverters.toJson(avpList,'List<AvpList>',context!)
};
getTypeName() => "TransactionalItemData";
TypeContext? context = _ctx;
}
class Colour implements IConvertible
{
String colourCode = "";
String colourDescription = "";
Colour({this.colourCode,this.colourDescription});
Colour.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
colourCode = json['colourCode'];
colourDescription = json['colourDescription'];
return this;
}
Map<String, dynamic> toJson() => {
'colourCode': colourCode,
'colourDescription': colourDescription
};
getTypeName() => "Colour";
TypeContext? context = _ctx;
}
class Size implements IConvertible
{
String descriptiveSize = "";
String sizeCode = "";
Size({this.descriptiveSize,this.sizeCode});
Size.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
descriptiveSize = json['descriptiveSize'];
sizeCode = json['sizeCode'];
return this;
}
Map<String, dynamic> toJson() => {
'descriptiveSize': descriptiveSize,
'sizeCode': sizeCode
};
getTypeName() => "Size";
TypeContext? context = _ctx;
}
class TradeItemClassification implements IConvertible
{
String gpcCategoryCode = "";
List<AvpList> additionalTradeItemClassificationCode = [];
String gpcCategoryName = "";
List<AvpList> gpcAttribute = [];
TradeItemClassification({this.gpcCategoryCode,this.additionalTradeItemClassificationCode,this.gpcCategoryName,this.gpcAttribute});
TradeItemClassification.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
gpcCategoryCode = json['gpcCategoryCode'];
additionalTradeItemClassificationCode = JsonConverters.fromJson(json['additionalTradeItemClassificationCode'],'List<AvpList>',context!);
gpcCategoryName = json['gpcCategoryName'];
gpcAttribute = JsonConverters.fromJson(json['gpcAttribute'],'List<AvpList>',context!);
return this;
}
Map<String, dynamic> toJson() => {
'gpcCategoryCode': gpcCategoryCode,
'additionalTradeItemClassificationCode': JsonConverters.toJson(additionalTradeItemClassificationCode,'List<AvpList>',context!),
'gpcCategoryName': gpcCategoryName,
'gpcAttribute': JsonConverters.toJson(gpcAttribute,'List<AvpList>',context!)
};
getTypeName() => "TradeItemClassification";
TypeContext? context = _ctx;
}
class TransactionalTradeItem implements IConvertible
{
String gtin = "";
List<AvpList> additionalTradeItemIdentification = [];
double? tradeItemQuantity;
String tradeItemDescription = "";
String productVariantIdentifier = "";
String itemTypeCode = "";
String tradeItemDataOwner = "";
String butterFatReference = "";
List<TransactionalItemData> transactionalItemData = [];
List<Colour> colour = [];
Size size;
TradeItemClassification tradeItemClassification;
List<AvpList> avpList = [];
TransactionalTradeItem({this.gtin,this.additionalTradeItemIdentification,this.tradeItemQuantity,this.tradeItemDescription,this.productVariantIdentifier,this.itemTypeCode,this.tradeItemDataOwner,this.butterFatReference,this.transactionalItemData,this.colour,this.size,this.tradeItemClassification,this.avpList});
TransactionalTradeItem.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
gtin = json['gtin'];
additionalTradeItemIdentification = JsonConverters.fromJson(json['additionalTradeItemIdentification'],'List<AvpList>',context!);
tradeItemQuantity = JsonConverters.toDouble(json['tradeItemQuantity']);
tradeItemDescription = json['tradeItemDescription'];
productVariantIdentifier = json['productVariantIdentifier'];
itemTypeCode = json['itemTypeCode'];
tradeItemDataOwner = json['tradeItemDataOwner'];
butterFatReference = json['butterFatReference'];
transactionalItemData = JsonConverters.fromJson(json['transactionalItemData'],'List<TransactionalItemData>',context!);
colour = JsonConverters.fromJson(json['colour'],'List<Colour>',context!);
size = JsonConverters.fromJson(json['size'],'Size',context!);
tradeItemClassification = JsonConverters.fromJson(json['tradeItemClassification'],'TradeItemClassification',context!);
avpList = JsonConverters.fromJson(json['avpList'],'List<AvpList>',context!);
return this;
}
Map<String, dynamic> toJson() => {
'gtin': gtin,
'additionalTradeItemIdentification': JsonConverters.toJson(additionalTradeItemIdentification,'List<AvpList>',context!),
'tradeItemQuantity': tradeItemQuantity,
'tradeItemDescription': tradeItemDescription,
'productVariantIdentifier': productVariantIdentifier,
'itemTypeCode': itemTypeCode,
'tradeItemDataOwner': tradeItemDataOwner,
'butterFatReference': butterFatReference,
'transactionalItemData': JsonConverters.toJson(transactionalItemData,'List<TransactionalItemData>',context!),
'colour': JsonConverters.toJson(colour,'List<Colour>',context!),
'size': JsonConverters.toJson(size,'Size',context!),
'tradeItemClassification': JsonConverters.toJson(tradeItemClassification,'TradeItemClassification',context!),
'avpList': JsonConverters.toJson(avpList,'List<AvpList>',context!)
};
getTypeName() => "TransactionalTradeItem";
TypeContext? context = _ctx;
}
class TradeItemIdentification implements IConvertible
{
List<AvpList> additionalTradeItemIdentification = [];
String gtin = "";
TradeItemIdentification({this.additionalTradeItemIdentification,this.gtin});
TradeItemIdentification.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
additionalTradeItemIdentification = JsonConverters.fromJson(json['additionalTradeItemIdentification'],'List<AvpList>',context!);
gtin = json['gtin'];
return this;
}
Map<String, dynamic> toJson() => {
'additionalTradeItemIdentification': JsonConverters.toJson(additionalTradeItemIdentification,'List<AvpList>',context!),
'gtin': gtin
};
getTypeName() => "TradeItemIdentification";
TypeContext? context = _ctx;
}
class ReceivingAdviceLineItem implements IConvertible
{
String Extension = "";
int? lineItemNumber;
String note = "";
int? parentLineItemNumber;
Quantity quantityAccepted;
Quantity quantityDespatched;
Quantity quantityReceived;
List<ReceivingConditionInformation> receivingConditionInformation = [];
TransactionalTradeItem transactionalTradeItem;
ConsignmentIdentification consignmentIdentification;
AvpList avpList;
DocumentReference contract;
DocumentReference customerReference;
DocumentReference deliveryNote;
DocumentReference despatchAdvice;
DocumentReference productCertification;
DocumentReference promotionalDeal;
DocumentReference purchaseConditions;
DocumentReference purchaseOrder;
TradeItemIdentification requestedItemIdentification;
DocumentReference specification;
ReceivingAdviceLineItem({this.Extension,this.lineItemNumber,this.note,this.parentLineItemNumber,this.quantityAccepted,this.quantityDespatched,this.quantityReceived,this.receivingConditionInformation,this.transactionalTradeItem,this.consignmentIdentification,this.avpList,this.contract,this.customerReference,this.deliveryNote,this.despatchAdvice,this.productCertification,this.promotionalDeal,this.purchaseConditions,this.purchaseOrder,this.requestedItemIdentification,this.specification});
ReceivingAdviceLineItem.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
Extension = json['extension'];
lineItemNumber = json['lineItemNumber'];
note = json['note'];
parentLineItemNumber = json['parentLineItemNumber'];
quantityAccepted = JsonConverters.fromJson(json['quantityAccepted'],'Quantity',context!);
quantityDespatched = JsonConverters.fromJson(json['quantityDespatched'],'Quantity',context!);
quantityReceived = JsonConverters.fromJson(json['quantityReceived'],'Quantity',context!);
receivingConditionInformation = JsonConverters.fromJson(json['receivingConditionInformation'],'List<ReceivingConditionInformation>',context!);
transactionalTradeItem = JsonConverters.fromJson(json['transactionalTradeItem'],'TransactionalTradeItem',context!);
consignmentIdentification = JsonConverters.fromJson(json['consignmentIdentification'],'ConsignmentIdentification',context!);
avpList = JsonConverters.fromJson(json['avpList'],'AvpList',context!);
contract = JsonConverters.fromJson(json['contract'],'DocumentReference',context!);
customerReference = JsonConverters.fromJson(json['customerReference'],'DocumentReference',context!);
deliveryNote = JsonConverters.fromJson(json['deliveryNote'],'DocumentReference',context!);
despatchAdvice = JsonConverters.fromJson(json['despatchAdvice'],'DocumentReference',context!);
productCertification = JsonConverters.fromJson(json['productCertification'],'DocumentReference',context!);
promotionalDeal = JsonConverters.fromJson(json['promotionalDeal'],'DocumentReference',context!);
purchaseConditions = JsonConverters.fromJson(json['purchaseConditions'],'DocumentReference',context!);
purchaseOrder = JsonConverters.fromJson(json['purchaseOrder'],'DocumentReference',context!);
requestedItemIdentification = JsonConverters.fromJson(json['requestedItemIdentification'],'TradeItemIdentification',context!);
specification = JsonConverters.fromJson(json['specification'],'DocumentReference',context!);
return this;
}
Map<String, dynamic> toJson() => {
'extension': Extension,
'lineItemNumber': lineItemNumber,
'note': note,
'parentLineItemNumber': parentLineItemNumber,
'quantityAccepted': JsonConverters.toJson(quantityAccepted,'Quantity',context!),
'quantityDespatched': JsonConverters.toJson(quantityDespatched,'Quantity',context!),
'quantityReceived': JsonConverters.toJson(quantityReceived,'Quantity',context!),
'receivingConditionInformation': JsonConverters.toJson(receivingConditionInformation,'List<ReceivingConditionInformation>',context!),
'transactionalTradeItem': JsonConverters.toJson(transactionalTradeItem,'TransactionalTradeItem',context!),
'consignmentIdentification': JsonConverters.toJson(consignmentIdentification,'ConsignmentIdentification',context!),
'avpList': JsonConverters.toJson(avpList,'AvpList',context!),
'contract': JsonConverters.toJson(contract,'DocumentReference',context!),
'customerReference': JsonConverters.toJson(customerReference,'DocumentReference',context!),
'deliveryNote': JsonConverters.toJson(deliveryNote,'DocumentReference',context!),
'despatchAdvice': JsonConverters.toJson(despatchAdvice,'DocumentReference',context!),
'productCertification': JsonConverters.toJson(productCertification,'DocumentReference',context!),
'promotionalDeal': JsonConverters.toJson(promotionalDeal,'DocumentReference',context!),
'purchaseConditions': JsonConverters.toJson(purchaseConditions,'DocumentReference',context!),
'purchaseOrder': JsonConverters.toJson(purchaseOrder,'DocumentReference',context!),
'requestedItemIdentification': JsonConverters.toJson(requestedItemIdentification,'TradeItemIdentification',context!),
'specification': JsonConverters.toJson(specification,'DocumentReference',context!)
};
getTypeName() => "ReceivingAdviceLineItem";
TypeContext? context = _ctx;
}
class ReceivingAdviceLogisticUnit extends LogisticUnits implements IConvertible
{
List<ReceivingAdviceLineItem> receivingAdviceLineItem = [];
ReceivingAdviceLogisticUnit({this.receivingAdviceLineItem});
ReceivingAdviceLogisticUnit.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
super.fromMap(json);
receivingAdviceLineItem = JsonConverters.fromJson(json['receivingAdviceLineItem'],'List<ReceivingAdviceLineItem>',context!);
return this;
}
Map<String, dynamic> toJson() => super.toJson()..addAll({
'receivingAdviceLineItem': JsonConverters.toJson(receivingAdviceLineItem,'List<ReceivingAdviceLineItem>',context!)
});
getTypeName() => "ReceivingAdviceLogisticUnit";
TypeContext? context = _ctx;
}
class ReceivingAdvice extends BaseDocument implements IConvertible
{
DateTime? despatchAdviceDeliveryDateTime;
String note = "";
DateTime? paymentDateTime;
DateTime? receivingDateTime;
String reportingCode = "";
double? totalDepositAmount;
ReceivingAdviceTransportInformation receivingAdviceTransportInformation;
DocumentReference billOfLadingNumber;
TransactionalParty buyer;
TransactionalParty carrier;
ConsignmentIdentification consignmentIdentification;
DocumentReference deliveryNote;
String despatchAdvice = "";
TransactionalParty inventoryLocation;
DocumentReference purchaseOrder;
TransactionalParty receiver;
String receivingAdviceIdentification = "";
TransactionalParty seller;
TransactionalParty shipFrom;
ConsignmentIdentification shipmentIdentification;
TransactionalParty shipper;
TransactionalParty shipTo;
List<ReceivingAdviceLogisticUnit> receivingAdviceLogisticUnit = [];
ReceivingAdvice({this.despatchAdviceDeliveryDateTime,this.note,this.paymentDateTime,this.receivingDateTime,this.reportingCode,this.totalDepositAmount,this.receivingAdviceTransportInformation,this.billOfLadingNumber,this.buyer,this.carrier,this.consignmentIdentification,this.deliveryNote,this.despatchAdvice,this.inventoryLocation,this.purchaseOrder,this.receiver,this.receivingAdviceIdentification,this.seller,this.shipFrom,this.shipmentIdentification,this.shipper,this.shipTo,this.receivingAdviceLogisticUnit});
ReceivingAdvice.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
super.fromMap(json);
despatchAdviceDeliveryDateTime = JsonConverters.fromJson(json['despatchAdviceDeliveryDateTime'],'DateTime',context!);
note = json['note'];
paymentDateTime = JsonConverters.fromJson(json['paymentDateTime'],'DateTime',context!);
receivingDateTime = JsonConverters.fromJson(json['receivingDateTime'],'DateTime',context!);
reportingCode = json['reportingCode'];
totalDepositAmount = JsonConverters.toDouble(json['totalDepositAmount']);
receivingAdviceTransportInformation = JsonConverters.fromJson(json['receivingAdviceTransportInformation'],'ReceivingAdviceTransportInformation',context!);
billOfLadingNumber = JsonConverters.fromJson(json['billOfLadingNumber'],'DocumentReference',context!);
buyer = JsonConverters.fromJson(json['buyer'],'TransactionalParty',context!);
carrier = JsonConverters.fromJson(json['carrier'],'TransactionalParty',context!);
consignmentIdentification = JsonConverters.fromJson(json['consignmentIdentification'],'ConsignmentIdentification',context!);
deliveryNote = JsonConverters.fromJson(json['deliveryNote'],'DocumentReference',context!);
despatchAdvice = json['despatchAdvice'];
inventoryLocation = JsonConverters.fromJson(json['inventoryLocation'],'TransactionalParty',context!);
purchaseOrder = JsonConverters.fromJson(json['purchaseOrder'],'DocumentReference',context!);
receiver = JsonConverters.fromJson(json['receiver'],'TransactionalParty',context!);
receivingAdviceIdentification = json['receivingAdviceIdentification'];
seller = JsonConverters.fromJson(json['seller'],'TransactionalParty',context!);
shipFrom = JsonConverters.fromJson(json['shipFrom'],'TransactionalParty',context!);
shipmentIdentification = JsonConverters.fromJson(json['shipmentIdentification'],'ConsignmentIdentification',context!);
shipper = JsonConverters.fromJson(json['shipper'],'TransactionalParty',context!);
shipTo = JsonConverters.fromJson(json['shipTo'],'TransactionalParty',context!);
receivingAdviceLogisticUnit = JsonConverters.fromJson(json['receivingAdviceLogisticUnit'],'List<ReceivingAdviceLogisticUnit>',context!);
return this;
}
Map<String, dynamic> toJson() => super.toJson()..addAll({
'despatchAdviceDeliveryDateTime': JsonConverters.toJson(despatchAdviceDeliveryDateTime,'DateTime',context!),
'note': note,
'paymentDateTime': JsonConverters.toJson(paymentDateTime,'DateTime',context!),
'receivingDateTime': JsonConverters.toJson(receivingDateTime,'DateTime',context!),
'reportingCode': reportingCode,
'totalDepositAmount': totalDepositAmount,
'receivingAdviceTransportInformation': JsonConverters.toJson(receivingAdviceTransportInformation,'ReceivingAdviceTransportInformation',context!),
'billOfLadingNumber': JsonConverters.toJson(billOfLadingNumber,'DocumentReference',context!),
'buyer': JsonConverters.toJson(buyer,'TransactionalParty',context!),
'carrier': JsonConverters.toJson(carrier,'TransactionalParty',context!),
'consignmentIdentification': JsonConverters.toJson(consignmentIdentification,'ConsignmentIdentification',context!),
'deliveryNote': JsonConverters.toJson(deliveryNote,'DocumentReference',context!),
'despatchAdvice': despatchAdvice,
'inventoryLocation': JsonConverters.toJson(inventoryLocation,'TransactionalParty',context!),
'purchaseOrder': JsonConverters.toJson(purchaseOrder,'DocumentReference',context!),
'receiver': JsonConverters.toJson(receiver,'TransactionalParty',context!),
'receivingAdviceIdentification': receivingAdviceIdentification,
'seller': JsonConverters.toJson(seller,'TransactionalParty',context!),
'shipFrom': JsonConverters.toJson(shipFrom,'TransactionalParty',context!),
'shipmentIdentification': JsonConverters.toJson(shipmentIdentification,'ConsignmentIdentification',context!),
'shipper': JsonConverters.toJson(shipper,'TransactionalParty',context!),
'shipTo': JsonConverters.toJson(shipTo,'TransactionalParty',context!),
'receivingAdviceLogisticUnit': JsonConverters.toJson(receivingAdviceLogisticUnit,'List<ReceivingAdviceLogisticUnit>',context!)
});
getTypeName() => "ReceivingAdvice";
TypeContext? context = _ctx;
}
class ReceivingAdviceMessage implements IConvertible
{
Header header;
ReceivingAdvice receivingAdvice;
ReceivingAdviceMessage({this.header,this.receivingAdvice});
ReceivingAdviceMessage.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
header = JsonConverters.fromJson(json['header'],'Header',context!);
receivingAdvice = JsonConverters.fromJson(json['receivingAdvice'],'ReceivingAdvice',context!);
return this;
}
Map<String, dynamic> toJson() => {
'header': JsonConverters.toJson(header,'Header',context!),
'receivingAdvice': JsonConverters.toJson(receivingAdvice,'ReceivingAdvice',context!)
};
getTypeName() => "ReceivingAdviceMessage";
TypeContext? context = _ctx;
}
/**
* Receiving Advice
*/
// @Api(Description="Receiving Advice")
// @ApiResponse(Description="Add ReceivingAdvice request received", IsDefaultResponse=true, StatusCode=200)
// @ApiResponse(Description="ReceivingAdvice not accepted, Confirm Sender GLN", ResponseType=typeof(UnauthorizedAccessException), StatusCode=403)
class AddReceivingAdvice implements IConvertible
{
/**
* ReceivingAdvice model containing all of the ReceivingAdvice data
*/
// @ApiMember(Description="ReceivingAdvice model containing all of the ReceivingAdvice data", ParameterType="model")
ReceivingAdviceMessage receivingAdvice;
AddReceivingAdvice({this.receivingAdvice});
AddReceivingAdvice.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
receivingAdvice = JsonConverters.fromJson(json['receivingAdvice'],'ReceivingAdviceMessage',context!);
return this;
}
Map<String, dynamic> toJson() => {
'receivingAdvice': JsonConverters.toJson(receivingAdvice,'ReceivingAdviceMessage',context!)
};
getTypeName() => "AddReceivingAdvice";
TypeContext? context = _ctx;
}
TypeContext _ctx = TypeContext(library: 'stf_api_uat.data_xchange.co.za', types: <String, TypeInfo> {
'TokenDto': TypeInfo(TypeOf.Class, create:() => TokenDto()),
'DocumentIdentification': TypeInfo(TypeOf.Class, create:() => DocumentIdentification()),
'Identifier': TypeInfo(TypeOf.Class, create:() => Identifier()),
'ContactInformation': TypeInfo(TypeOf.Class, create:() => ContactInformation()),
'Partner': TypeInfo(TypeOf.Class, create:() => Partner()),
'List<ContactInformation>': TypeInfo(TypeOf.Class, create:() => <ContactInformation>[]),
'Header': TypeInfo(TypeOf.Class, create:() => Header()),
'DocumentAction': TypeInfo(TypeOf.Enum, enumValues:DocumentAction.values),
'DocumentStatus': TypeInfo(TypeOf.Enum, enumValues:DocumentStatus.values),
'AvpList': TypeInfo(TypeOf.Class, create:() => AvpList()),
'BaseDocument': TypeInfo(TypeOf.Class, create:() => BaseDocument()),
'List<AvpList>': TypeInfo(TypeOf.Class, create:() => <AvpList>[]),
'CommunicationChannel': TypeInfo(TypeOf.Class, create:() => CommunicationChannel()),
'Contact': TypeInfo(TypeOf.Class, create:() => Contact()),
'List<CommunicationChannel>': TypeInfo(TypeOf.Class, create:() => <CommunicationChannel>[]),
'IdentityDocument': TypeInfo(TypeOf.Class, create:() => IdentityDocument()),
'Person': TypeInfo(TypeOf.Class, create:() => Person()),
'List<IdentityDocument>': TypeInfo(TypeOf.Class, create:() => <IdentityDocument>[]),
'ReceivingAdviceTransportInformation': TypeInfo(TypeOf.Class, create:() => ReceivingAdviceTransportInformation()),
'DocumentReference': TypeInfo(TypeOf.Class, create:() => DocumentReference()),
'Ecom_PartyIdentificationType': TypeInfo(TypeOf.Class, create:() => Ecom_PartyIdentificationType()),
'Address': TypeInfo(TypeOf.Class, create:() => Address()),
'FinancialRoutingNumber': TypeInfo(TypeOf.Class, create:() => FinancialRoutingNumber()),
'FinancialAccount': TypeInfo(TypeOf.Class, create:() => FinancialAccount()),
'FinancialInstitutionInformation': TypeInfo(TypeOf.Class, create:() => FinancialInstitutionInformation()),
'TransactionalParty': TypeInfo(TypeOf.Class, create:() => TransactionalParty()),
'List<Contact>': TypeInfo(TypeOf.Class, create:() => <Contact>[]),
'AdditionalConsignmentIdentification': TypeInfo(TypeOf.Class, create:() => AdditionalConsignmentIdentification()),
'ConsignmentIdentification': TypeInfo(TypeOf.Class, create:() => ConsignmentIdentification()),
'Measurement': TypeInfo(TypeOf.Class, create:() => Measurement()),
'Dimension': TypeInfo(TypeOf.Class, create:() => Dimension()),
'UnitMeasurement': TypeInfo(TypeOf.Class, create:() => UnitMeasurement()),
'LogisticUnitMeasurement': TypeInfo(TypeOf.Class, create:() => LogisticUnitMeasurement()),
'AdditionalReturnableAssetIdentification': TypeInfo(TypeOf.Class, create:() => AdditionalReturnableAssetIdentification()),
'ReturnableAssetIdentification': TypeInfo(TypeOf.Class, create:() => ReturnableAssetIdentification()),
'List<AdditionalReturnableAssetIdentification>': TypeInfo(TypeOf.Class, create:() => <AdditionalReturnableAssetIdentification>[]),
'ReturnablePackaging': TypeInfo(TypeOf.Class, create:() => ReturnablePackaging()),
'List<ReturnableAssetIdentification>': TypeInfo(TypeOf.Class, create:() => <ReturnableAssetIdentification>[]),
'CarrierTrackAndTraceInformation': TypeInfo(TypeOf.Class, create:() => CarrierTrackAndTraceInformation()),
'AdditionalIndividualAssetIdentification': TypeInfo(TypeOf.Class, create:() => AdditionalIndividualAssetIdentification()),
'Ecom_IndividualAssetIdentification': TypeInfo(TypeOf.Class, create:() => Ecom_IndividualAssetIdentification()),
'List<AdditionalIndividualAssetIdentification>': TypeInfo(TypeOf.Class, create:() => <AdditionalIndividualAssetIdentification>[]),
'AdditionalLogisticUnitIdentification': TypeInfo(TypeOf.Class, create:() => AdditionalLogisticUnitIdentification()),
'Ecom_LogisticUnitIdentification': TypeInfo(TypeOf.Class, create:() => Ecom_LogisticUnitIdentification()),
'List<AdditionalLogisticUnitIdentification>': TypeInfo(TypeOf.Class, create:() => <AdditionalLogisticUnitIdentification>[]),
'LogisticUnits': TypeInfo(TypeOf.Class, create:() => LogisticUnits()),
'List<ReturnablePackaging>': TypeInfo(TypeOf.Class, create:() => <ReturnablePackaging>[]),
'List<Ecom_IndividualAssetIdentification>': TypeInfo(TypeOf.Class, create:() => <Ecom_IndividualAssetIdentification>[]),
'Quantity': TypeInfo(TypeOf.Class, create:() => Quantity()),
'ReceivingConditionInformation': TypeInfo(TypeOf.Class, create:() => ReceivingConditionInformation()),
'TransactionalItem': TypeInfo(TypeOf.Class, create:() => TransactionalItem()),
'SerialNumberRange': TypeInfo(TypeOf.Class, create:() => SerialNumberRange()),
'TransactionalItemDimension': TypeInfo(TypeOf.Class, create:() => TransactionalItemDimension()),
'TransactionalItemLogisticUnitInformation': TypeInfo(TypeOf.Class, create:() => TransactionalItemLogisticUnitInformation()),
'List<TransactionalItemDimension>': TypeInfo(TypeOf.Class, create:() => <TransactionalItemDimension>[]),
'TransactionalItemDataCarrierAndIdentification': TypeInfo(TypeOf.Class, create:() => TransactionalItemDataCarrierAndIdentification()),
'TradeItemWaste': TypeInfo(TypeOf.Class, create:() => TradeItemWaste()),
'TransactionalItemOrganicInformation': TypeInfo(TypeOf.Class, create:() => TransactionalItemOrganicInformation()),
'TransactionalItemData': TypeInfo(TypeOf.Class, create:() => TransactionalItemData()),
'List<TransactionalItem>': TypeInfo(TypeOf.Class, create:() => <TransactionalItem>[]),
'List<SerialNumberRange>': TypeInfo(TypeOf.Class, create:() => <SerialNumberRange>[]),
'List<TradeItemWaste>': TypeInfo(TypeOf.Class, create:() => <TradeItemWaste>[]),
'Colour': TypeInfo(TypeOf.Class, create:() => Colour()),
'Size': TypeInfo(TypeOf.Class, create:() => Size()),
'TradeItemClassification': TypeInfo(TypeOf.Class, create:() => TradeItemClassification()),
'TransactionalTradeItem': TypeInfo(TypeOf.Class, create:() => TransactionalTradeItem()),
'List<TransactionalItemData>': TypeInfo(TypeOf.Class, create:() => <TransactionalItemData>[]),
'List<Colour>': TypeInfo(TypeOf.Class, create:() => <Colour>[]),
'TradeItemIdentification': TypeInfo(TypeOf.Class, create:() => TradeItemIdentification()),
'ReceivingAdviceLineItem': TypeInfo(TypeOf.Class, create:() => ReceivingAdviceLineItem()),
'List<ReceivingConditionInformation>': TypeInfo(TypeOf.Class, create:() => <ReceivingConditionInformation>[]),
'ReceivingAdviceLogisticUnit': TypeInfo(TypeOf.Class, create:() => ReceivingAdviceLogisticUnit()),
'List<ReceivingAdviceLineItem>': TypeInfo(TypeOf.Class, create:() => <ReceivingAdviceLineItem>[]),
'ReceivingAdvice': TypeInfo(TypeOf.Class, create:() => ReceivingAdvice()),
'List<ReceivingAdviceLogisticUnit>': TypeInfo(TypeOf.Class, create:() => <ReceivingAdviceLogisticUnit>[]),
'ReceivingAdviceMessage': TypeInfo(TypeOf.Class, create:() => ReceivingAdviceMessage()),
'AddReceivingAdvice': TypeInfo(TypeOf.Class, create:() => AddReceivingAdvice()),
});
To override the Content-type in your clients, use the HTTP Accept Header, append the .jsv suffix or ?format=jsv
The following are sample HTTP requests and responses. The placeholders shown need to be replaced with actual values.
POST /api/receivingAdvice HTTP/1.1
Host: stf-api-uat.data-xchange.co.za
Accept: text/jsv
Content-Type: text/jsv
Content-Length: length
{
receivingAdvice:
{
header:
{
documentIdentification:
{
identifier: String,
type: String
},
sender:
{
identifier:
{
authority: String,
text: String
},
contactInformation:
[
{
}
]
},
receiver:
{
identifier:
{
authority: String,
text: String
},
contactInformation:
[
{
}
]
}
},
receivingAdvice:
{
despatchAdviceDeliveryDateTime: 0001-01-01,
note: String,
paymentDateTime: 0001-01-01,
receivingDateTime: 0001-01-01,
reportingCode: String,
totalDepositAmount: 0,
receivingAdviceTransportInformation:
{
routeID:
{
authority: String,
text: String
},
transportMeansID:
{
authority: String,
text: String
},
transportMeansName: String,
driver:
{
contactTypeCode: String,
personName: String,
departmentName: String,
jobTitle: String,
responsibility: String,
communicationChannel:
[
{
communicationChannelCode: String,
communicationChannelName: String,
communicationValue: String
}
]
},
driverID:
{
dateOfBirth: 0001-01-01,
gender: String,
nationality: String,
personName: String,
identityDocument:
[
{
identityDocumentIssuer: String,
identityDocumentNumber: String,
identityDocumentType: String
}
]
},
receiver:
{
contactTypeCode: String,
personName: String,
departmentName: String,
jobTitle: String,
responsibility: String,
communicationChannel:
[
{
communicationChannelCode: String,
communicationChannelName: String,
communicationValue: String
}
]
},
receiverID:
{
dateOfBirth: 0001-01-01,
gender: String,
nationality: String,
personName: String,
identityDocument:
[
{
identityDocumentIssuer: String,
identityDocumentNumber: String,
identityDocumentType: String
}
]
}
},
billOfLadingNumber:
{
creationDateTime: 0001-01-01,
revisionNumber: 0,
lineItemNumber: 0,
entityIdentification: String
},
buyer:
{
contact:
[
{
contactTypeCode: String,
personName: String,
departmentName: String,
jobTitle: String,
responsibility: String,
communicationChannel:
[
{
communicationChannelCode: String,
communicationChannelName: String,
communicationValue: String
}
]
}
],
address:
{
streetAddressOne: String,
streetAddressTwo: String,
streetAddressThree: String,
city: String,
postalCode: String,
provinceCode: String,
countryCode: String
},
communicationChannel:
[
{
code: String,
value: String
}
],
financialInstitutionInformation:
{
financialInstitutionBranchName: String,
financialInstitutionName: String,
financialRoutingNumber:
{
number: String,
numberTypeCode: String
},
financialAccount:
{
number: String,
numberTypeCode: String,
name: String
},
swiftCode: String,
exportersCode: String
},
dutyFeeTaxRegistration: String,
entityIdentification: String,
gln: String,
name: String,
additionalPartyIdentification:
[
{
code: String,
value: String
}
]
},
carrier:
{
contact:
[
{
contactTypeCode: String,
personName: String,
departmentName: String,
jobTitle: String,
responsibility: String,
communicationChannel:
[
{
communicationChannelCode: String,
communicationChannelName: String,
communicationValue: String
}
]
}
],
address:
{
streetAddressOne: String,
streetAddressTwo: String,
streetAddressThree: String,
city: String,
postalCode: String,
provinceCode: String,
countryCode: String
},
communicationChannel:
[
{
code: String,
value: String
}
],
financialInstitutionInformation:
{
financialInstitutionBranchName: String,
financialInstitutionName: String,
financialRoutingNumber:
{
number: String,
numberTypeCode: String
},
financialAccount:
{
number: String,
numberTypeCode: String,
name: String
},
swiftCode: String,
exportersCode: String
},
dutyFeeTaxRegistration: String,
entityIdentification: String,
gln: String,
name: String,
additionalPartyIdentification:
[
{
code: String,
value: String
}
]
},
consignmentIdentification:
{
ginc: String,
additionalConsignmentIdentification:
{
text: String,
additionalConsignmentIdentificationTypeCode: String
}
},
deliveryNote:
{
creationDateTime: 0001-01-01,
revisionNumber: 0,
lineItemNumber: 0,
entityIdentification: String
},
despatchAdvice: String,
inventoryLocation:
{
contact:
[
{
contactTypeCode: String,
personName: String,
departmentName: String,
jobTitle: String,
responsibility: String,
communicationChannel:
[
{
communicationChannelCode: String,
communicationChannelName: String,
communicationValue: String
}
]
}
],
address:
{
streetAddressOne: String,
streetAddressTwo: String,
streetAddressThree: String,
city: String,
postalCode: String,
provinceCode: String,
countryCode: String
},
communicationChannel:
[
{
code: String,
value: String
}
],
financialInstitutionInformation:
{
financialInstitutionBranchName: String,
financialInstitutionName: String,
financialRoutingNumber:
{
number: String,
numberTypeCode: String
},
financialAccount:
{
number: String,
numberTypeCode: String,
name: String
},
swiftCode: String,
exportersCode: String
},
dutyFeeTaxRegistration: String,
entityIdentification: String,
gln: String,
name: String,
additionalPartyIdentification:
[
{
code: String,
value: String
}
]
},
purchaseOrder:
{
creationDateTime: 0001-01-01,
revisionNumber: 0,
lineItemNumber: 0,
entityIdentification: String
},
receiver:
{
contact:
[
{
contactTypeCode: String,
personName: String,
departmentName: String,
jobTitle: String,
responsibility: String,
communicationChannel:
[
{
communicationChannelCode: String,
communicationChannelName: String,
communicationValue: String
}
]
}
],
address:
{
streetAddressOne: String,
streetAddressTwo: String,
streetAddressThree: String,
city: String,
postalCode: String,
provinceCode: String,
countryCode: String
},
communicationChannel:
[
{
code: String,
value: String
}
],
financialInstitutionInformation:
{
financialInstitutionBranchName: String,
financialInstitutionName: String,
financialRoutingNumber:
{
number: String,
numberTypeCode: String
},
financialAccount:
{
number: String,
numberTypeCode: String,
name: String
},
swiftCode: String,
exportersCode: String
},
dutyFeeTaxRegistration: String,
entityIdentification: String,
gln: String,
name: String,
additionalPartyIdentification:
[
{
code: String,
value: String
}
]
},
receivingAdviceIdentification: String,
seller:
{
contact:
[
{
contactTypeCode: String,
personName: String,
departmentName: String,
jobTitle: String,
responsibility: String,
communicationChannel:
[
{
communicationChannelCode: String,
communicationChannelName: String,
communicationValue: String
}
]
}
],
address:
{
streetAddressOne: String,
streetAddressTwo: String,
streetAddressThree: String,
city: String,
postalCode: String,
provinceCode: String,
countryCode: String
},
communicationChannel:
[
{
code: String,
value: String
}
],
financialInstitutionInformation:
{
financialInstitutionBranchName: String,
financialInstitutionName: String,
financialRoutingNumber:
{
number: String,
numberTypeCode: String
},
financialAccount:
{
number: String,
numberTypeCode: String,
name: String
},
swiftCode: String,
exportersCode: String
},
dutyFeeTaxRegistration: String,
entityIdentification: String,
gln: String,
name: String,
additionalPartyIdentification:
[
{
code: String,
value: String
}
]
},
shipFrom:
{
contact:
[
{
contactTypeCode: String,
personName: String,
departmentName: String,
jobTitle: String,
responsibility: String,
communicationChannel:
[
{
communicationChannelCode: String,
communicationChannelName: String,
communicationValue: String
}
]
}
],
address:
{
streetAddressOne: String,
streetAddressTwo: String,
streetAddressThree: String,
city: String,
postalCode: String,
provinceCode: String,
countryCode: String
},
communicationChannel:
[
{
code: String,
value: String
}
],
financialInstitutionInformation:
{
financialInstitutionBranchName: String,
financialInstitutionName: String,
financialRoutingNumber:
{
number: String,
numberTypeCode: String
},
financialAccount:
{
number: String,
numberTypeCode: String,
name: String
},
swiftCode: String,
exportersCode: String
},
dutyFeeTaxRegistration: String,
entityIdentification: String,
gln: String,
name: String,
additionalPartyIdentification:
[
{
code: String,
value: String
}
]
},
shipmentIdentification:
{
ginc: String,
additionalConsignmentIdentification:
{
text: String,
additionalConsignmentIdentificationTypeCode: String
}
},
shipper:
{
contact:
[
{
contactTypeCode: String,
personName: String,
departmentName: String,
jobTitle: String,
responsibility: String,
communicationChannel:
[
{
communicationChannelCode: String,
communicationChannelName: String,
communicationValue: String
}
]
}
],
address:
{
streetAddressOne: String,
streetAddressTwo: String,
streetAddressThree: String,
city: String,
postalCode: String,
provinceCode: String,
countryCode: String
},
communicationChannel:
[
{
code: String,
value: String
}
],
financialInstitutionInformation:
{
financialInstitutionBranchName: String,
financialInstitutionName: String,
financialRoutingNumber:
{
number: String,
numberTypeCode: String
},
financialAccount:
{
number: String,
numberTypeCode: String,
name: String
},
swiftCode: String,
exportersCode: String
},
dutyFeeTaxRegistration: String,
entityIdentification: String,
gln: String,
name: String,
additionalPartyIdentification:
[
{
code: String,
value: String
}
]
},
shipTo:
{
contact:
[
{
contactTypeCode: String,
personName: String,
departmentName: String,
jobTitle: String,
responsibility: String,
communicationChannel:
[
{
communicationChannelCode: String,
communicationChannelName: String,
communicationValue: String
}
]
}
],
address:
{
streetAddressOne: String,
streetAddressTwo: String,
streetAddressThree: String,
city: String,
postalCode: String,
provinceCode: String,
countryCode: String
},
communicationChannel:
[
{
code: String,
value: String
}
],
financialInstitutionInformation:
{
financialInstitutionBranchName: String,
financialInstitutionName: String,
financialRoutingNumber:
{
number: String,
numberTypeCode: String
},
financialAccount:
{
number: String,
numberTypeCode: String,
name: String
},
swiftCode: String,
exportersCode: String
},
dutyFeeTaxRegistration: String,
entityIdentification: String,
gln: String,
name: String,
additionalPartyIdentification:
[
{
code: String,
value: String
}
]
},
receivingAdviceLogisticUnit:
[
{
receivingAdviceLineItem:
[
{
extension: String,
lineItemNumber: 0,
note: String,
parentLineItemNumber: 0,
quantityAccepted:
{
value: 0,
measurementUnitCode: String,
codeListVersion: String
},
quantityDespatched:
{
value: 0,
measurementUnitCode: String,
codeListVersion: String
},
quantityReceived:
{
value: 0,
measurementUnitCode: String,
codeListVersion: String
},
receivingConditionInformation:
[
{
receivedGoodsDisposition: String,
receivingConditionCode: String,
receivingConditionQuantity:
{
value: 0,
measurementUnitCode: String,
codeListVersion: String
}
}
],
transactionalTradeItem:
{
gtin: String,
additionalTradeItemIdentification:
[
{
code: String,
value: String
}
],
tradeItemQuantity: 0,
tradeItemDescription: String,
productVariantIdentifier: String,
itemTypeCode: String,
tradeItemDataOwner: String,
butterFatReference: String,
transactionalItemData:
[
{
availableForSaleDate: 0001-01-01,
batchNumber: String,
bestBeforeDate: 0001-01-01,
countryOfOrigin: String,
itemExpirationDate: 0001-01-01,
lotNumber: String,
packagingDate: 0001-01-01,
productionDate: 0001-01-01,
productQualityIndication: String,
sellByDate: 0001-01-01,
serialNumber:
[
String
],
shelfLife: String,
tradeItemQuantity: 0,
itemInContactWithFoodProduct: False,
transactionalItemWeight:
[
{
measurementUnitCode: String,
measurementType: String,
measurementValue: String
}
],
transactionalItemVolume:
[
{
measurementUnitCode: String,
measurementType: String,
measurementValue: String
}
],
serialNumberRange:
[
{
maximumValue: String,
minimumValue: String
}
],
transactionalItemDimensions:
[
{
measurementUnitCode: String,
depth: String,
height: String,
width: String
}
],
transactionalItemLogisticUnitInformation:
{
numberOfLayers: 0,
numberOfUnitsPerLayer: 0,
numberOfUnitsPerPallet: 0,
packagingTerms: String,
packageTypeCode: String,
maximumStackingFactor: 0,
returnablePackageTransportCostPayment: String,
dimensionsOfLogisticUnit:
[
{
measurementUnitCode: String,
depth: String,
height: String,
width: String
}
]
},
transactionalItemDataCarrierAndIdentification:
{
gs1TransactionalItemIdentificationKey: String,
dataCarrier: String
},
tradeItemWaste:
[
{
wasteIdentification: String,
typeOfWaste:
[
{
code: String,
value: String
}
]
}
],
transactionalItemOrganicInformation:
{
isTradeItemOrganic: False,
organicCertification: String
},
avpList:
[
{
code: String,
value: String
}
]
}
],
colour:
[
{
colourCode: String,
colourDescription: String
}
],
size:
{
descriptiveSize: String,
sizeCode: String
},
tradeItemClassification:
{
gpcCategoryCode: String,
additionalTradeItemClassificationCode:
[
{
code: String,
value: String
}
],
gpcCategoryName: String,
gpcAttribute:
[
{
code: String,
value: String
}
]
},
avpList:
[
{
code: String,
value: String
}
]
},
consignmentIdentification:
{
ginc: String,
additionalConsignmentIdentification:
{
text: String,
additionalConsignmentIdentificationTypeCode: String
}
},
avpList:
{
code: String,
value: String
},
contract:
{
creationDateTime: 0001-01-01,
revisionNumber: 0,
lineItemNumber: 0,
entityIdentification: String
},
customerReference:
{
creationDateTime: 0001-01-01,
revisionNumber: 0,
lineItemNumber: 0,
entityIdentification: String
},
deliveryNote:
{
creationDateTime: 0001-01-01,
revisionNumber: 0,
lineItemNumber: 0,
entityIdentification: String
},
despatchAdvice:
{
creationDateTime: 0001-01-01,
revisionNumber: 0,
lineItemNumber: 0,
entityIdentification: String
},
productCertification:
{
creationDateTime: 0001-01-01,
revisionNumber: 0,
lineItemNumber: 0,
entityIdentification: String
},
promotionalDeal:
{
creationDateTime: 0001-01-01,
revisionNumber: 0,
lineItemNumber: 0,
entityIdentification: String
},
purchaseConditions:
{
creationDateTime: 0001-01-01,
revisionNumber: 0,
lineItemNumber: 0,
entityIdentification: String
},
purchaseOrder:
{
creationDateTime: 0001-01-01,
revisionNumber: 0,
lineItemNumber: 0,
entityIdentification: String
},
requestedItemIdentification:
{
additionalTradeItemIdentification:
[
{
code: String,
value: String
}
],
gtin: String
},
specification:
{
creationDateTime: 0001-01-01,
revisionNumber: 0,
lineItemNumber: 0,
entityIdentification: String
}
}
],
childPackageTypeCode: String,
levelIdentification: 0,
packageTypeCode: String,
parentLevelIdentification: 0,
quantityOfChildren: 0,
quantityOfLogisticUnits: 0,
logisticUnitMeasurement:
{
dimension:
{
depth:
{
value: 0,
codeListVersion: String,
measurementUnitCode: String
},
height:
{
value: 0,
codeListVersion: String,
measurementUnitCode: String
},
width:
{
value: 0,
codeListVersion: String,
measurementUnitCode: String
}
},
unitMeasurement:
{
measurementType: String,
measurementValue:
{
value: 0,
codeListVersion: String,
measurementUnitCode: String
}
}
},
returnablePackaging:
[
{
currentHolderRegistration:
{
authority: String,
text: String
},
newHolderRegistration:
{
authority: String,
text: String
},
packagingConditionCode: String,
packagingQuantity: 0,
individualReturnableAssetIdentification:
[
{
additionalReturnableAssetIdentification:
[
{
value: String,
additionalReturnableAssetIdentificationTypeCode: String
}
],
grai: String
}
],
returnableAssetIdentification:
{
additionalReturnableAssetIdentification:
[
{
value: String,
additionalReturnableAssetIdentificationTypeCode: String
}
],
grai: String
}
}
],
carrierTrackAndTraceInformation:
{
carrierTrackAndTraceURL: String,
packageTrackingNumber: String
},
avpList:
{
code: String,
value: String
},
individualAssetIdentification:
[
{
additionalIndividualAssetIdentification:
[
{
value: 0,
additionalIndividualAssetIdentificationTypeCode: String
}
],
giai: String
}
],
logisticUnitIdentification:
{
additionalLogisiticUnitIdentification:
[
{
value: 0,
additionalLogisticUnitIdentificationTypeCode: String
}
],
sscc: String
}
}
],
currencyCode: String,
documentActionCode: ADD,
documentStatusCode: ADDITIONAL_TRANSMISSION,
documentStructureVersion: String,
lastUpdateDateTime: 0001-01-01,
revisionNumber: 0,
avpList:
[
{
code: String,
value: String
}
]
}
}
}
HTTP/1.1 200 OK
Content-Type: text/jsv
Content-Length: length
{
}