/* Options:
Date: 2026-02-14 10:15:30
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: GetItemDataNotification.*
//ExcludeTypes: 
//DefaultImports: package:servicestack/servicestack.dart
*/

import 'package:servicestack/servicestack.dart';

abstract class IDocument extends IHaveToken
{
}

abstract class IHaveToken
{
    String token = "";
}

class ResultItem<T> implements IDocument, IConvertible
{
    String token = "";
    T item;

    ResultItem({this.token,this.item});
    ResultItem.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

    Map<String, dynamic> toJson() => {
        'token': token,
        'item': JsonConverters.toJson(item,'T',context!)
    };

    getTypeName() => "ResultItem<$T>";
    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;
}

class AdditionalTradeItemIdentification implements IConvertible
{
    String value = "";
    String code = "";

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

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

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

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

class Ecom_TradeItemIdentification implements IConvertible
{
    List<AdditionalTradeItemIdentification> additionalTradeItemIdentification = [];
    String gtin = "";

    Ecom_TradeItemIdentification({this.additionalTradeItemIdentification,this.gtin});
    Ecom_TradeItemIdentification.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        additionalTradeItemIdentification = JsonConverters.fromJson(json['additionalTradeItemIdentification'],'List<AdditionalTradeItemIdentification>',context!);
        gtin = json['gtin'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'additionalTradeItemIdentification': JsonConverters.toJson(additionalTradeItemIdentification,'List<AdditionalTradeItemIdentification>',context!),
        'gtin': gtin
    };

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

class IdentifierType implements IConvertible
{
    String value = "";
    String identificationSchemeAgencyCodeCodeListVersion = "";
    String identificationSchemeAgencyName = "";
    String identificationSchemeName = "";

    IdentifierType({this.value,this.identificationSchemeAgencyCodeCodeListVersion,this.identificationSchemeAgencyName,this.identificationSchemeName});
    IdentifierType.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        value = json['value'];
        identificationSchemeAgencyCodeCodeListVersion = json['identificationSchemeAgencyCodeCodeListVersion'];
        identificationSchemeAgencyName = json['identificationSchemeAgencyName'];
        identificationSchemeName = json['identificationSchemeName'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'value': value,
        'identificationSchemeAgencyCodeCodeListVersion': identificationSchemeAgencyCodeCodeListVersion,
        'identificationSchemeAgencyName': identificationSchemeAgencyName,
        'identificationSchemeName': identificationSchemeName
    };

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

class AdditionalTradeItemClassificationCode implements IConvertible
{
    String value = "";
    String additionalTradeItemClassificationCodeListCode = "";
    String additionalTradeItemClassificationCodeListVersion = "";
    String codeDescription = "";

    AdditionalTradeItemClassificationCode({this.value,this.additionalTradeItemClassificationCodeListCode,this.additionalTradeItemClassificationCodeListVersion,this.codeDescription});
    AdditionalTradeItemClassificationCode.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        value = json['value'];
        additionalTradeItemClassificationCodeListCode = json['additionalTradeItemClassificationCodeListCode'];
        additionalTradeItemClassificationCodeListVersion = json['additionalTradeItemClassificationCodeListVersion'];
        codeDescription = json['codeDescription'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'value': value,
        'additionalTradeItemClassificationCodeListCode': additionalTradeItemClassificationCodeListCode,
        'additionalTradeItemClassificationCodeListVersion': additionalTradeItemClassificationCodeListVersion,
        'codeDescription': codeDescription
    };

