/**
 * QualifiedDataType classes for Factur-X
 * Based on urn:un:unece:uncefact:data:standard:QualifiedDataType:100
 */
/**
 * Code identifying the type of a buyer accounting account.
 * @profile EXTENDED
 */
declare class AccountingAccountTypeCodeType {
    constructor({ value }: {
        value: string;
    });
    value: string;
}
/**
 * Coded reason for an allowance or charge (UNTDID 5189 for allowances, UNTDID 7161 for charges).
 * @profile BASIC WL
 */
declare class AllowanceChargeReasonCodeType {
    constructor({ value }: {
        value: string;
    });
    value: string;
}
/**
 * Code identifying the type or role of a trade contact.
 * @profile EXTENDED
 */
declare class ContactTypeCodeType {
    constructor({ value }: {
        value: string;
    });
    value: string;
}
/**
 * ISO 3166-1 alpha-2 country code.
 * @profile MINIMUM
 */
declare class CountryIDType {
    constructor({ value }: {
        value: string;
    });
    value: string;
}
/**
 * ISO 4217 currency code.
 * @profile MINIMUM
 */
declare class CurrencyCodeType {
    constructor({ value }: {
        value: string;
    });
    value: string;
}
/**
 * Incoterms code identifying the applicable delivery terms.
 * @profile EXTENDED
 */
declare class DeliveryTermsCodeType {
    constructor({ value }: {
        value: string;
    });
    value: string;
}
/**
 * UNTDID 1001 code giving the document / invoice type.
 * @profile MINIMUM
 */
declare class DocumentCodeType {
    constructor({ value }: {
        value: string;
    });
    value: string;
}
/**
 * A date/time expressed with an explicit format qualifier.
 * @profile BASIC WL
 */
declare class FormattedDateTimeType {
    constructor({ dateTimeString, format }: {
        dateTimeString: string;
        format: string;
    });
    dateTimeString: string;
    format: string;
}
/**
 * Code giving the status of an invoice line.
 * @profile EXTENDED
 */
declare class LineStatusCodeType {
    constructor({ value }: {
        value: string;
    });
    value: string;
}
/**
 * Code identifying the role a trade party plays.
 * @profile EXTENDED
 */
declare class PartyRoleCodeType {
    constructor({ value }: {
        value: string;
    });
    value: string;
}
/**
 * UNTDID 4461 code identifying the means of payment.
 * @profile BASIC WL
 */
declare class PaymentMeansCodeType {
    constructor({ value }: {
        value: string;
    });
    value: string;
}
/**
 * UNTDID 1153 code qualifying the type of a referenced document.
 * @profile EN 16931
 */
declare class ReferenceCodeType {
    constructor({ value }: {
        value: string;
    });
    value: string;
}
/**
 * VAT category code (UNTDID 5305), e.g. standard rate, zero-rated, exempt or reverse charge.
 * @profile BASIC WL
 */
declare class TaxCategoryCodeType {
    constructor({ value }: {
        value: string;
    });
    value: string;
}
/**
 * Code identifying the type of tax, typically VAT (UNTDID 5153).
 * @profile BASIC WL
 */
declare class TaxTypeCodeType {
    constructor({ value }: {
        value: string;
    });
    value: string;
}
/**
 * Code identifying the event a date refers to, e.g. the basis for a VAT due date.
 * @profile BASIC WL
 */
declare class TimeReferenceCodeType {
    constructor({ value }: {
        value: string;
    });
    value: string;
}
/**
 * Code identifying the mode of transport.
 * @profile EXTENDED
 */
declare class TransportModeCodeType {
    constructor({ value }: {
        value: string;
    });
    value: string;
}

/**
 * UnqualifiedDataType classes for Factur-X
 * Based on urn:un:unece:uncefact:data:standard:UnqualifiedDataType:100
 */
/**
 * A monetary amount, optionally tagged with its ISO 4217 currency.
 * @profile MINIMUM
 */
declare class AmountType {
    constructor({ value, currencyID }: {
        value: number;
        currencyID?: string;
    });
    value: number;
    currencyID?: string;
}
/**
 * An embedded binary attachment (e.g. a supporting document or image) with its MIME type and filename.
 * @profile EN 16931
 */
declare class BinaryObjectType {
    constructor({ value, mimeCode, filename }: {
        value: string;
        mimeCode: string;
        filename: string;
    });
    value: string;
    mimeCode: string;
    filename: string;
}
/**
 * A coded value drawn from a code list, optionally identifying the list and its version.
 * @profile BASIC WL
 */
declare class CodeType {
    constructor({ value, listID, listVersionID }: {
        value: string;
        listID?: string;
        listVersionID?: string;
    });
    value: string;
    listID?: string;
    listVersionID?: string;
}
/**
 * A date/time value paired with a format code describing how its string is encoded.
 * @profile MINIMUM
 */
declare class DateTimeType {
    constructor({ dateTimeString, format }: {
        dateTimeString: string;
        format: string;
    });
    dateTimeString: string;
    format: string;
}
/**
 * A date value paired with a format code describing how its string is encoded.
 * @profile EN 16931
 */
declare class DateType {
    constructor({ dateString, format }: {
        dateString: string;
        format: string;
    });
    dateString: string;
    format: string;
}
/**
 * An identifier value, optionally qualified by the scheme under which it is issued.
 * @profile MINIMUM
 */
declare class IDType {
    constructor({ value, schemeID }: {
        value: string;
        schemeID?: string;
    });
    value: string;
    schemeID?: string;
}
/**
 * A boolean flag.
 * @profile BASIC WL
 */
declare class IndicatorType {
    constructor({ indicator }: {
        indicator: boolean;
    });
    indicator: boolean;
}
/**
 * A measured physical quantity, optionally tagged with its unit of measure.
 * @profile EXTENDED
 */
declare class MeasureType {
    constructor({ value, unitCode }: {
        value: number;
        unitCode?: string;
    });
    value: number;
    unitCode?: string;
}
/**
 * A plain numeric value.
 * @profile EXTENDED
 */
declare class NumericType {
    constructor({ value }: {
        value: number;
    });
    value: number;
}
/**
 * A percentage value.
 * @profile BASIC WL
 */
declare class PercentType {
    constructor({ value }: {
        value: number;
    });
    value: number;
}
/**
 * A counted quantity, optionally tagged with its unit of measure.
 * @profile BASIC
 */
declare class QuantityType {
    constructor({ value, unitCode }: {
        value: number;
        unitCode?: string;
    });
    value: number;
    unitCode?: string;
}
/**
 * A rate value, such as a currency conversion rate.
 * @profile EXTENDED
 */
declare class RateType {
    constructor({ value }: {
        value: number;
    });
    value: number;
}
/**
 * A free-text string value.
 * @profile MINIMUM
 */
