/* Options:
Date: 2026-02-14 10:16:32
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: GetCustomerMasterByIdentification.*
//ExcludeTypes: 
//DefaultImports: package:servicestack/servicestack.dart
*/

import 'package:servicestack/servicestack.dart';

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 CustomerMasterAddress extends Address implements IConvertible
{
    String addressType = "";

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

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

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

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

class CustomerRecord implements IConvertible
{
    String gln = "";
    String code = "";
    String name = "";
    String buyerAssignedVendorNo = "";
    String supplierAssignedVendorNo = "";
    String dutyFeeTaxRegistration = "";
    String entityIdentification = "";
    List<Contact> contact = [];
    CustomerMasterAddress address;
    List<AvpList> avpList = [];

    CustomerRecord({this.gln,this.code,this.name,this.buyerAssignedVendorNo,this.supplierAssignedVendorNo,this.dutyFeeTaxRegistration,this.entityIdentification,this.contact,this.address,this.avpList});
    CustomerRecord.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        gln = json['gln'];
        code = json['code'];
        name = json['name'];
        buyerAssignedVendorNo = json['buyerAssignedVendorNo'];
        supplierAssignedVendorNo = json['supplierAssignedVendorNo'];
        dutyFeeTaxRegistration = json['dutyFeeTaxRegistration'];
        entityIdentification = json['entityIdentification'];
        contact = JsonConverters.fromJson(json['contact'],'List<Contact>',context!);
        address = JsonConverters.fromJson(json['address'],'CustomerMasterAddress',context!);
        avpList = JsonConverters.fromJson(json['avpList'],'List<AvpList>',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'gln': gln,
        'code': code,
        'name': name,
        'buyerAssignedVendorNo': buyerAssignedVendorNo,
        'supplierAssignedVendorNo': supplierAssignedVendorNo,
        'dutyFeeTaxRegistration': dutyFeeTaxRegistration,
        'entityIdentification': entityIdentification,
        'contact': JsonConverters.toJson(contact,'List<Contact>',context!),
        'address': JsonConverters.toJson(address,'CustomerMasterAddress',context!),
        'avpList': JsonConverters.toJson(avpList,'List<AvpList>',context!)
    };

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

class CreditLimit implements IConvertible
{
    double limit = 0;
    double balance = 0;
    double available = 0;
    DateTime? effectiveDateTime;

    CreditLimit({this.limit,this.balance,this.available,this.effectiveDateTime});
    CreditLimit.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        limit = JsonConverters.toDouble(json['limit']);
        balance = JsonConverters.toDouble(json['balance']);
        available = JsonConverters.toDouble(json['available']);
        effectiveDateTime = JsonConverters.fromJson(json['effectiveDateTime'],'DateTime',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'limit': limit,
        'balance': balance,
        'available': available,
        'effectiveDateTime': JsonConverters.toJson(effectiveDateTime,'DateTime',context!)
    };

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

class CustomerMasterType extends CustomerRecord implements IConvertible
{
    CustomerRecord payByCustomer;
    CustomerRecord billToCustomer;
    String routingCode = "";
    String storeType = "";
    String currencyCode = "";
    String type = "";
    String group = "";
    String region = "";
    String zoneRate = "";
    String taxRule = "";
    String paymentTerm = "";
    String shipmentSite = "";
    String shipmentSiteName = "";
    String shipmentSiteGln = "";
    String accountingCode = "";
    String commercialRepresentative = "";
    String commercialTerritory = "";
    CreditLimit credit;
    List<String> nod = [];
    List<String> ndd = [];

    CustomerMasterType({this.payByCustomer,this.billToCustomer,this.routingCode,this.storeType,this.currencyCode,this.type,this.group,this.region,this.zoneRate,this.taxRule,this.paymentTerm,this.shipmentSite,this.shipmentSiteName,this.shipmentSiteGln,this.accountingCode,this.commercialRepresentative,this.commercialTerritory,this.credit,this.nod,this.ndd});
    CustomerMasterType.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        super.fromMap(json);
        payByCustomer = JsonConverters.fromJson(json['payByCustomer'],'CustomerRecord',context!);
        billToCustomer = JsonConverters.fromJson(json['billToCustomer'],'CustomerRecord',context!);
        routingCode = json['routingCode'];
        storeType = json['storeType'];
        currencyCode = json['currencyCode'];
        type = json['type'];
        group = json['group'];
        region = json['region'];
        zoneRate = json['zoneRate'];
        taxRule = json['taxRule'];
        paymentTerm = json['paymentTerm'];
        shipmentSite = json['shipmentSite'];
        shipmentSiteName = json['shipmentSiteName'];
        shipmentSiteGln = json['shipmentSiteGln'];
        accountingCode = json['accountingCode'];
        commercialRepresentative = json['commercialRepresentative'];
        commercialTerritory = json['commercialTerritory'];
        credit = JsonConverters.fromJson(json['credit'],'CreditLimit',context!);
        nod = JsonConverters.fromJson(json['nod'],'List<String>',context!);
        ndd = JsonConverters.fromJson(json['ndd'],'List<String>',context!);
        return this;
    }

    Map<String, dynamic> toJson() => super.toJson()..addAll({
        'payByCustomer': JsonConverters.toJson(payByCustomer,'CustomerRecord',context!),
        'billToCustomer': JsonConverters.toJson(billToCustomer,'CustomerRecord',context!),
        'routingCode': routingCode,
        'storeType': storeType,
        'currencyCode': currencyCode,
        'type': type,
        'group': group,
        'region': region,
        'zoneRate': zoneRate,
        'taxRule': taxRule,
        'paymentTerm': paymentTerm,
        'shipmentSite': shipmentSite,
        'shipmentSiteName': shipmentSiteName,
        'shipmentSiteGln': shipmentSiteGln,
        'accountingCode': accountingCode,
        'commercialRepresentative': commercialRepresentative,
        'commercialTerritory': commercialTerritory,
        'credit': JsonConverters.toJson(credit,'CreditLimit',context!),
        'nod': JsonConverters.toJson(nod,'List<String>',context!),
        'ndd': JsonConverters.toJson(ndd,'List<String>',context!)
    });

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

class CustomerMasterMessage implements IConvertible
{
    TransactionalParty dataSource;
    TransactionalParty dataRecipient;
    String customerMasterIdentification = "";
    List<CustomerMasterType> customer = [];
    String documentStatusCode = "";
    String documentActionCode = "";
    DateTime creationDateTime = DateTime(0);
    DateTime lastUpdateDateTime = DateTime(0);

    CustomerMasterMessage({this.dataSource,this.dataRecipient,this.customerMasterIdentification,this.customer,this.documentStatusCode,this.documentActionCode,this.creationDateTime,this.lastUpdateDateTime});
    CustomerMasterMessage.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        dataSource = JsonConverters.fromJson(json['dataSource'],'TransactionalParty',context!);
        dataRecipient = JsonConverters.fromJson(json['dataRecipient'],'TransactionalParty',context!);
        customerMasterIdentification = json['customerMasterIdentification'];
        customer = JsonConverters.fromJson(json['customer'],'List<CustomerMasterType>',context!);
        documentStatusCode = json['documentStatusCode'];
        documentActionCode = json['documentActionCode'];
        creationDateTime = JsonConverters.fromJson(json['creationDateTime'],'DateTime',context!);
        lastUpdateDateTime = JsonConverters.fromJson(json['lastUpdateDateTime'],'DateTime',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'dataSource': JsonConverters.toJson(dataSource,'TransactionalParty',context!),
        'dataRecipient': JsonConverters.toJson(dataRecipient,'TransactionalParty',context!),
        'customerMasterIdentification': customerMasterIdentification,
        'customer': JsonConverters.toJson(customer,'List<CustomerMasterType>',context!),
        'documentStatusCode': documentStatusCode,
        'documentActionCode': documentActionCode,
        'creationDateTime': JsonConverters.toJson(creationDateTime,'DateTime',context!),
        'lastUpdateDateTime': JsonConverters.toJson(lastUpdateDateTime,'DateTime',context!)
    };

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

/**
* Customer Master
*/
// @Route("/customerMaster/{OwnerGln}/{CustomerMasterIdentification}", "GET")
// @Api(Description="Customer Master")
// @ApiResponse(Description="Customer Master data", IsDefaultResponse=true, StatusCode=200)
// @ApiResponse(Description="No Content", ResponseType=typeof(IReturnVoid), StatusCode=204)
// @ApiResponse(Description="Specified argument was out of the range of valid values.", ResponseType=typeof(ArgumentOutOfRangeException), StatusCode=400)
class GetCustomerMasterByIdentification implements IReturn<CustomerMasterMessage>, IConvertible, IGet
{
    /**
    * Owner GLN
    */
    // @ApiMember(Description="Owner GLN", ExcludeInSchema=true, ParameterType="path")
    String ownerGln = "";

    /**
    * Customer Master Identification
    */
    // @ApiMember(Description="Customer Master Identification", ExcludeInSchema=true, ParameterType="path")
    String customerMasterIdentification = "";

    GetCustomerMasterByIdentification({this.ownerGln,this.customerMasterIdentification});
    GetCustomerMasterByIdentification.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

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

    createResponse() => CustomerMasterMessage();
    getResponseTypeName() => "CustomerMasterMessage";
    getTypeName() => "GetCustomerMasterByIdentification";
    TypeContext? context = _ctx;
}

TypeContext _ctx = TypeContext(library: 'stf_api_uat.data_xchange.co.za', types: <String, TypeInfo> {
    '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>[]),
    'CustomerMasterAddress': TypeInfo(TypeOf.Class, create:() => CustomerMasterAddress()),
    'CustomerRecord': TypeInfo(TypeOf.Class, create:() => CustomerRecord()),
    'CreditLimit': TypeInfo(TypeOf.Class, create:() => CreditLimit()),
    'CustomerMasterType': TypeInfo(TypeOf.Class, create:() => CustomerMasterType()),
    'CustomerMasterMessage': TypeInfo(TypeOf.Class, create:() => CustomerMasterMessage()),
    'List<CustomerMasterType>': TypeInfo(TypeOf.Class, create:() => <CustomerMasterType>[]),
    'GetCustomerMasterByIdentification': TypeInfo(TypeOf.Class, create:() => GetCustomerMasterByIdentification()),
});