/* Options:
Date: 2026-02-14 11:50:45
Version: 10.04
Tip: To override a DTO option, remove "//" prefix before updating
BaseUrl: https://stf-api-uat.data-xchange.co.za

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

import 'package:servicestack/servicestack.dart';

abstract class IGetDocumentById extends ISingleEntityQuery
{
}

abstract class ISingleEntityQuery
{
    String id = "";
}

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

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

enum DocumentAction
{
    ADD,
    CHANGE_BY_REFRESH,
    DELETE,
    REJECTED,
}

enum DocumentStatus
{
    ADDITIONAL_TRANSMISSION,
    COPY,
    ORIGINAL,
}

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 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 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
*/
// @Route("/receivingAdvice/{Id}", "GET")
// @Api(Description="Receiving Advice")
// @ApiResponse(Description="ReceivingAdvice data", IsDefaultResponse=true, StatusCode=200)
// @ApiResponse(Description="No Content", ResponseType=typeof(IReturnVoid), StatusCode=204)
// @ApiResponse(Description="Specified argument was out of the range of valid values.", ResponseType=typeof(ArgumentOutOfRangeException), StatusCode=400)
class GetReceivingAdviceById implements IReturn<ReceivingAdviceMessage>, IGetDocumentById, IConvertible, IGet
{
    /**
    * ReceivingAdvice ID or Token
    */
    // @ApiMember(Description="ReceivingAdvice ID or Token", ExcludeInSchema=true, ParameterType="path")
    String id = "";

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

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

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

    createResponse() => ReceivingAdviceMessage();
    getResponseTypeName() => "ReceivingAdviceMessage";
    getTypeName() => "GetReceivingAdviceById";
    TypeContext? context = _ctx;
}

TypeContext _ctx = TypeContext(library: 'stf_api_uat.data_xchange.co.za', types: <String, TypeInfo> {
    'IGetDocumentById': TypeInfo(TypeOf.Interface),
    'ISingleEntityQuery': TypeInfo(TypeOf.Interface),
    '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()),
    'AvpList': TypeInfo(TypeOf.Class, create:() => AvpList()),
    'Ecom_PartyIdentificationType': TypeInfo(TypeOf.Class, create:() => Ecom_PartyIdentificationType()),
    '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>[]),
    '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>[]),
    'DocumentAction': TypeInfo(TypeOf.Enum, enumValues:DocumentAction.values),
    'DocumentStatus': TypeInfo(TypeOf.Enum, enumValues:DocumentStatus.values),
    'BaseDocument': TypeInfo(TypeOf.Class, create:() => BaseDocument()),
    '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()),
    '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()),
    'GetReceivingAdviceById': TypeInfo(TypeOf.Class, create:() => GetReceivingAdviceById()),
});