declare class TextType {
    constructor({ value }: {
        value: string;
    });
    value: string;
}

/**
 * ReusableAggregateBusinessInformationEntity classes for Factur-X
 * Based on urn:un:unece:uncefact:data:standard:ReusableAggregateBusinessInformationEntity:100
 */

/**
 * A time period given by start and end (or a single complete) date-time, such as an invoicing or billing period.
 * @profile BASIC WL
 */
declare class SpecifiedPeriodType {
    constructor({ description, startDateTime, endDateTime, completeDateTime, }: {
        description?: TextType;
        startDateTime?: DateTimeType;
        endDateTime?: DateTimeType;
        completeDateTime?: DateTimeType;
    });
    description?: TextType;
    startDateTime?: DateTimeType;
    endDateTime?: DateTimeType;
    completeDateTime?: DateTimeType;
}
/**
 * A reference to a related document such as an order, contract, despatch advice or supporting attachment, with its identifier, type and optional embedded binary content.
 * @profile MINIMUM
 */
declare class ReferencedDocumentType {
    constructor({ issuerAssignedID, uriID, lineID, typeCode, name, attachmentBinaryObject, referenceTypeCode, formattedIssueDateTime, }: {
        issuerAssignedID?: IDType;
        uriID?: IDType;
        lineID?: IDType;
        typeCode?: DocumentCodeType;
        name?: TextType[];
        attachmentBinaryObject?: BinaryObjectType;
        referenceTypeCode?: ReferenceCodeType;
        formattedIssueDateTime?: FormattedDateTimeType;
    });
    issuerAssignedID?: IDType;
    uriID?: IDType;
    lineID?: IDType;
    typeCode?: DocumentCodeType;
    name?: TextType[];
    attachmentBinaryObject?: BinaryObjectType;
    referenceTypeCode?: ReferenceCodeType;
    formattedIssueDateTime?: FormattedDateTimeType;
}
/**
 * The applicable delivery terms, given as an Incoterms-style code and an optional relevant location.
 * @profile EXTENDED
 */
declare class TradeDeliveryTermsType {
    constructor({ deliveryTypeCode, relevantTradeLocation, }: {
        deliveryTypeCode: DeliveryTermsCodeType;
        relevantTradeLocation?: TradeLocationType;
    });
    deliveryTypeCode: DeliveryTermsCodeType;
    relevantTradeLocation?: TradeLocationType;
}
/**
 * A geographic location, identified by country code and/or name.
 * @profile EXTENDED
 */
declare class TradeLocationType {
    constructor({ countryID, name, }: {
        countryID?: CountryIDType;
        name?: TextType;
    });
    countryID?: CountryIDType;
    name?: TextType;
}
/**
 * The procurement project or contract reference the invoice relates to, identified by its identifier and name.
 * @profile EN 16931
 */
declare class ProcuringProjectType {
    constructor({ id, name, }: {
        id: IDType;
        name: TextType;
    });
    id: IDType;
    name: TextType;
}
/**
 * An advance (prepaid) payment: its paid amount, receipt date, included VAT and the prepayment invoice it refers to.
 * @profile EXTENDED
 */
declare class AdvancePaymentType {
    constructor({ paidAmount, formattedReceivedDateTime, includedTradeTax, invoiceSpecifiedReferencedDocument, }: {
        paidAmount: AmountType;
        formattedReceivedDateTime?: FormattedDateTimeType;
        includedTradeTax: TradeTaxType[];
        invoiceSpecifiedReferencedDocument?: ReferencedDocumentType;
    });
    paidAmount: AmountType;
    formattedReceivedDateTime?: FormattedDateTimeType;
    includedTradeTax: TradeTaxType[];
    invoiceSpecifiedReferencedDocument?: ReferencedDocumentType;
}
/**
 * A financial adjustment to the settlement, given as a reason and an amount.
 * @profile EXTENDED
 */
declare class FinancialAdjustmentType {
    constructor({ reason, actualAmount, }: {
        reason: TextType;
        actualAmount: AmountType;
    });
    reason: TextType;
    actualAmount: AmountType;
}
/**
 * The payee's receiving bank account, identified by IBAN or a proprietary number, with an optional account name.
 * @profile BASIC WL
 */
declare class CreditorFinancialAccountType {
    constructor({ ibanID, accountName, proprietaryID, }: {
        ibanID?: IDType;
        accountName?: TextType;
        proprietaryID?: IDType;
    });
    ibanID?: IDType;
    accountName?: TextType;
    proprietaryID?: IDType;
}
/**
 * The payee's bank, identified by its BIC.
 * @profile EN 16931
 */
declare class CreditorFinancialInstitutionType {
    constructor({ bicID }: {
        bicID: IDType;
    });
    bicID: IDType;
}
/**
 * The payer's bank account, identified by IBAN, used notably for direct debit.
 * @profile BASIC WL
 */
declare class DebtorFinancialAccountType {
    constructor({ ibanID, accountName }: {
        ibanID: IDType;
        accountName?: TextType;
    });
    ibanID: IDType;
    accountName?: TextType;
}
/**
 * The payer's bank, identified by its BIC.
 * @profile EXTENDED
 */
declare class DebtorFinancialInstitutionType {
    constructor({ bicID }: {
        bicID?: IDType;
    });
    bicID?: IDType;
}
/**
 * A context parameter carrying the identifier of a guideline or business process.
 * @profile MINIMUM
 */
declare class DocumentContextParameterType {
    constructor({ id }: {
        id: IDType;
    });
    id: IDType;
}
/**
 * A free-text note, optionally qualified by subject and content codes.
 * @profile BASIC WL
 */
declare class NoteType {
    constructor({ contentCode, content, subjectCode, }: {
        contentCode?: CodeType;
        content: TextType;
        subjectCode?: CodeType;
    });
    contentCode?: CodeType;
    content: TextType;
    subjectCode?: CodeType;
}
/**
 * Line-level document header: the line number, optional parent line, status code and free-text notes.
 * @profile BASIC
 */
declare class DocumentLineDocumentType {
    constructor({ lineID, parentLineID, lineStatusCode, lineStatusReasonCode, includedNote, }: {
        lineID: IDType;
        parentLineID?: IDType;
        lineStatusCode?: LineStatusCodeType;
        lineStatusReasonCode?: CodeType;
        includedNote?: NoteType[];
    });
    lineID: IDType;
    parentLineID?: IDType;
    lineStatusCode?: LineStatusCodeType;
    lineStatusReasonCode?: CodeType;
    includedNote?: NoteType[];
}
/**
 * A VAT breakdown entry for one combination of category and rate: the taxable basis, the resulting tax amount and an optional exemption reason.
 * @profile BASIC WL
 */
