/* Options:
Date: 2026-02-14 10:15:51
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: GetPurchaseCondition.*
//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;
}

// @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 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 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 PurchaseConditionsCommitmentPeriod implements IConvertible
{
    TimeMeasurement commitmentPeriodDuration;
    String purchaseConditionsCommitmentTypeCode = "";

    PurchaseConditionsCommitmentPeriod({this.commitmentPeriodDuration,this.purchaseConditionsCommitmentTypeCode});
    PurchaseConditionsCommitmentPeriod.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

    Map<String, dynamic> toJson() => {
        'commitmentPeriodDuration': JsonConverters.toJson(commitmentPeriodDuration,'TimeMeasurement',context!),
        'purchaseConditionsCommitmentTypeCode': purchaseConditionsCommitmentTypeCode
    };

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

class QuantityRange implements IConvertible
{
    Quantity maximumQuantity;
    Quantity minimumQuantity;

    QuantityRange({this.maximumQuantity,this.minimumQuantity});
    QuantityRange.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

    Map<String, dynamic> toJson() => {
        'maximumQuantity': JsonConverters.toJson(maximumQuantity,'Quantity',context!),
        'minimumQuantity': JsonConverters.toJson(minimumQuantity,'Quantity',context!)
    };

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

class DateTimeRange implements IConvertible
{
    DateTime beginDate = DateTime(0);
    Duration? beginTime;
    DateTime? endDate;
    Duration? endTime;

    DateTimeRange({this.beginDate,this.beginTime,this.endDate,this.endTime});
    DateTimeRange.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        beginDate = JsonConverters.fromJson(json['beginDate'],'DateTime',context!);
        beginTime = JsonConverters.fromJson(json['beginTime'],'Duration',context!);
        endDate = JsonConverters.fromJson(json['endDate'],'DateTime',context!);
        endTime = JsonConverters.fromJson(json['endTime'],'Duration',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'beginDate': JsonConverters.toJson(beginDate,'DateTime',context!),
        'beginTime': JsonConverters.toJson(beginTime,'Duration',context!),
        'endDate': JsonConverters.toJson(endDate,'DateTime',context!),
        'endTime': JsonConverters.toJson(endTime,'Duration',context!)
    };

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

class PurchaseConditionsPriceInformation implements IConvertible
{
    Quantity itemPriceBaseQuantity;
    double? itemPriceExclusiveAllowancesCharges;
    QuantityRange quantityRange;
    DateTimeRange effectivePeriod;

    PurchaseConditionsPriceInformation({this.itemPriceBaseQuantity,this.itemPriceExclusiveAllowancesCharges,this.quantityRange,this.effectivePeriod});
    PurchaseConditionsPriceInformation.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        itemPriceBaseQuantity = JsonConverters.fromJson(json['itemPriceBaseQuantity'],'Quantity',context!);
        itemPriceExclusiveAllowancesCharges = JsonConverters.toDouble(json['itemPriceExclusiveAllowancesCharges']);
        quantityRange = JsonConverters.fromJson(json['quantityRange'],'QuantityRange',context!);
        effectivePeriod = JsonConverters.fromJson(json['effectivePeriod'],'DateTimeRange',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'itemPriceBaseQuantity': JsonConverters.toJson(itemPriceBaseQuantity,'Quantity',context!),
        'itemPriceExclusiveAllowancesCharges': itemPriceExclusiveAllowancesCharges,
        'quantityRange': JsonConverters.toJson(quantityRange,'QuantityRange',context!),
        'effectivePeriod': JsonConverters.toJson(effectivePeriod,'DateTimeRange',context!)
    };

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

class AllowanceCharge implements IConvertible
{
    double? allowanceChargeAmount;
    double? allowanceChargePercentage;
    String allowanceChargeType = "";
    String allowanceOrChargeType = "";
    double? amountPerUnit;
    double? baseAmount;
    String baseNumberOfUnits = "";
    String bracketIdentifier = "";
    DateTime? effectiveDateType;
    String sequenceNumber = "";
    String settlementType = "";
    String specialServiceType = "";
    String allowanceChargeDescription = "";

    AllowanceCharge({this.allowanceChargeAmount,this.allowanceChargePercentage,this.allowanceChargeType,this.allowanceOrChargeType,this.amountPerUnit,this.baseAmount,this.baseNumberOfUnits,this.bracketIdentifier,this.effectiveDateType,this.sequenceNumber,this.settlementType,this.specialServiceType,this.allowanceChargeDescription});
    AllowanceCharge.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        allowanceChargeAmount = JsonConverters.toDouble(json['allowanceChargeAmount']);
        allowanceChargePercentage = JsonConverters.toDouble(json['allowanceChargePercentage']);
        allowanceChargeType = json['allowanceChargeType'];
        allowanceOrChargeType = json['allowanceOrChargeType'];
        amountPerUnit = JsonConverters.toDouble(json['amountPerUnit']);
        baseAmount = JsonConverters.toDouble(json['baseAmount']);
        baseNumberOfUnits = json['baseNumberOfUnits'];
        bracketIdentifier = json['bracketIdentifier'];
        effectiveDateType = JsonConverters.fromJson(json['effectiveDateType'],'DateTime',context!);
        sequenceNumber = json['sequenceNumber'];
        settlementType = json['settlementType'];
        specialServiceType = json['specialServiceType'];
        allowanceChargeDescription = json['allowanceChargeDescription'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'allowanceChargeAmount': allowanceChargeAmount,
        'allowanceChargePercentage': allowanceChargePercentage,
        'allowanceChargeType': allowanceChargeType,
        'allowanceOrChargeType': allowanceOrChargeType,
        'amountPerUnit': amountPerUnit,
        'baseAmount': baseAmount,
        'baseNumberOfUnits': baseNumberOfUnits,
        'bracketIdentifier': bracketIdentifier,
        'effectiveDateType': JsonConverters.toJson(effectiveDateType,'DateTime',context!),
        'sequenceNumber': sequenceNumber,
        'settlementType': settlementType,
        'specialServiceType': specialServiceType,
        'allowanceChargeDescription': allowanceChargeDescription
    };

    getTypeName() => "AllowanceCharge";
    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 LeviedDutyFeeTax implements IConvertible
{
    double? dutyFeeTaxAmount;
    double? dutyFeeTaxBasisAmount;
    String dutyFeeTaxDescription = "";
    double? dutyFeeTaxPercentage;

    LeviedDutyFeeTax({this.dutyFeeTaxAmount,this.dutyFeeTaxBasisAmount,this.dutyFeeTaxDescription,this.dutyFeeTaxPercentage});
    LeviedDutyFeeTax.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        dutyFeeTaxAmount = JsonConverters.toDouble(json['dutyFeeTaxAmount']);
        dutyFeeTaxBasisAmount = JsonConverters.toDouble(json['dutyFeeTaxBasisAmount']);
        dutyFeeTaxDescription = json['dutyFeeTaxDescription'];
        dutyFeeTaxPercentage = JsonConverters.toDouble(json['dutyFeeTaxPercentage']);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'dutyFeeTaxAmount': dutyFeeTaxAmount,
        'dutyFeeTaxBasisAmount': dutyFeeTaxBasisAmount,
        'dutyFeeTaxDescription': dutyFeeTaxDescription,
        'dutyFeeTaxPercentage': dutyFeeTaxPercentage
    };

    getTypeName() => "LeviedDutyFeeTax";
    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 PurchaseConditionsLineItem implements IConvertible
{
    double? discrepancyTolerancePercentage;
    int? lineItemNumber;
    String packagingTypeCode = "";
    int? parentLineItemNumber;
    Quantity purchaseConditionsQuantity;
    List<PurchaseConditionsCommitmentPeriod> purchaseConditionsCommitmentPeriod = [];
    List<PurchaseConditionsPriceInformation> purchaseConditionsPriceInformation = [];
    List<AllowanceCharge> allowanceCharge = [];
    TransactionalTradeItem transactionalTradeItem;
    LeviedDutyFeeTax leviedDutyFeeTax;
    List<AvpList> avpList = [];
    DateTimeRange effectivePeriod;
    DocumentReference materialSpecification;
    QuantityRange purchaseConditionsQuantityRange;

    PurchaseConditionsLineItem({this.discrepancyTolerancePercentage,this.lineItemNumber,this.packagingTypeCode,this.parentLineItemNumber,this.purchaseConditionsQuantity,this.purchaseConditionsCommitmentPeriod,this.purchaseConditionsPriceInformation,this.allowanceCharge,this.transactionalTradeItem,this.leviedDutyFeeTax,this.avpList,this.effectivePeriod,this.materialSpecification,this.purchaseConditionsQuantityRange});
    PurchaseConditionsLineItem.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        discrepancyTolerancePercentage = JsonConverters.toDouble(json['discrepancyTolerancePercentage']);
        lineItemNumber = json['lineItemNumber'];
        packagingTypeCode = json['packagingTypeCode'];
        parentLineItemNumber = json['parentLineItemNumber'];
        purchaseConditionsQuantity = JsonConverters.fromJson(json['purchaseConditionsQuantity'],'Quantity',context!);
        purchaseConditionsCommitmentPeriod = JsonConverters.fromJson(json['purchaseConditionsCommitmentPeriod'],'List<PurchaseConditionsCommitmentPeriod>',context!);
        purchaseConditionsPriceInformation = JsonConverters.fromJson(json['purchaseConditionsPriceInformation'],'List<PurchaseConditionsPriceInformation>',context!);
        allowanceCharge = JsonConverters.fromJson(json['allowanceCharge'],'List<AllowanceCharge>',context!);
        transactionalTradeItem = JsonConverters.fromJson(json['transactionalTradeItem'],'TransactionalTradeItem',context!);
        leviedDutyFeeTax = JsonConverters.fromJson(json['leviedDutyFeeTax'],'LeviedDutyFeeTax',context!);
        avpList = JsonConverters.fromJson(json['avpList'],'List<AvpList>',context!);
        effectivePeriod = JsonConverters.fromJson(json['effectivePeriod'],'DateTimeRange',context!);
        materialSpecification = JsonConverters.fromJson(json['materialSpecification'],'DocumentReference',context!);
        purchaseConditionsQuantityRange = JsonConverters.fromJson(json['purchaseConditionsQuantityRange'],'QuantityRange',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'discrepancyTolerancePercentage': discrepancyTolerancePercentage,
        'lineItemNumber': lineItemNumber,
        'packagingTypeCode': packagingTypeCode,
        'parentLineItemNumber': parentLineItemNumber,
        'purchaseConditionsQuantity': JsonConverters.toJson(purchaseConditionsQuantity,'Quantity',context!),
        'purchaseConditionsCommitmentPeriod': JsonConverters.toJson(purchaseConditionsCommitmentPeriod,'List<PurchaseConditionsCommitmentPeriod>',context!),
        'purchaseConditionsPriceInformation': JsonConverters.toJson(purchaseConditionsPriceInformation,'List<PurchaseConditionsPriceInformation>',context!),
        'allowanceCharge': JsonConverters.toJson(allowanceCharge,'List<AllowanceCharge>',context!),
        'transactionalTradeItem': JsonConverters.toJson(transactionalTradeItem,'TransactionalTradeItem',context!),
        'leviedDutyFeeTax': JsonConverters.toJson(leviedDutyFeeTax,'LeviedDutyFeeTax',context!),
        'avpList': JsonConverters.toJson(avpList,'List<AvpList>',context!),
        'effectivePeriod': JsonConverters.toJson(effectivePeriod,'DateTimeRange',context!),
        'materialSpecification': JsonConverters.toJson(materialSpecification,'DocumentReference',context!),
        'purchaseConditionsQuantityRange': JsonConverters.toJson(purchaseConditionsQuantityRange,'QuantityRange',context!)
    };

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

class PurchaseConditionsLocationInformation implements IConvertible
{
    List<PurchaseConditionsLineItem> purchaseConditionsLineItem = [];
    TransactionalParty shipFrom;
    TransactionalParty shipTo;

    PurchaseConditionsLocationInformation({this.purchaseConditionsLineItem,this.shipFrom,this.shipTo});
    PurchaseConditionsLocationInformation.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        purchaseConditionsLineItem = JsonConverters.fromJson(json['purchaseConditionsLineItem'],'List<PurchaseConditionsLineItem>',context!);
        shipFrom = JsonConverters.fromJson(json['shipFrom'],'TransactionalParty',context!);
        shipTo = JsonConverters.fromJson(json['shipTo'],'TransactionalParty',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'purchaseConditionsLineItem': JsonConverters.toJson(purchaseConditionsLineItem,'List<PurchaseConditionsLineItem>',context!),
        'shipFrom': JsonConverters.toJson(shipFrom,'TransactionalParty',context!),
        'shipTo': JsonConverters.toJson(shipTo,'TransactionalParty',context!)
    };

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

class CurrencyExchangeRateInformation implements IConvertible
{
    String currencyConversionFromCode = "";
    String currencyConversionToCode = "";
    int? exchangeRate;
    DateTime? exchangeRateDateTime;

    CurrencyExchangeRateInformation({this.currencyConversionFromCode,this.currencyConversionToCode,this.exchangeRate,this.exchangeRateDateTime});
    CurrencyExchangeRateInformation.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        currencyConversionFromCode = json['currencyConversionFromCode'];
        currencyConversionToCode = json['currencyConversionToCode'];
        exchangeRate = json['exchangeRate'];
        exchangeRateDateTime = JsonConverters.fromJson(json['exchangeRateDateTime'],'DateTime',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'currencyConversionFromCode': currencyConversionFromCode,
        'currencyConversionToCode': currencyConversionToCode,
        'exchangeRate': exchangeRate,
        'exchangeRateDateTime': JsonConverters.toJson(exchangeRateDateTime,'DateTime',context!)
    };

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

class PurchaseConditions extends BaseDocument implements IConvertible
{
    String purchaseConditionsCurrencyCode = "";
    List<PurchaseConditionsLocationInformation> purchaseConditionsLocationInformation = [];
    CurrencyExchangeRateInformation currencyExchangeRateInformation;
    TransactionalParty buyer;
    TransactionalParty payee;
    TransactionalParty payer;
    String purchaseConditionsIdentification = "";
    TransactionalParty remitTo;
    TransactionalParty seller;
    TransactionalParty taxRepresentative;

    PurchaseConditions({this.purchaseConditionsCurrencyCode,this.purchaseConditionsLocationInformation,this.currencyExchangeRateInformation,this.buyer,this.payee,this.payer,this.purchaseConditionsIdentification,this.remitTo,this.seller,this.taxRepresentative});
    PurchaseConditions.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        super.fromMap(json);
        purchaseConditionsCurrencyCode = json['purchaseConditionsCurrencyCode'];
        purchaseConditionsLocationInformation = JsonConverters.fromJson(json['purchaseConditionsLocationInformation'],'List<PurchaseConditionsLocationInformation>',context!);
        currencyExchangeRateInformation = JsonConverters.fromJson(json['currencyExchangeRateInformation'],'CurrencyExchangeRateInformation',context!);
        buyer = JsonConverters.fromJson(json['buyer'],'TransactionalParty',context!);
        payee = JsonConverters.fromJson(json['payee'],'TransactionalParty',context!);
        payer = JsonConverters.fromJson(json['payer'],'TransactionalParty',context!);
        purchaseConditionsIdentification = json['purchaseConditionsIdentification'];
        remitTo = JsonConverters.fromJson(json['remitTo'],'TransactionalParty',context!);
        seller = JsonConverters.fromJson(json['seller'],'TransactionalParty',context!);
        taxRepresentative = JsonConverters.fromJson(json['taxRepresentative'],'TransactionalParty',context!);
        return this;
    }

    Map<String, dynamic> toJson() => super.toJson()..addAll({
        'purchaseConditionsCurrencyCode': purchaseConditionsCurrencyCode,
        'purchaseConditionsLocationInformation': JsonConverters.toJson(purchaseConditionsLocationInformation,'List<PurchaseConditionsLocationInformation>',context!),
        'currencyExchangeRateInformation': JsonConverters.toJson(currencyExchangeRateInformation,'CurrencyExchangeRateInformation',context!),
        'buyer': JsonConverters.toJson(buyer,'TransactionalParty',context!),
        'payee': JsonConverters.toJson(payee,'TransactionalParty',context!),
        'payer': JsonConverters.toJson(payer,'TransactionalParty',context!),
        'purchaseConditionsIdentification': purchaseConditionsIdentification,
        'remitTo': JsonConverters.toJson(remitTo,'TransactionalParty',context!),
        'seller': JsonConverters.toJson(seller,'TransactionalParty',context!),
        'taxRepresentative': JsonConverters.toJson(taxRepresentative,'TransactionalParty',context!)
    });

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

class PurchaseConditionsMessage implements IConvertible
{
    Header header;
    PurchaseConditions purchaseConditions;

    PurchaseConditionsMessage({this.header,this.purchaseConditions});
    PurchaseConditionsMessage.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        header = JsonConverters.fromJson(json['header'],'Header',context!);
        purchaseConditions = JsonConverters.fromJson(json['purchaseConditions'],'PurchaseConditions',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'header': JsonConverters.toJson(header,'Header',context!),
        'purchaseConditions': JsonConverters.toJson(purchaseConditions,'PurchaseConditions',context!)
    };

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

/**
* Purchase Conditions
*/
// @Route("/purchaseCondition", "GET")
// @Api(Description="Purchase Conditions")
// @ApiResponse(Description="Purchase Condition message", IsDefaultResponse=true, StatusCode=200)
// @ApiResponse(Description="No Content", ResponseType=typeof(IReturnVoid), StatusCode=204)
class GetPurchaseCondition implements IReturn<ResultItem<PurchaseConditionsMessage>>, IConvertible, IGet
{
    GetPurchaseCondition();
    GetPurchaseCondition.fromJson(Map<String, dynamic> json) : super();
    fromMap(Map<String, dynamic> json) {
        return this;
    }