    getTypeName() => "AdditionalTradeItemClassificationCode";
    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 ItemDataWeightAndDimension implements IConvertible
{
    Measurement depth;
    Measurement diameter;
    Measurement grossWeight;
    Measurement height;
    Measurement netWeight;
    Measurement width;

    ItemDataWeightAndDimension({this.depth,this.diameter,this.grossWeight,this.height,this.netWeight,this.width});
    ItemDataWeightAndDimension.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        depth = JsonConverters.fromJson(json['depth'],'Measurement',context!);
        diameter = JsonConverters.fromJson(json['diameter'],'Measurement',context!);
        grossWeight = JsonConverters.fromJson(json['grossWeight'],'Measurement',context!);
        height = JsonConverters.fromJson(json['height'],'Measurement',context!);
        netWeight = JsonConverters.fromJson(json['netWeight'],'Measurement',context!);
        width = JsonConverters.fromJson(json['width'],'Measurement',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'depth': JsonConverters.toJson(depth,'Measurement',context!),
        'diameter': JsonConverters.toJson(diameter,'Measurement',context!),
        'grossWeight': JsonConverters.toJson(grossWeight,'Measurement',context!),
        'height': JsonConverters.toJson(height,'Measurement',context!),
        'netWeight': JsonConverters.toJson(netWeight,'Measurement',context!),
        'width': JsonConverters.toJson(width,'Measurement',context!)
    };

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

class TemperatureMeasurement implements IConvertible
{
    double? value;
    String temperatureMeasurementUnitCode = "";

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

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

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

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

class TemperatureRange implements IConvertible
{
    TemperatureMeasurement maximumTemperature;
    TemperatureMeasurement minimumTemperature;

    TemperatureRange({this.maximumTemperature,this.minimumTemperature});
    TemperatureRange.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

    Map<String, dynamic> toJson() => {
        'maximumTemperature': JsonConverters.toJson(maximumTemperature,'TemperatureMeasurement',context!),
        'minimumTemperature': JsonConverters.toJson(minimumTemperature,'TemperatureMeasurement',context!)
    };

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

class HandlingInstruction implements IConvertible
{
    String handlingInstructionCode = "";
    String handlingInstructionText = "";
    List<String> printingInstructionCode = [];
    TemperatureRange storageTemperature;
    TemperatureRange transportTemperature;

    HandlingInstruction({this.handlingInstructionCode,this.handlingInstructionText,this.printingInstructionCode,this.storageTemperature,this.transportTemperature});
    HandlingInstruction.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        handlingInstructionCode = json['handlingInstructionCode'];
        handlingInstructionText = json['handlingInstructionText'];
        printingInstructionCode = JsonConverters.fromJson(json['printingInstructionCode'],'List<String>',context!);
        storageTemperature = JsonConverters.fromJson(json['storageTemperature'],'TemperatureRange',context!);
        transportTemperature = JsonConverters.fromJson(json['transportTemperature'],'TemperatureRange',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'handlingInstructionCode': handlingInstructionCode,
        'handlingInstructionText': handlingInstructionText,
        'printingInstructionCode': JsonConverters.toJson(printingInstructionCode,'List<String>',context!),
        'storageTemperature': JsonConverters.toJson(storageTemperature,'TemperatureRange',context!),
        'transportTemperature': JsonConverters.toJson(transportTemperature,'TemperatureRange',context!)
    };

    getTypeName() => "HandlingInstruction";
    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;
}

class DangerousGoodsInformation implements IConvertible
{
    String dangerousGoodsDescription = "";
    String dangerousGoodsShippingName = "";
    String dangerousGoodsTechnicalName = "";
    Identifier dangerousGoodsUNIdentifier;
    List<Contact> contact = [];

    DangerousGoodsInformation({this.dangerousGoodsDescription,this.dangerousGoodsShippingName,this.dangerousGoodsTechnicalName,this.dangerousGoodsUNIdentifier,this.contact});
    DangerousGoodsInformation.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        dangerousGoodsDescription = json['dangerousGoodsDescription'];
        dangerousGoodsShippingName = json['dangerousGoodsShippingName'];
        dangerousGoodsTechnicalName = json['dangerousGoodsTechnicalName'];
        dangerousGoodsUNIdentifier = JsonConverters.fromJson(json['dangerousGoodsUNIdentifier'],'Identifier',context!);
        contact = JsonConverters.fromJson(json['contact'],'List<Contact>',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'dangerousGoodsDescription': dangerousGoodsDescription,
        'dangerousGoodsShippingName': dangerousGoodsShippingName,
        'dangerousGoodsTechnicalName': dangerousGoodsTechnicalName,
        'dangerousGoodsUNIdentifier': JsonConverters.toJson(dangerousGoodsUNIdentifier,'Identifier',context!),
        'contact': JsonConverters.toJson(contact,'List<Contact>',context!)
    };

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

class AdministrativeUnit implements IConvertible
{
    String typeCode = "";
    String gln = "";
    String internalIdentification = "";

    AdministrativeUnit({this.typeCode,this.gln,this.internalIdentification});
    AdministrativeUnit.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

    Map<String, dynamic> toJson() => {
        'typeCode': typeCode,
        'gln': gln,
        'internalIdentification': internalIdentification
    };

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

class ItemDataTradingPartnerNeutral implements IConvertible
{
    DateTime? cancelledDateTime;
    DateTime? discontinuedDateTime;
    DateTime effectiveDateTime = DateTime(0);
    DateTime? endAvailabilityDateTime;
    int? maximumStackingFactor;
    DateTime startAvailabilityDateTime = DateTime(0);
    String tradeItemBaseUnitOfMeasure = "";
    List<AdditionalTradeItemClassificationCode> tradeItemClassificationCode = [];
    String warehouseABCClassificationCode = "";
    ItemDataWeightAndDimension itemDataWeightAndDimension;
    List<HandlingInstruction> handlingInstruction = [];
    List<DangerousGoodsInformation> dangerousGoodsInformation = [];
    AdministrativeUnit administrativeUnitOfLogisticServiceBuyer;
    List<AvpList> avpList = [];

    ItemDataTradingPartnerNeutral({this.cancelledDateTime,this.discontinuedDateTime,this.effectiveDateTime,this.endAvailabilityDateTime,this.maximumStackingFactor,this.startAvailabilityDateTime,this.tradeItemBaseUnitOfMeasure,this.tradeItemClassificationCode,this.warehouseABCClassificationCode,this.itemDataWeightAndDimension,this.handlingInstruction,this.dangerousGoodsInformation,this.administrativeUnitOfLogisticServiceBuyer,this.avpList});
    ItemDataTradingPartnerNeutral.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        cancelledDateTime = JsonConverters.fromJson(json['cancelledDateTime'],'DateTime',context!);
        discontinuedDateTime = JsonConverters.fromJson(json['discontinuedDateTime'],'DateTime',context!);
        effectiveDateTime = JsonConverters.fromJson(json['effectiveDateTime'],'DateTime',context!);
        endAvailabilityDateTime = JsonConverters.fromJson(json['endAvailabilityDateTime'],'DateTime',context!);
        maximumStackingFactor = json['maximumStackingFactor'];
        startAvailabilityDateTime = JsonConverters.fromJson(json['startAvailabilityDateTime'],'DateTime',context!);
        tradeItemBaseUnitOfMeasure = json['tradeItemBaseUnitOfMeasure'];
        tradeItemClassificationCode = JsonConverters.fromJson(json['tradeItemClassificationCode'],'List<AdditionalTradeItemClassificationCode>',context!);
        warehouseABCClassificationCode = json['warehouseABCClassificationCode'];
        itemDataWeightAndDimension = JsonConverters.fromJson(json['itemDataWeightAndDimension'],'ItemDataWeightAndDimension',context!);
        handlingInstruction = JsonConverters.fromJson(json['handlingInstruction'],'List<HandlingInstruction>',context!);
        dangerousGoodsInformation = JsonConverters.fromJson(json['dangerousGoodsInformation'],'List<DangerousGoodsInformation>',context!);
        administrativeUnitOfLogisticServiceBuyer = JsonConverters.fromJson(json['administrativeUnitOfLogisticServiceBuyer'],'AdministrativeUnit',context!);
        avpList = JsonConverters.fromJson(json['avpList'],'List<AvpList>',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'cancelledDateTime': JsonConverters.toJson(cancelledDateTime,'DateTime',context!),
        'discontinuedDateTime': JsonConverters.toJson(discontinuedDateTime,'DateTime',context!),
        'effectiveDateTime': JsonConverters.toJson(effectiveDateTime,'DateTime',context!),
        'endAvailabilityDateTime': JsonConverters.toJson(endAvailabilityDateTime,'DateTime',context!),
        'maximumStackingFactor': maximumStackingFactor,
        'startAvailabilityDateTime': JsonConverters.toJson(startAvailabilityDateTime,'DateTime',context!),
        'tradeItemBaseUnitOfMeasure': tradeItemBaseUnitOfMeasure,
        'tradeItemClassificationCode': JsonConverters.toJson(tradeItemClassificationCode,'List<AdditionalTradeItemClassificationCode>',context!),
        'warehouseABCClassificationCode': warehouseABCClassificationCode,
        'itemDataWeightAndDimension': JsonConverters.toJson(itemDataWeightAndDimension,'ItemDataWeightAndDimension',context!),
        'handlingInstruction': JsonConverters.toJson(handlingInstruction,'List<HandlingInstruction>',context!),
        'dangerousGoodsInformation': JsonConverters.toJson(dangerousGoodsInformation,'List<DangerousGoodsInformation>',context!),
        'administrativeUnitOfLogisticServiceBuyer': JsonConverters.toJson(administrativeUnitOfLogisticServiceBuyer,'AdministrativeUnit',context!),
        'avpList': JsonConverters.toJson(avpList,'List<AvpList>',context!)
    };

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

class TimeMeasurement implements IConvertible
{
    String timeMeasurementUnitCode = "";
    double? value;

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

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

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

    getTypeName() => "TimeMeasurement";
    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 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 ItemDataLogisticUnitInformation implements IConvertible
{
    Measurement grossWeight;
    int? maximumStackingFactor;
    Measurement netWeight;
    int? numberOfLayers;
    String packageLevelCode = "";
    String packageTypeCode = "";
    Quantity tradeItemQuantity;
    Quantity tradeItemQuantityPerLayer;
    AvpList avpList;
    List<Dimension> dimensionsOfLogisticUnit = [];

    ItemDataLogisticUnitInformation({this.grossWeight,this.maximumStackingFactor,this.netWeight,this.numberOfLayers,this.packageLevelCode,this.packageTypeCode,this.tradeItemQuantity,this.tradeItemQuantityPerLayer,this.avpList,this.dimensionsOfLogisticUnit});
    ItemDataLogisticUnitInformation.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        grossWeight = JsonConverters.fromJson(json['grossWeight'],'Measurement',context!);
        maximumStackingFactor = json['maximumStackingFactor'];
        netWeight = JsonConverters.fromJson(json['netWeight'],'Measurement',context!);
        numberOfLayers = json['numberOfLayers'];
        packageLevelCode = json['packageLevelCode'];
        packageTypeCode = json['packageTypeCode'];
        tradeItemQuantity = JsonConverters.fromJson(json['tradeItemQuantity'],'Quantity',context!);
        tradeItemQuantityPerLayer = JsonConverters.fromJson(json['tradeItemQuantityPerLayer'],'Quantity',context!);
        avpList = JsonConverters.fromJson(json['avpList'],'AvpList',context!);
        dimensionsOfLogisticUnit = JsonConverters.fromJson(json['dimensionsOfLogisticUnit'],'List<Dimension>',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'grossWeight': JsonConverters.toJson(grossWeight,'Measurement',context!),
        'maximumStackingFactor': maximumStackingFactor,
        'netWeight': JsonConverters.toJson(netWeight,'Measurement',context!),
        'numberOfLayers': numberOfLayers,
        'packageLevelCode': packageLevelCode,
        'packageTypeCode': packageTypeCode,
        'tradeItemQuantity': JsonConverters.toJson(tradeItemQuantity,'Quantity',context!),
        'tradeItemQuantityPerLayer': JsonConverters.toJson(tradeItemQuantityPerLayer,'Quantity',context!),
        'avpList': JsonConverters.toJson(avpList,'AvpList',context!),
        'dimensionsOfLogisticUnit': JsonConverters.toJson(dimensionsOfLogisticUnit,'List<Dimension>',context!)
    };

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

class ItemDataStockRequirements implements IConvertible
{
    Quantity requiredStockLevel;
    DateTime? requiredStockLevelValidityDateTime;
    String stockRequirementTypeCode = "";

    ItemDataStockRequirements({this.requiredStockLevel,this.requiredStockLevelValidityDateTime,this.stockRequirementTypeCode});
    ItemDataStockRequirements.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        requiredStockLevel = JsonConverters.fromJson(json['requiredStockLevel'],'Quantity',context!);
        requiredStockLevelValidityDateTime = JsonConverters.fromJson(json['requiredStockLevelValidityDateTime'],'DateTime',context!);
        stockRequirementTypeCode = json['stockRequirementTypeCode'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'requiredStockLevel': JsonConverters.toJson(requiredStockLevel,'Quantity',context!),
        'requiredStockLevelValidityDateTime': JsonConverters.toJson(requiredStockLevelValidityDateTime,'DateTime',context!),
        'stockRequirementTypeCode': stockRequirementTypeCode
    };

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

class TransactionalPartyInRole implements IConvertible
{
    String partyRoleCode = "";
    TransactionalParty transactionalParty;

    TransactionalPartyInRole({this.partyRoleCode,this.transactionalParty});
    TransactionalPartyInRole.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

    Map<String, dynamic> toJson() => {
        'partyRoleCode': partyRoleCode,
        'transactionalParty': JsonConverters.toJson(transactionalParty,'TransactionalParty',context!)
    };

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

class ItemDataTradingPartnerDependent implements IConvertible
{
    String countryOfOrigin = "";
    TimeMeasurement minimumRemainingShelfLifeInbound;
    TimeMeasurement minimumRemainingShelfLifeOutbound;
    Quantity orderQuantityMaximum;
    Quantity orderQuantityMinimum;
    Quantity orderQuantityMultiple;
    String qualityControlCode = "";
    TimeMeasurement quarantinePeriod;
    TimeMeasurement tradeItemProductionLeadTime;
    TimeMeasurement tradeItemShipmentLeadTime;
    String tradeItemSpecificUnitOfMeasure = "";
    DateTime? tradeItemSubstitutionDateTime;
    List<ItemDataLogisticUnitInformation> itemDataLogisticUnitInformation = [];
    List<ItemDataStockRequirements> itemDataStockRequirements = [];
    List<AdministrativeUnit> administrativeUnitOfReceiver = [];
    AvpList avpList;
    List<TransactionalPartyInRole> originatingParty = [];
    TransactionalParty receiver;
    TransactionalParty shipper;
    Ecom_TradeItemIdentification substituteItem;

    ItemDataTradingPartnerDependent({this.countryOfOrigin,this.minimumRemainingShelfLifeInbound,this.minimumRemainingShelfLifeOutbound,this.orderQuantityMaximum,this.orderQuantityMinimum,this.orderQuantityMultiple,this.qualityControlCode,this.quarantinePeriod,this.tradeItemProductionLeadTime,this.tradeItemShipmentLeadTime,this.tradeItemSpecificUnitOfMeasure,this.tradeItemSubstitutionDateTime,this.itemDataLogisticUnitInformation,this.itemDataStockRequirements,this.administrativeUnitOfReceiver,this.avpList,this.originatingParty,this.receiver,this.shipper,this.substituteItem});
    ItemDataTradingPartnerDependent.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        countryOfOrigin = json['countryOfOrigin'];
        minimumRemainingShelfLifeInbound = JsonConverters.fromJson(json['minimumRemainingShelfLifeInbound'],'TimeMeasurement',context!);
        minimumRemainingShelfLifeOutbound = JsonConverters.fromJson(json['minimumRemainingShelfLifeOutbound'],'TimeMeasurement',context!);
        orderQuantityMaximum = JsonConverters.fromJson(json['orderQuantityMaximum'],'Quantity',context!);
        orderQuantityMinimum = JsonConverters.fromJson(json['orderQuantityMinimum'],'Quantity',context!);
        orderQuantityMultiple = JsonConverters.fromJson(json['orderQuantityMultiple'],'Quantity',context!);
        qualityControlCode = json['qualityControlCode'];
        quarantinePeriod = JsonConverters.fromJson(json['quarantinePeriod'],'TimeMeasurement',context!);
        tradeItemProductionLeadTime = JsonConverters.fromJson(json['tradeItemProductionLeadTime'],'TimeMeasurement',context!);
        tradeItemShipmentLeadTime = JsonConverters.fromJson(json['tradeItemShipmentLeadTime'],'TimeMeasurement',context!);
        tradeItemSpecificUnitOfMeasure = json['tradeItemSpecificUnitOfMeasure'];
        tradeItemSubstitutionDateTime = JsonConverters.fromJson(json['tradeItemSubstitutionDateTime'],'DateTime',context!);
        itemDataLogisticUnitInformation = JsonConverters.fromJson(json['itemDataLogisticUnitInformation'],'List<ItemDataLogisticUnitInformation>',context!);
        itemDataStockRequirements = JsonConverters.fromJson(json['itemDataStockRequirements'],'List<ItemDataStockRequirements>',context!);
        administrativeUnitOfReceiver = JsonConverters.fromJson(json['administrativeUnitOfReceiver'],'List<AdministrativeUnit>',context!);
        avpList = JsonConverters.fromJson(json['avpList'],'AvpList',context!);
        originatingParty = JsonConverters.fromJson(json['originatingParty'],'List<TransactionalPartyInRole>',context!);
        receiver = JsonConverters.fromJson(json['receiver'],'TransactionalParty',context!);
        shipper = JsonConverters.fromJson(json['shipper'],'TransactionalParty',context!);
        substituteItem = JsonConverters.fromJson(json['substituteItem'],'Ecom_TradeItemIdentification',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'countryOfOrigin': countryOfOrigin,
        'minimumRemainingShelfLifeInbound': JsonConverters.toJson(minimumRemainingShelfLifeInbound,'TimeMeasurement',context!),
        'minimumRemainingShelfLifeOutbound': JsonConverters.toJson(minimumRemainingShelfLifeOutbound,'TimeMeasurement',context!),
        'orderQuantityMaximum': JsonConverters.toJson(orderQuantityMaximum,'Quantity',context!),
        'orderQuantityMinimum': JsonConverters.toJson(orderQuantityMinimum,'Quantity',context!),
        'orderQuantityMultiple': JsonConverters.toJson(orderQuantityMultiple,'Quantity',context!),
        'qualityControlCode': qualityControlCode,
        'quarantinePeriod': JsonConverters.toJson(quarantinePeriod,'TimeMeasurement',context!),
        'tradeItemProductionLeadTime': JsonConverters.toJson(tradeItemProductionLeadTime,'TimeMeasurement',context!),
        'tradeItemShipmentLeadTime': JsonConverters.toJson(tradeItemShipmentLeadTime,'TimeMeasurement',context!),
        'tradeItemSpecificUnitOfMeasure': tradeItemSpecificUnitOfMeasure,
        'tradeItemSubstitutionDateTime': JsonConverters.toJson(tradeItemSubstitutionDateTime,'DateTime',context!),
        'itemDataLogisticUnitInformation': JsonConverters.toJson(itemDataLogisticUnitInformation,'List<ItemDataLogisticUnitInformation>',context!),
        'itemDataStockRequirements': JsonConverters.toJson(itemDataStockRequirements,'List<ItemDataStockRequirements>',context!),
        'administrativeUnitOfReceiver': JsonConverters.toJson(administrativeUnitOfReceiver,'List<AdministrativeUnit>',context!),
        'avpList': JsonConverters.toJson(avpList,'AvpList',context!),
        'originatingParty': JsonConverters.toJson(originatingParty,'List<TransactionalPartyInRole>',context!),
        'receiver': JsonConverters.toJson(receiver,'TransactionalParty',context!),
        'shipper': JsonConverters.toJson(shipper,'TransactionalParty',context!),
        'substituteItem': JsonConverters.toJson(substituteItem,'Ecom_TradeItemIdentification',context!)
    };

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

class LowerLevelTradeItem extends Ecom_TradeItemIdentification implements IConvertible
{
    double? quantityOfLowerLevelTradeItem;

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

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

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

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

class ItemDataNotificationLineItem extends Ecom_TradeItemIdentification implements IConvertible
{
    String brandName = "";
    String gpcCategoryCode = "";
    bool? isTheProductVariantPreferred;
    int? lineItemNumber;
    int? parentLineItemNumber;
    IdentifierType productVariantIdentifier;
    double? quantityOfItemTypes;
    double? quantityOfItemUnits;
    List<String> tradeItemDescription = [];
    String tradeItemUnitDescriptorCode = "";
    ItemDataTradingPartnerNeutral itemDataTradingPartnerNeutral;
    List<ItemDataTradingPartnerDependent> itemDataTradingPartnerDependent = [];
    List<LowerLevelTradeItem> lowerLevelTradeItem = [];
    List<AvpList> avpList = [];

    ItemDataNotificationLineItem({this.brandName,this.gpcCategoryCode,this.isTheProductVariantPreferred,this.lineItemNumber,this.parentLineItemNumber,this.productVariantIdentifier,this.quantityOfItemTypes,this.quantityOfItemUnits,this.tradeItemDescription,this.tradeItemUnitDescriptorCode,this.itemDataTradingPartnerNeutral,this.itemDataTradingPartnerDependent,this.lowerLevelTradeItem,this.avpList});
    ItemDataNotificationLineItem.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        super.fromMap(json);
        brandName = json['brandName'];
        gpcCategoryCode = json['gpcCategoryCode'];
        isTheProductVariantPreferred = json['isTheProductVariantPreferred'];
        lineItemNumber = json['lineItemNumber'];
        parentLineItemNumber = json['parentLineItemNumber'];
        productVariantIdentifier = JsonConverters.fromJson(json['productVariantIdentifier'],'IdentifierType',context!);
        quantityOfItemTypes = JsonConverters.toDouble(json['quantityOfItemTypes']);
        quantityOfItemUnits = JsonConverters.toDouble(json['quantityOfItemUnits']);
        tradeItemDescription = JsonConverters.fromJson(json['tradeItemDescription'],'List<String>',context!);
        tradeItemUnitDescriptorCode = json['tradeItemUnitDescriptorCode'];
        itemDataTradingPartnerNeutral = JsonConverters.fromJson(json['itemDataTradingPartnerNeutral'],'ItemDataTradingPartnerNeutral',context!);
        itemDataTradingPartnerDependent = JsonConverters.fromJson(json['itemDataTradingPartnerDependent'],'List<ItemDataTradingPartnerDependent>',context!);
        lowerLevelTradeItem = JsonConverters.fromJson(json['lowerLevelTradeItem'],'List<LowerLevelTradeItem>',context!);
        avpList = JsonConverters.fromJson(json['avpList'],'List<AvpList>',context!);
        return this;
    }

    Map<String, dynamic> toJson() => super.toJson()..addAll({
        'brandName': brandName,
        'gpcCategoryCode': gpcCategoryCode,
        'isTheProductVariantPreferred': isTheProductVariantPreferred,
        'lineItemNumber': lineItemNumber,
        'parentLineItemNumber': parentLineItemNumber,
        'productVariantIdentifier': JsonConverters.toJson(productVariantIdentifier,'IdentifierType',context!),
        'quantityOfItemTypes': quantityOfItemTypes,
        'quantityOfItemUnits': quantityOfItemUnits,
        'tradeItemDescription': JsonConverters.toJson(tradeItemDescription,'List<String>',context!),
        'tradeItemUnitDescriptorCode': tradeItemUnitDescriptorCode,
        'itemDataTradingPartnerNeutral': JsonConverters.toJson(itemDataTradingPartnerNeutral,'ItemDataTradingPartnerNeutral',context!),
        'itemDataTradingPartnerDependent': JsonConverters.toJson(itemDataTradingPartnerDependent,'List<ItemDataTradingPartnerDependent>',context!),
        'lowerLevelTradeItem': JsonConverters.toJson(lowerLevelTradeItem,'List<LowerLevelTradeItem>',context!),
        'avpList': JsonConverters.toJson(avpList,'List<AvpList>',context!)
    });

    getTypeName() => "ItemDataNotificationLineItem";
    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 ItemDataNotificationMessage extends BaseDocument implements IConvertible
{
    TransactionalParty dataRecipient;
    TransactionalParty dataSource;
    String itemDataNotificationIdentification = "";
    List<ItemDataNotificationLineItem> itemDataNotificationLineItem = [];

    ItemDataNotificationMessage({this.dataRecipient,this.dataSource,this.itemDataNotificationIdentification,this.itemDataNotificationLineItem});
    ItemDataNotificationMessage.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        super.fromMap(json);
        dataRecipient = JsonConverters.fromJson(json['dataRecipient'],'TransactionalParty',context!);
        dataSource = JsonConverters.fromJson(json['dataSource'],'TransactionalParty',context!);
        itemDataNotificationIdentification = json['itemDataNotificationIdentification'];
        itemDataNotificationLineItem = JsonConverters.fromJson(json['itemDataNotificationLineItem'],'List<ItemDataNotificationLineItem>',context!);
        return this;
    }

    Map<String, dynamic> toJson() => super.toJson()..addAll({
        'dataRecipient': JsonConverters.toJson(dataRecipient,'TransactionalParty',context!),
        'dataSource': JsonConverters.toJson(dataSource,'TransactionalParty',context!),
        'itemDataNotificationIdentification': itemDataNotificationIdentification,
        'itemDataNotificationLineItem': JsonConverters.toJson(itemDataNotificationLineItem,'List<ItemDataNotificationLineItem>',context!)
    });

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

/**
* Item Data Notification
*/
// @Route("/itemDataNotification", "GET")
// @Api(Description="Item Data Notification")
// @ApiResponse(Description="ItemDataNotification message", IsDefaultResponse=true, StatusCode=200)
// @ApiResponse(Description="No Content", ResponseType=typeof(IReturnVoid), StatusCode=204)
class GetItemDataNotification implements IReturn<ResultItem<ItemDataNotificationMessage>>, IConvertible, IGet
{
    GetItemDataNotification();
    GetItemDataNotification.fromJson(Map<String, dynamic> json) : super();
    fromMap(Map<String, dynamic> json) {
        return this;
    }

    Map<String, dynamic> toJson() => {};
    createResponse() => ResultItem<ItemDataNotificationMessage>();
    getResponseTypeName() => "ResultItem<ItemDataNotificationMessage>";
    getTypeName() => "GetItemDataNotification";
    TypeContext? context = _ctx;
}

TypeContext _ctx = TypeContext(library: 'stf_api_uat.data_xchange.co.za', types: <String, TypeInfo> {
    'IDocument': TypeInfo(TypeOf.Interface),
    'IHaveToken': TypeInfo(TypeOf.Interface),
    'ResultItem<T>': TypeInfo(TypeOf.GenericDef,create:() => ResultItem()),
    '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>[]),
    'AdditionalTradeItemIdentification': TypeInfo(TypeOf.Class, create:() => AdditionalTradeItemIdentification()),
    'Ecom_TradeItemIdentification': TypeInfo(TypeOf.Class, create:() => Ecom_TradeItemIdentification()),
    'List<AdditionalTradeItemIdentification>': TypeInfo(TypeOf.Class, create:() => <AdditionalTradeItemIdentification>[]),
    'IdentifierType': TypeInfo(TypeOf.Class, create:() => IdentifierType()),
    'AdditionalTradeItemClassificationCode': TypeInfo(TypeOf.Class, create:() => AdditionalTradeItemClassificationCode()),
    'Measurement': TypeInfo(TypeOf.Class, create:() => Measurement()),
    'ItemDataWeightAndDimension': TypeInfo(TypeOf.Class, create:() => ItemDataWeightAndDimension()),
    'TemperatureMeasurement': TypeInfo(TypeOf.Class, create:() => TemperatureMeasurement()),
    'TemperatureRange': TypeInfo(TypeOf.Class, create:() => TemperatureRange()),
    'HandlingInstruction': TypeInfo(TypeOf.Class, create:() => HandlingInstruction()),
    'Identifier': TypeInfo(TypeOf.Class, create:() => Identifier()),
    'DangerousGoodsInformation': TypeInfo(TypeOf.Class, create:() => DangerousGoodsInformation()),
    'AdministrativeUnit': TypeInfo(TypeOf.Class, create:() => AdministrativeUnit()),
    'ItemDataTradingPartnerNeutral': TypeInfo(TypeOf.Class, create:() => ItemDataTradingPartnerNeutral()),
    'List<AdditionalTradeItemClassificationCode>': TypeInfo(TypeOf.Class, create:() => <AdditionalTradeItemClassificationCode>[]),
    'List<HandlingInstruction>': TypeInfo(TypeOf.Class, create:() => <HandlingInstruction>[]),
    'List<DangerousGoodsInformation>': TypeInfo(TypeOf.Class, create:() => <DangerousGoodsInformation>[]),
    'TimeMeasurement': TypeInfo(TypeOf.Class, create:() => TimeMeasurement()),
    'Quantity': TypeInfo(TypeOf.Class, create:() => Quantity()),
    'Dimension': TypeInfo(TypeOf.Class, create:() => Dimension()),
    'ItemDataLogisticUnitInformation': TypeInfo(TypeOf.Class, create:() => ItemDataLogisticUnitInformation()),
    'List<Dimension>': TypeInfo(TypeOf.Class, create:() => <Dimension>[]),
    'ItemDataStockRequirements': TypeInfo(TypeOf.Class, create:() => ItemDataStockRequirements()),
    'TransactionalPartyInRole': TypeInfo(TypeOf.Class, create:() => TransactionalPartyInRole()),
    'ItemDataTradingPartnerDependent': TypeInfo(TypeOf.Class, create:() => ItemDataTradingPartnerDependent()),
    'List<ItemDataLogisticUnitInformation>': TypeInfo(TypeOf.Class, create:() => <ItemDataLogisticUnitInformation>[]),
    'List<ItemDataStockRequirements>': TypeInfo(TypeOf.Class, create:() => <ItemDataStockRequirements>[]),
    'List<AdministrativeUnit>': TypeInfo(TypeOf.Class, create:() => <AdministrativeUnit>[]),
    'List<TransactionalPartyInRole>': TypeInfo(TypeOf.Class, create:() => <TransactionalPartyInRole>[]),
    'LowerLevelTradeItem': TypeInfo(TypeOf.Class, create:() => LowerLevelTradeItem()),
    'ItemDataNotificationLineItem': TypeInfo(TypeOf.Class, create:() => ItemDataNotificationLineItem()),
    'List<ItemDataTradingPartnerDependent>': TypeInfo(TypeOf.Class, create:() => <ItemDataTradingPartnerDependent>[]),
    'List<LowerLevelTradeItem>': TypeInfo(TypeOf.Class, create:() => <LowerLevelTradeItem>[]),
    'DocumentAction': TypeInfo(TypeOf.Enum, enumValues:DocumentAction.values),
    'DocumentStatus': TypeInfo(TypeOf.Enum, enumValues:DocumentStatus.values),
    'BaseDocument': TypeInfo(TypeOf.Class, create:() => BaseDocument()),
    'ItemDataNotificationMessage': TypeInfo(TypeOf.Class, create:() => ItemDataNotificationMessage()),
    'List<ItemDataNotificationLineItem>': TypeInfo(TypeOf.Class, create:() => <ItemDataNotificationLineItem>[]),
    'ResultItem<ItemDataNotificationMessage>': TypeInfo(TypeOf.Class, create:() => ResultItem<ItemDataNotificationMessage>()),
    'GetItemDataNotification': TypeInfo(TypeOf.Class, create:() => GetItemDataNotification()),
});