declare class TradeTaxType {
    constructor({ calculatedAmount, typeCode, exemptionReason, basisAmount, lineTotalBasisAmount, allowanceChargeBasisAmount, categoryCode, exemptionReasonCode, taxPointDate, dueDateTypeCode, rateApplicablePercent, }: {
        calculatedAmount?: AmountType;
        typeCode?: TaxTypeCodeType;
        exemptionReason?: TextType;
        basisAmount?: AmountType;
        lineTotalBasisAmount?: AmountType;
        allowanceChargeBasisAmount?: AmountType;
        categoryCode: TaxCategoryCodeType;
        exemptionReasonCode?: CodeType;
        taxPointDate?: DateType;
        dueDateTypeCode?: TimeReferenceCodeType;
        rateApplicablePercent?: PercentType;
    });
    calculatedAmount?: AmountType;
    typeCode?: TaxTypeCodeType;
    exemptionReason?: TextType;
    basisAmount?: AmountType;
    lineTotalBasisAmount?: AmountType;
    allowanceChargeBasisAmount?: AmountType;
    categoryCode: TaxCategoryCodeType;
    exemptionReasonCode?: CodeType;
    taxPointDate?: DateType;
    dueDateTypeCode?: TimeReferenceCodeType;
    rateApplicablePercent?: PercentType;
}
/**
 * A postal address: street lines, city, post code, ISO 3166-1 country code and country sub-division.
 * @profile MINIMUM
 */
declare class TradeAddressType {
    constructor({ postcodeCode, lineOne, lineTwo, lineThree, cityName, countryID, countrySubDivisionName, }: {
        postcodeCode?: CodeType;
        lineOne?: TextType;
        lineTwo?: TextType;
        lineThree?: TextType;
        cityName?: TextType;
        countryID: CountryIDType;
        countrySubDivisionName?: TextType[];
    });
    postcodeCode?: CodeType;
    lineOne?: TextType;
    lineTwo?: TextType;
    lineThree?: TextType;
    cityName?: TextType;
    countryID: CountryIDType;
    countrySubDivisionName?: TextType[];
}
/**
 * A communication channel, holding either a URI/email address or a phone or fax number.
 * @profile BASIC WL
 */
declare class UniversalCommunicationType {
    constructor({ uriID, completeNumber, }: {
        uriID?: IDType;
        completeNumber?: TextType;
    });
    uriID?: IDType;
    completeNumber?: TextType;
}
/**
 * A contact person for a party: name, department and telephone, fax and email channels.
 * @profile EN 16931
 */
declare class TradeContactType {
    constructor({ personName, departmentName, typeCode, telephoneUniversalCommunication, faxUniversalCommunication, emailURIUniversalCommunication, }: {
        personName?: TextType;
        departmentName?: TextType;
        typeCode?: ContactTypeCodeType;
        telephoneUniversalCommunication?: UniversalCommunicationType;
        faxUniversalCommunication?: UniversalCommunicationType;
        emailURIUniversalCommunication?: UniversalCommunicationType;
    });
    personName?: TextType;
    departmentName?: TextType;
    typeCode?: ContactTypeCodeType;
    telephoneUniversalCommunication?: UniversalCommunicationType;
    faxUniversalCommunication?: UniversalCommunicationType;
    emailURIUniversalCommunication?: UniversalCommunicationType;
}
/**
 * A party's legal registration: its legal identifier, trading name and registered address.
 * @profile MINIMUM
 */
declare class LegalOrganizationType {
    constructor({ id, tradingBusinessName, postalTradeAddress, }: {
        id?: IDType;
        tradingBusinessName?: TextType;
        postalTradeAddress?: TradeAddressType;
    });
    id?: IDType;
    tradingBusinessName?: TextType;
    postalTradeAddress?: TradeAddressType;
}
/**
 * A party's tax registration identifier, such as its VAT identifier.
 * @profile MINIMUM
 */
declare class TaxRegistrationType {
    constructor({ id }: {
        id: IDType;
    });
    id: IDType;
}
/**
 * A party involved in the trade (seller, buyer, payee, ship-to, tax representative, …): its identifiers, name, role, legal organization, address, contacts and tax registrations.
 * @profile MINIMUM
 */
declare class TradePartyType {
    constructor({ id, globalID, name, roleCode, description, specifiedLegalOrganization, definedTradeContact, postalTradeAddress, uriUniversalCommunication, specifiedTaxRegistration, }: {
        id?: IDType[];
        globalID?: IDType[];
        name?: TextType;
        roleCode?: PartyRoleCodeType;
        description?: TextType;
        specifiedLegalOrganization?: LegalOrganizationType;
        definedTradeContact?: TradeContactType[];
        postalTradeAddress?: TradeAddressType;
        uriUniversalCommunication?: UniversalCommunicationType;
        specifiedTaxRegistration?: TaxRegistrationType[];
    });
    id?: IDType[];
    globalID?: IDType[];
    name?: TextType;
    roleCode?: PartyRoleCodeType;
    description?: TextType;
    specifiedLegalOrganization?: LegalOrganizationType;
    definedTradeContact?: TradeContactType[];
    postalTradeAddress?: TradeAddressType;
    uriUniversalCommunication?: UniversalCommunicationType;
    specifiedTaxRegistration?: TaxRegistrationType[];
}
/**
 * A supply-chain event, such as the actual delivery, given by its occurrence date-time.
 * @profile BASIC WL
 */
declare class SupplyChainEventType {
    constructor({ occurrenceDateTime, }: {
        occurrenceDateTime: DateTimeType;
    });
    occurrenceDateTime: DateTimeType;
}
/**
 * A consignment within the delivery, carrying its specified transport movements.
 * @profile EXTENDED
 */
declare class SupplyChainConsignmentType {
    constructor({ specifiedLogisticsTransportMovement, }: {
        specifiedLogisticsTransportMovement?: LogisticsTransportMovementType[];
    });
    specifiedLogisticsTransportMovement?: LogisticsTransportMovementType[];
}
/**
 * A transport movement, identified by its mode of transport.
 * @profile EXTENDED
 */
declare class LogisticsTransportMovementType {
    constructor({ modeCode, }: {
        modeCode: TransportModeCodeType;
    });
    modeCode: TransportModeCodeType;
}
/**
 * A buyer accounting reference, such as a cost-centre code, with an optional account type code.
 * @profile BASIC WL
 */
declare class TradeAccountingAccountType {
    constructor({ id, typeCode, }: {
        id: IDType;
        typeCode?: AccountingAccountTypeCodeType;
    });
    id: IDType;
    typeCode?: AccountingAccountTypeCodeType;
}
/**
 * A currency conversion between source and target currencies, with the conversion rate and its date.
 * @profile EXTENDED
 */