    Map<String, dynamic> toJson() => {};
    createResponse() => ResultItem<PurchaseConditionsMessage>();
    getResponseTypeName() => "ResultItem<PurchaseConditionsMessage>";
    getTypeName() => "GetPurchaseCondition";
    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()),
    '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()),
    'Quantity': TypeInfo(TypeOf.Class, create:() => Quantity()),
    'TimeMeasurement': TypeInfo(TypeOf.Class, create:() => TimeMeasurement()),
    'PurchaseConditionsCommitmentPeriod': TypeInfo(TypeOf.Class, create:() => PurchaseConditionsCommitmentPeriod()),
    'QuantityRange': TypeInfo(TypeOf.Class, create:() => QuantityRange()),
    'DateTimeRange': TypeInfo(TypeOf.Class, create:() => DateTimeRange()),
    'PurchaseConditionsPriceInformation': TypeInfo(TypeOf.Class, create:() => PurchaseConditionsPriceInformation()),
    'AllowanceCharge': TypeInfo(TypeOf.Class, create:() => AllowanceCharge()),
    '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>[]),
    'LeviedDutyFeeTax': TypeInfo(TypeOf.Class, create:() => LeviedDutyFeeTax()),
    'DocumentReference': TypeInfo(TypeOf.Class, create:() => DocumentReference()),
    'PurchaseConditionsLineItem': TypeInfo(TypeOf.Class, create:() => PurchaseConditionsLineItem()),
    'List<PurchaseConditionsCommitmentPeriod>': TypeInfo(TypeOf.Class, create:() => <PurchaseConditionsCommitmentPeriod>[]),
    'List<PurchaseConditionsPriceInformation>': TypeInfo(TypeOf.Class, create:() => <PurchaseConditionsPriceInformation>[]),
    'List<AllowanceCharge>': TypeInfo(TypeOf.Class, create:() => <AllowanceCharge>[]),
    'PurchaseConditionsLocationInformation': TypeInfo(TypeOf.Class, create:() => PurchaseConditionsLocationInformation()),
    'List<PurchaseConditionsLineItem>': TypeInfo(TypeOf.Class, create:() => <PurchaseConditionsLineItem>[]),
    'CurrencyExchangeRateInformation': TypeInfo(TypeOf.Class, create:() => CurrencyExchangeRateInformation()),
    'PurchaseConditions': TypeInfo(TypeOf.Class, create:() => PurchaseConditions()),
    'List<PurchaseConditionsLocationInformation>': TypeInfo(TypeOf.Class, create:() => <PurchaseConditionsLocationInformation>[]),
    'PurchaseConditionsMessage': TypeInfo(TypeOf.Class, create:() => PurchaseConditionsMessage()),
    'ResultItem<PurchaseConditionsMessage>': TypeInfo(TypeOf.Class, create:() => ResultItem<PurchaseConditionsMessage>()),
    'GetPurchaseCondition': TypeInfo(TypeOf.Class, create:() => GetPurchaseCondition()),
});