declare class TradeCurrencyExchangeType {
    constructor({ sourceCurrencyCode, targetCurrencyCode, conversionRate, conversionRateDateTime, }: {
        sourceCurrencyCode: CurrencyCodeType;
        targetCurrencyCode: CurrencyCodeType;
        conversionRate: RateType;
        conversionRateDateTime?: DateTimeType;
    });
    sourceCurrencyCode: CurrencyCodeType;
    targetCurrencyCode: CurrencyCodeType;
    conversionRate: RateType;
    conversionRateDateTime?: DateTimeType;
}
/**
 * An allowance (deduction) or charge: a charge indicator, an amount or percentage with its basis, a reason and the applicable VAT category.
 * @profile BASIC WL
 */
declare class TradeAllowanceChargeType {
    constructor({ chargeIndicator, sequenceNumeric, calculationPercent, basisAmount, basisQuantity, actualAmount, reasonCode, reason, categoryTradeTax, }: {
        chargeIndicator: IndicatorType;
        sequenceNumeric?: NumericType;
        calculationPercent?: PercentType;
        basisAmount?: AmountType;
        basisQuantity?: QuantityType;
        actualAmount: AmountType;
        reasonCode?: AllowanceChargeReasonCodeType;
        reason?: TextType;
        categoryTradeTax?: TradeTaxType;
    });
    chargeIndicator: IndicatorType;
    sequenceNumeric?: NumericType;
    calculationPercent?: PercentType;
    basisAmount?: AmountType;
    basisQuantity?: QuantityType;
    actualAmount: AmountType;
    reasonCode?: AllowanceChargeReasonCodeType;
    reason?: TextType;
    categoryTradeTax?: TradeTaxType;
}
/**
 * A logistics service charge, given by its description, amount and applicable tax.
 * @profile EXTENDED
 */
declare class LogisticsServiceChargeType {
    constructor({ description, appliedAmount, appliedTradeTax, }: {
        description: TextType;
        appliedAmount: AmountType;
        appliedTradeTax?: TradeTaxType[];
    });
    description: TextType;
    appliedAmount: AmountType;
    appliedTradeTax?: TradeTaxType[];
}
/**
 * Late-payment penalty terms: the basis date, period and amount together with the penalty percentage or amount.
 * @profile EXTENDED
 */
declare class TradePaymentPenaltyTermsType {
    constructor({ basisDateTime, basisPeriodMeasure, basisAmount, calculationPercent, actualPenaltyAmount, }: {
        basisDateTime?: DateTimeType;
        basisPeriodMeasure?: MeasureType;
        basisAmount?: AmountType;
        calculationPercent?: PercentType;
        actualPenaltyAmount?: AmountType;
    });
    basisDateTime?: DateTimeType;
    basisPeriodMeasure?: MeasureType;
    basisAmount?: AmountType;
    calculationPercent?: PercentType;
    actualPenaltyAmount?: AmountType;
}
/**
 * Early-payment discount terms: the basis date, period and amount together with the discount percentage or amount.
 * @profile EXTENDED
 */
declare class TradePaymentDiscountTermsType {
    constructor({ basisDateTime, basisPeriodMeasure, basisAmount, calculationPercent, actualDiscountAmount, }: {
        basisDateTime?: DateTimeType;
        basisPeriodMeasure?: MeasureType;
        basisAmount?: AmountType;
        calculationPercent?: PercentType;
        actualDiscountAmount?: AmountType;
    });
    basisDateTime?: DateTimeType;
    basisPeriodMeasure?: MeasureType;
    basisAmount?: AmountType;
    calculationPercent?: PercentType;
    actualDiscountAmount?: AmountType;
}
/**
 * Payment terms: textual description, due date, direct-debit mandate, partial-payment amount and the applicable penalty and discount terms.
 * @profile BASIC WL
 */
declare class TradePaymentTermsType {
    constructor({ description, dueDateDateTime, directDebitMandateID, partialPaymentAmount, applicableTradePaymentPenaltyTerms, applicableTradePaymentDiscountTerms, payeeTradeParty, }: {
        description?: TextType;
        dueDateDateTime?: DateTimeType;
        directDebitMandateID?: IDType;
        partialPaymentAmount?: AmountType;
        applicableTradePaymentPenaltyTerms?: TradePaymentPenaltyTermsType;
        applicableTradePaymentDiscountTerms?: TradePaymentDiscountTermsType;
        payeeTradeParty?: TradePartyType;
    });
    description?: TextType;
    dueDateDateTime?: DateTimeType;
    directDebitMandateID?: IDType;
    partialPaymentAmount?: AmountType;
    applicableTradePaymentPenaltyTerms?: TradePaymentPenaltyTermsType;
    applicableTradePaymentDiscountTerms?: TradePaymentDiscountTermsType;
    payeeTradeParty?: TradePartyType;
}
/**
 * A payment card used for settlement, identified by a (masked) card number and cardholder name.
 * @profile EN 16931
 */
declare class TradeSettlementFinancialCardType {
    constructor({ id, cardholderName, }: {
        id: IDType;
        cardholderName?: TextType;
    });
    id: IDType;
    cardholderName?: TextType;
}
/**
 * A means of payment: its UNTDID 4461 type code plus the card, debtor/creditor accounts and financial institutions involved.
 * @profile BASIC WL
 */
declare class TradeSettlementPaymentMeansType {
    constructor({ typeCode, information, applicableTradeSettlementFinancialCard, payerPartyDebtorFinancialAccount, payeePartyCreditorFinancialAccount, payerSpecifiedDebtorFinancialInstitution, payeeSpecifiedCreditorFinancialInstitution, }: {
        typeCode: PaymentMeansCodeType;
        information?: TextType;
        applicableTradeSettlementFinancialCard?: TradeSettlementFinancialCardType;
        payerPartyDebtorFinancialAccount?: DebtorFinancialAccountType;
        payeePartyCreditorFinancialAccount?: CreditorFinancialAccountType;
        payerSpecifiedDebtorFinancialInstitution?: DebtorFinancialInstitutionType;
        payeeSpecifiedCreditorFinancialInstitution?: CreditorFinancialInstitutionType;
    });
    typeCode: PaymentMeansCodeType;
    information?: TextType;
    applicableTradeSettlementFinancialCard?: TradeSettlementFinancialCardType;
    payerPartyDebtorFinancialAccount?: DebtorFinancialAccountType;
    payeePartyCreditorFinancialAccount?: CreditorFinancialAccountType;
    payerSpecifiedDebtorFinancialInstitution?: DebtorFinancialInstitutionType;
    payeeSpecifiedCreditorFinancialInstitution?: CreditorFinancialInstitutionType;
}
/**
 * Document-level monetary totals: line, charge and allowance totals, tax basis and VAT amount, grand total, prepaid amount and the amount due for payment.
 * @profile MINIMUM
 */
declare class TradeSettlementHeaderMonetarySummationType {
    constructor({ lineTotalAmount, chargeTotalAmount, allowanceTotalAmount, taxBasisTotalAmount, taxTotalAmount, roundingAmount, grandTotalAmount, totalPrepaidAmount, duePayableAmount, }: {
        lineTotalAmount?: AmountType;
        chargeTotalAmount?: AmountType;
        allowanceTotalAmount?: AmountType;
        taxBasisTotalAmount: AmountType;
        taxTotalAmount?: AmountType[];
        roundingAmount?: AmountType;
        grandTotalAmount: AmountType;
        totalPrepaidAmount?: AmountType;
        duePayableAmount: AmountType;
    });
    lineTotalAmount?: AmountType;
    chargeTotalAmount?: AmountType;
    allowanceTotalAmount?: AmountType;
    taxBasisTotalAmount: AmountType;
    taxTotalAmount?: AmountType[];
    roundingAmount?: AmountType;
    grandTotalAmount: AmountType;
    totalPrepaidAmount?: AmountType;
    duePayableAmount: AmountType;
}
/**
 * A product attribute, given as a description and value, optionally with a measured value and type code.
 * @profile EN 16931
 */
declare class ProductCharacteristicType {
    constructor({ typeCode, description, valueMeasure, value, }: {
        typeCode?: CodeType;
        description: TextType;
        valueMeasure?: MeasureType;
        value: TextType;
    });
    typeCode?: CodeType;
    description: TextType;
    valueMeasure?: MeasureType;
    value: TextType;
}
/**
 * A product classification, given as a classification code and/or class name.
 * @profile EN 16931
 */
declare class ProductClassificationType {
    constructor({ classCode, className, }: {
        classCode?: CodeType;
        className?: TextType;
    });
    classCode?: CodeType;
    className?: TextType;
}
/**
 * A specific instance of an item, identified by batch and/or supplier-assigned serial number.
 * @profile EXTENDED
 */
declare class TradeProductInstanceType {
    constructor({ batchID, supplierAssignedSerialID, }: {
        batchID?: IDType;
        supplierAssignedSerialID?: IDType;
    });
    batchID?: IDType;
    supplierAssignedSerialID?: IDType;
}
/**
 * The country of origin of an item, given as an ISO 3166-1 country code.
 * @profile EN 16931
 */
declare class TradeCountryType {
    constructor({ id, }: {
        id?: CountryIDType;
    });
    id?: CountryIDType;
}
/**
 * A component or included product, with its identifiers, name, description and unit quantity.
 * @profile EXTENDED
 */
declare class ReferencedProductType {
    constructor({ id, globalID, sellerAssignedID, buyerAssignedID, industryAssignedID, name, description, unitQuantity, }: {
        id?: IDType;
        globalID?: IDType[];
        sellerAssignedID?: IDType;
        buyerAssignedID?: IDType;
        industryAssignedID?: IDType;
        name: TextType;
        description?: TextType;
        unitQuantity?: QuantityType;
    });
    id?: IDType;
    globalID?: IDType[];
    sellerAssignedID?: IDType;
    buyerAssignedID?: IDType;
    industryAssignedID?: IDType;
    name: TextType;
    description?: TextType;
    unitQuantity?: QuantityType;
}
/**
 * The invoiced item: its identifiers, name, description, attributes, classifications, country of origin and manufacturer.
 * @profile BASIC
 */
declare class TradeProductType {
    constructor({ id, globalID, sellerAssignedID, buyerAssignedID, industryAssignedID, modelID, name, description, batchID, brandName, modelName, applicableProductCharacteristic, designatedProductClassification, individualTradeProductInstance, originTradeCountry, manufacturerTradeParty, includedReferencedProduct, }: {
        id?: IDType;
        globalID?: IDType;
        sellerAssignedID?: IDType;
        buyerAssignedID?: IDType;
        industryAssignedID?: IDType;
        modelID?: IDType;
        name: TextType;
        description?: TextType;
        batchID?: IDType[];
        brandName?: TextType;
        modelName?: TextType;
        applicableProductCharacteristic?: ProductCharacteristicType[];
        designatedProductClassification?: ProductClassificationType[];
        individualTradeProductInstance?: TradeProductInstanceType[];
        originTradeCountry?: TradeCountryType;
        manufacturerTradeParty?: TradePartyType;
        includedReferencedProduct?: ReferencedProductType[];
    });
    id?: IDType;
    globalID?: IDType;
    sellerAssignedID?: IDType;
    buyerAssignedID?: IDType;
    industryAssignedID?: IDType;
    modelID?: IDType;
    name: TextType;
    description?: TextType;
    batchID?: IDType[];
    brandName?: TextType;
    modelName?: TextType;
    applicableProductCharacteristic?: ProductCharacteristicType[];
    designatedProductClassification?: ProductClassificationType[];
    individualTradeProductInstance?: TradeProductInstanceType[];
    originTradeCountry?: TradeCountryType;
    manufacturerTradeParty?: TradePartyType;
    includedReferencedProduct?: ReferencedProductType[];
}
/**
 * An item price (gross or net): the price amount, its basis quantity and any applied allowances/charges or included tax.
 * @profile BASIC
 */
declare class TradePriceType {
    constructor({ chargeAmount, basisQuantity, appliedTradeAllowanceCharge, includedTradeTax, }: {
        chargeAmount: AmountType;
        basisQuantity?: QuantityType;
        appliedTradeAllowanceCharge?: TradeAllowanceChargeType[];
        includedTradeTax?: TradeTaxType;
    });
    chargeAmount: AmountType;
    basisQuantity?: QuantityType;
    appliedTradeAllowanceCharge?: TradeAllowanceChargeType[];
    includedTradeTax?: TradeTaxType;
}
/**
 * Line-level trade agreement (price details): the gross and net unit prices and references to the related order, contract and quotation.
 * @profile BASIC
 */
declare class LineTradeAgreementType {
    constructor({ applicableTradeDeliveryTerms, sellerOrderReferencedDocument, buyerOrderReferencedDocument, quotationReferencedDocument, contractReferencedDocument, additionalReferencedDocument, grossPriceProductTradePrice, netPriceProductTradePrice, itemSellerTradeParty, ultimateCustomerOrderReferencedDocument, }: {
        applicableTradeDeliveryTerms?: TradeDeliveryTermsType;
        sellerOrderReferencedDocument?: ReferencedDocumentType;
        buyerOrderReferencedDocument?: ReferencedDocumentType;
        quotationReferencedDocument?: ReferencedDocumentType;
        contractReferencedDocument?: ReferencedDocumentType;
        additionalReferencedDocument?: ReferencedDocumentType[];
        grossPriceProductTradePrice?: TradePriceType;
        netPriceProductTradePrice?: TradePriceType;
        itemSellerTradeParty?: TradePartyType;
        ultimateCustomerOrderReferencedDocument?: ReferencedDocumentType[];
    });
    applicableTradeDeliveryTerms?: TradeDeliveryTermsType;
    sellerOrderReferencedDocument?: ReferencedDocumentType;
    buyerOrderReferencedDocument?: ReferencedDocumentType;
    quotationReferencedDocument?: ReferencedDocumentType;
    contractReferencedDocument?: ReferencedDocumentType;
    additionalReferencedDocument?: ReferencedDocumentType[];
    grossPriceProductTradePrice?: TradePriceType;
    netPriceProductTradePrice?: TradePriceType;
    itemSellerTradeParty?: TradePartyType;
    ultimateCustomerOrderReferencedDocument?: ReferencedDocumentType[];
}
/**
 * Line-level delivery: the billed and packaging quantities, ship-to party, delivery event and despatch/receiving/delivery-note references.
 * @profile BASIC
 */
declare class LineTradeDeliveryType {
    constructor({ billedQuantity, chargeFreeQuantity, packageQuantity, perPackageUnitQuantity, shipToTradeParty, ultimateShipToTradeParty, actualDeliverySupplyChainEvent, despatchAdviceReferencedDocument, receivingAdviceReferencedDocument, deliveryNoteReferencedDocument, }: {
        billedQuantity?: QuantityType;
        chargeFreeQuantity?: QuantityType;
        packageQuantity?: QuantityType;
        perPackageUnitQuantity?: QuantityType;
        shipToTradeParty?: TradePartyType;
        ultimateShipToTradeParty?: TradePartyType;
        actualDeliverySupplyChainEvent?: SupplyChainEventType;
        despatchAdviceReferencedDocument?: ReferencedDocumentType;
        receivingAdviceReferencedDocument?: ReferencedDocumentType;
        deliveryNoteReferencedDocument?: ReferencedDocumentType;
    });
    billedQuantity?: QuantityType;
    chargeFreeQuantity?: QuantityType;
    packageQuantity?: QuantityType;
    perPackageUnitQuantity?: QuantityType;
    shipToTradeParty?: TradePartyType;
    ultimateShipToTradeParty?: TradePartyType;
    actualDeliverySupplyChainEvent?: SupplyChainEventType;
    despatchAdviceReferencedDocument?: ReferencedDocumentType;
    receivingAdviceReferencedDocument?: ReferencedDocumentType;
    deliveryNoteReferencedDocument?: ReferencedDocumentType;
}
/**
 * Line-level monetary totals: the net line amount plus any charge, allowance and tax totals.
 * @profile BASIC
 */
declare class TradeSettlementLineMonetarySummationType {
    constructor({ lineTotalAmount, chargeTotalAmount, allowanceTotalAmount, taxTotalAmount, grandTotalAmount, totalAllowanceChargeAmount, }: {
        lineTotalAmount: AmountType;
        chargeTotalAmount?: AmountType;
        allowanceTotalAmount?: AmountType;
        taxTotalAmount?: AmountType;
        grandTotalAmount?: AmountType;
        totalAllowanceChargeAmount?: AmountType;
    });
    lineTotalAmount: AmountType;
    chargeTotalAmount?: AmountType;
    allowanceTotalAmount?: AmountType;
    taxTotalAmount?: AmountType;
    grandTotalAmount?: AmountType;
    totalAllowanceChargeAmount?: AmountType;
}
/**
 * Line-level settlement: the applicable VAT, invoice line period, line allowances/charges, line totals and accounting reference.
 * @profile BASIC
 */
declare class LineTradeSettlementType {
    constructor({ applicableTradeTax, billingSpecifiedPeriod, specifiedTradeAllowanceCharge, specifiedTradeSettlementLineMonetarySummation, invoiceReferencedDocument, additionalReferencedDocument, receivableSpecifiedTradeAccountingAccount, }: {
        applicableTradeTax: TradeTaxType[];
        billingSpecifiedPeriod?: SpecifiedPeriodType;
        specifiedTradeAllowanceCharge?: TradeAllowanceChargeType[];
        specifiedTradeSettlementLineMonetarySummation?: TradeSettlementLineMonetarySummationType;
        invoiceReferencedDocument?: ReferencedDocumentType;
        additionalReferencedDocument?: ReferencedDocumentType[];
        receivableSpecifiedTradeAccountingAccount?: TradeAccountingAccountType[];
    });
    applicableTradeTax: TradeTaxType[];
    billingSpecifiedPeriod?: SpecifiedPeriodType;
    specifiedTradeAllowanceCharge?: TradeAllowanceChargeType[];
    specifiedTradeSettlementLineMonetarySummation?: TradeSettlementLineMonetarySummationType;
    invoiceReferencedDocument?: ReferencedDocumentType;
    additionalReferencedDocument?: ReferencedDocumentType[];
    receivableSpecifiedTradeAccountingAccount?: TradeAccountingAccountType[];
}
/**
 * An invoice line: its line document, the specified item, and the line-level agreement, delivery and settlement.
 * @profile BASIC
 */
declare class SupplyChainTradeLineItemType {
    constructor({ associatedDocumentLineDocument, specifiedTradeProduct, specifiedLineTradeAgreement, specifiedLineTradeDelivery, specifiedLineTradeSettlement, }: {
        associatedDocumentLineDocument: DocumentLineDocumentType;
        specifiedTradeProduct: TradeProductType;
        specifiedLineTradeAgreement?: LineTradeAgreementType;
        specifiedLineTradeDelivery?: LineTradeDeliveryType;
        specifiedLineTradeSettlement: LineTradeSettlementType;
    });
    associatedDocumentLineDocument: DocumentLineDocumentType;
    specifiedTradeProduct: TradeProductType;
    specifiedLineTradeAgreement?: LineTradeAgreementType;
    specifiedLineTradeDelivery?: LineTradeDeliveryType;
    specifiedLineTradeSettlement: LineTradeSettlementType;
}

/**
 * CrossIndustryInvoice classes for Factur-X
 * Based on urn:un:unece:uncefact:data:standard:CrossIndustryInvoice:100
 */

/**
 * Business context of the invoice, naming the Factur-X guideline (profile) it conforms to and the business process it belongs to.
 * @profile MINIMUM
 */
declare class ExchangedDocumentContextType {
    constructor({ testIndicator, businessProcessSpecifiedDocumentContextParameter, guidelineSpecifiedDocumentContextParameter, }: {
        testIndicator?: IndicatorType;
        businessProcessSpecifiedDocumentContextParameter?: DocumentContextParameterType;
        guidelineSpecifiedDocumentContextParameter: DocumentContextParameterType;
    });
    testIndicator?: IndicatorType;
    businessProcessSpecifiedDocumentContextParameter?: DocumentContextParameterType;
    guidelineSpecifiedDocumentContextParameter: DocumentContextParameterType;
}
/**
 * Document-level header of the invoice: its number, UNTDID 1001 type code, issue date and optional name, notes and language.
 * @profile MINIMUM
 */
declare class ExchangedDocumentType {
    constructor({ id, name, typeCode, issueDateTime, copyIndicator, languageID, includedNote, effectiveSpecifiedPeriod, }: {
        id: IDType;
        name?: TextType;
        typeCode: DocumentCodeType;
        issueDateTime: DateTimeType;
        copyIndicator?: IndicatorType;
        languageID?: IDType[];
        includedNote?: NoteType[];
        effectiveSpecifiedPeriod?: SpecifiedPeriodType;
    });
    id: IDType;
    name?: TextType;
    typeCode: DocumentCodeType;
    issueDateTime: DateTimeType;
    copyIndicator?: IndicatorType;
    languageID?: IDType[];
    includedNote?: NoteType[];
    effectiveSpecifiedPeriod?: SpecifiedPeriodType;
}
/**
 * Document-level trade agreement covering the seller and buyer, their tax representatives and agents, and references to the order, contract, quotation and procuring project.
 * @profile MINIMUM
 */
declare class HeaderTradeAgreementType {
    constructor({ buyerReference, sellerTradeParty, buyerTradeParty, salesAgentTradeParty, buyerTaxRepresentativeTradeParty, sellerTaxRepresentativeTradeParty, productEndUserTradeParty, applicableTradeDeliveryTerms, sellerOrderReferencedDocument, buyerOrderReferencedDocument, quotationReferencedDocument, contractReferencedDocument, additionalReferencedDocument, buyerAgentTradeParty, specifiedProcuringProject, ultimateCustomerOrderReferencedDocument, }: {
        buyerReference?: TextType;
        sellerTradeParty: TradePartyType;
        buyerTradeParty: TradePartyType;
        salesAgentTradeParty?: TradePartyType;
        buyerTaxRepresentativeTradeParty?: TradePartyType;
        sellerTaxRepresentativeTradeParty?: TradePartyType;
        productEndUserTradeParty?: TradePartyType;
        applicableTradeDeliveryTerms?: TradeDeliveryTermsType;
        sellerOrderReferencedDocument?: ReferencedDocumentType;
        buyerOrderReferencedDocument?: ReferencedDocumentType;
        quotationReferencedDocument?: ReferencedDocumentType;
        contractReferencedDocument?: ReferencedDocumentType;
        additionalReferencedDocument?: ReferencedDocumentType[];
        buyerAgentTradeParty?: TradePartyType;
        specifiedProcuringProject?: ProcuringProjectType;
        ultimateCustomerOrderReferencedDocument?: ReferencedDocumentType[];
    });
    buyerReference?: TextType;
    sellerTradeParty: TradePartyType;
    buyerTradeParty: TradePartyType;
    salesAgentTradeParty?: TradePartyType;
    buyerTaxRepresentativeTradeParty?: TradePartyType;
    sellerTaxRepresentativeTradeParty?: TradePartyType;
    productEndUserTradeParty?: TradePartyType;
    applicableTradeDeliveryTerms?: TradeDeliveryTermsType;
    sellerOrderReferencedDocument?: ReferencedDocumentType;
    buyerOrderReferencedDocument?: ReferencedDocumentType;
    quotationReferencedDocument?: ReferencedDocumentType;
    contractReferencedDocument?: ReferencedDocumentType;
    additionalReferencedDocument?: ReferencedDocumentType[];
    buyerAgentTradeParty?: TradePartyType;
    specifiedProcuringProject?: ProcuringProjectType;
    ultimateCustomerOrderReferencedDocument?: ReferencedDocumentType[];
}
/**
 * Document-level delivery information stating where and when the goods or services are delivered: ship-to/ship-from parties, the actual delivery event and despatch, receiving and delivery-note references.
 * @profile MINIMUM
 */
declare class HeaderTradeDeliveryType {
    constructor({ relatedSupplyChainConsignment, shipToTradeParty, ultimateShipToTradeParty, shipFromTradeParty, actualDeliverySupplyChainEvent, despatchAdviceReferencedDocument, receivingAdviceReferencedDocument, deliveryNoteReferencedDocument, }: {
        relatedSupplyChainConsignment?: SupplyChainConsignmentType;
        shipToTradeParty?: TradePartyType;
        ultimateShipToTradeParty?: TradePartyType;
        shipFromTradeParty?: TradePartyType;
        actualDeliverySupplyChainEvent?: SupplyChainEventType;
        despatchAdviceReferencedDocument?: ReferencedDocumentType;
        receivingAdviceReferencedDocument?: ReferencedDocumentType;
        deliveryNoteReferencedDocument?: ReferencedDocumentType;
    });
    relatedSupplyChainConsignment?: SupplyChainConsignmentType;
    shipToTradeParty?: TradePartyType;
    ultimateShipToTradeParty?: TradePartyType;
    shipFromTradeParty?: TradePartyType;
    actualDeliverySupplyChainEvent?: SupplyChainEventType;
    despatchAdviceReferencedDocument?: ReferencedDocumentType;
    receivingAdviceReferencedDocument?: ReferencedDocumentType;
    deliveryNoteReferencedDocument?: ReferencedDocumentType;
}
/**
 * Document-level settlement covering invoice and VAT accounting currencies, payee/payer parties, payment means, the VAT breakdown, document-level allowances and charges, payment terms and the monetary totals.
 * @profile MINIMUM
 */
declare class HeaderTradeSettlementType {
    constructor({ creditorReferenceID, paymentReference, taxCurrencyCode, invoiceCurrencyCode, invoiceIssuerReference, invoicerTradeParty, invoiceeTradeParty, payeeTradeParty, payerTradeParty, taxApplicableTradeCurrencyExchange, specifiedTradeSettlementPaymentMeans, applicableTradeTax, billingSpecifiedPeriod, specifiedTradeAllowanceCharge, specifiedLogisticsServiceCharge, specifiedTradePaymentTerms, specifiedTradeSettlementHeaderMonetarySummation, specifiedFinancialAdjustment, invoiceReferencedDocument, receivableSpecifiedTradeAccountingAccount, specifiedAdvancePayment, }: {
        creditorReferenceID?: IDType;
        paymentReference?: TextType;
        taxCurrencyCode?: CurrencyCodeType;
        invoiceCurrencyCode: CurrencyCodeType;
        invoiceIssuerReference?: TextType;
        invoicerTradeParty?: TradePartyType;
        invoiceeTradeParty?: TradePartyType;
        payeeTradeParty?: TradePartyType;
        payerTradeParty?: TradePartyType;
        taxApplicableTradeCurrencyExchange?: TradeCurrencyExchangeType;
        specifiedTradeSettlementPaymentMeans?: TradeSettlementPaymentMeansType[];
        applicableTradeTax?: TradeTaxType[];
        billingSpecifiedPeriod?: SpecifiedPeriodType;
        specifiedTradeAllowanceCharge?: TradeAllowanceChargeType[];
        specifiedLogisticsServiceCharge?: LogisticsServiceChargeType[];
        specifiedTradePaymentTerms?: TradePaymentTermsType[];
        specifiedTradeSettlementHeaderMonetarySummation: TradeSettlementHeaderMonetarySummationType;
        specifiedFinancialAdjustment?: FinancialAdjustmentType[];
        invoiceReferencedDocument?: ReferencedDocumentType[];
        receivableSpecifiedTradeAccountingAccount?: TradeAccountingAccountType[];
        specifiedAdvancePayment?: AdvancePaymentType[];
    });
    creditorReferenceID?: IDType;
    paymentReference?: TextType;
    taxCurrencyCode?: CurrencyCodeType;
    invoiceCurrencyCode: CurrencyCodeType;
    invoiceIssuerReference?: TextType;
    invoicerTradeParty?: TradePartyType;
    invoiceeTradeParty?: TradePartyType;
    payeeTradeParty?: TradePartyType;
    payerTradeParty?: TradePartyType;
    taxApplicableTradeCurrencyExchange?: TradeCurrencyExchangeType;
    specifiedTradeSettlementPaymentMeans?: TradeSettlementPaymentMeansType[];
    applicableTradeTax: TradeTaxType[];
    billingSpecifiedPeriod?: SpecifiedPeriodType;
    specifiedTradeAllowanceCharge?: TradeAllowanceChargeType[];
    specifiedLogisticsServiceCharge?: LogisticsServiceChargeType[];
    specifiedTradePaymentTerms?: TradePaymentTermsType[];
    specifiedTradeSettlementHeaderMonetarySummation: TradeSettlementHeaderMonetarySummationType;
    specifiedFinancialAdjustment?: FinancialAdjustmentType[];
    invoiceReferencedDocument?: ReferencedDocumentType[];
    receivableSpecifiedTradeAccountingAccount?: TradeAccountingAccountType[];
    specifiedAdvancePayment?: AdvancePaymentType[];
}
/**
 * The trade transaction bundling the invoice line items with the document-level agreement, delivery and settlement headers.
 * @profile MINIMUM
 */
declare class SupplyChainTradeTransactionType {
    constructor({ includedSupplyChainTradeLineItem, applicableHeaderTradeAgreement, applicableHeaderTradeDelivery, applicableHeaderTradeSettlement, }: {
        includedSupplyChainTradeLineItem?: SupplyChainTradeLineItemType[];
        applicableHeaderTradeAgreement: HeaderTradeAgreementType;
        applicableHeaderTradeDelivery: HeaderTradeDeliveryType;
        applicableHeaderTradeSettlement: HeaderTradeSettlementType;
    });
    includedSupplyChainTradeLineItem?: SupplyChainTradeLineItemType[];
    applicableHeaderTradeAgreement: HeaderTradeAgreementType;
    applicableHeaderTradeDelivery: HeaderTradeDeliveryType;
    applicableHeaderTradeSettlement: HeaderTradeSettlementType;
}
/**
 * Root of a Factur-X / UN/CEFACT CII invoice, bundling the document context, the document header and the trade transaction.
 * @profile MINIMUM
 */
declare class CrossIndustryInvoiceType {
    constructor({ exchangedDocumentContext, exchangedDocument, supplyChainTradeTransaction, }: {
        exchangedDocumentContext: ExchangedDocumentContextType;
        exchangedDocument: ExchangedDocumentType;
        supplyChainTradeTransaction: SupplyChainTradeTransactionType;
    });
    exchangedDocumentContext: ExchangedDocumentContextType;
    exchangedDocument: ExchangedDocumentType;
    supplyChainTradeTransaction: SupplyChainTradeTransactionType;
}

export { AccountingAccountTypeCodeType, AdvancePaymentType, AllowanceChargeReasonCodeType, AmountType, BinaryObjectType, CodeType, ContactTypeCodeType, CountryIDType, CreditorFinancialAccountType, CreditorFinancialInstitutionType, CrossIndustryInvoiceType, CurrencyCodeType, DateTimeType, DateType, DebtorFinancialAccountType, DebtorFinancialInstitutionType, DeliveryTermsCodeType, DocumentCodeType, DocumentContextParameterType, DocumentLineDocumentType, ExchangedDocumentContextType, ExchangedDocumentType, FinancialAdjustmentType, FormattedDateTimeType, HeaderTradeAgreementType, HeaderTradeDeliveryType, HeaderTradeSettlementType, IDType, IndicatorType, LegalOrganizationType, LineStatusCodeType, LineTradeAgreementType, LineTradeDeliveryType, LineTradeSettlementType, LogisticsServiceChargeType, LogisticsTransportMovementType, MeasureType, NoteType, NumericType, PartyRoleCodeType, PaymentMeansCodeType, PercentType, ProcuringProjectType, ProductCharacteristicType, ProductClassificationType, QuantityType, RateType, ReferenceCodeType, ReferencedDocumentType, ReferencedProductType, SpecifiedPeriodType, SupplyChainConsignmentType, SupplyChainEventType, SupplyChainTradeLineItemType, SupplyChainTradeTransactionType, TaxCategoryCodeType, TaxRegistrationType, TaxTypeCodeType, TextType, TimeReferenceCodeType, TradeAccountingAccountType, TradeAddressType, TradeAllowanceChargeType, TradeContactType, TradeCountryType, TradeCurrencyExchangeType, TradeDeliveryTermsType, TradeLocationType, TradePartyType, TradePaymentDiscountTermsType, TradePaymentPenaltyTermsType, TradePaymentTermsType, TradePriceType, TradeProductInstanceType, TradeProductType, TradeSettlementFinancialCardType, TradeSettlementHeaderMonetarySummationType, TradeSettlementLineMonetarySummationType, TradeSettlementPaymentMeansType, TradeTaxType, TransportModeCodeType, UniversalCommunicationType };