/**
 * QualifiedDataType classes for Factur-X
 * Based on urn:un:unece:uncefact:data:standard:QualifiedDataType:100
 */
/**
 * Accounting account type code content
 */
declare class AccountingAccountTypeCodeType {
    constructor({ value }: {
        value: string;
    });
    value: string;
}
/**
 * Allowance charge reason code
 */
declare class AllowanceChargeReasonCodeType {
    constructor({ value }: {
        value: string;
    });
    value: string;
}
/**
 * Contact type code
 */
declare class ContactTypeCodeType {
    constructor({ value }: {
        value: string;
    });
    value: string;
}
/**
 * Country ID code
 */
declare class CountryIDType {
    constructor({ value }: {
        value: string;
    });
    value: string;
}
/**
 * Currency code
 */
declare class CurrencyCodeType {
    constructor({ value }: {
        value: string;
    });
    value: string;
}
/**
 * Delivery terms code
 */
declare class DeliveryTermsCodeType {
    constructor({ value }: {
        value: string;
    });
    value: string;
}
/**
 * Document code
 */
declare class DocumentCodeType {
    constructor({ value }: {
        value: string;
    });
    value: string;
}
/**
 * Formatted date time type
 */
declare class FormattedDateTimeType {
    constructor({ dateTimeString, format }: {
        dateTimeString: string;
        format: string;
    });
    dateTimeString: string;
    format: string;
}
/**
 * Line status code
 */
declare class LineStatusCodeType {
    constructor({ value }: {
        value: string;
    });
    value: string;
}
/**
 * Party role code
 */
declare class PartyRoleCodeType {
    constructor({ value }: {
        value: string;
    });
    value: string;
}
/**
 * Payment means code
 */
declare class PaymentMeansCodeType {
    constructor({ value }: {
        value: string;
    });
    value: string;
}
/**
 * Reference code
 */
declare class ReferenceCodeType {
    constructor({ value }: {
        value: string;
    });
    value: string;
}
/**
 * Tax category code
 */
declare class TaxCategoryCodeType {
    constructor({ value }: {
        value: string;
    });
    value: string;
}
/**
 * Tax type code
 */
declare class TaxTypeCodeType {
    constructor({ value }: {
        value: string;
    });
    value: string;
}
/**
 * Time reference code
 */
declare class TimeReferenceCodeType {
    constructor({ value }: {
        value: string;
    });
    value: string;
}
/**
 * Transport mode code
 */
declare class TransportModeCodeType {
    constructor({ value }: {
        value: string;
    });
    value: string;
}

/**
 * UnqualifiedDataType classes for Factur-X
 * Based on urn:un:unece:uncefact:data:standard:UnqualifiedDataType:100
 */
/**
 * Represents a monetary amount with optional currency
 */
declare class AmountType {
    constructor({ value, currencyID }: {
        value: number;
        currencyID?: string;
    });
    value: number;
    currencyID?: string;
}
/**
 * Represents binary data with required MIME type and filename
 */
declare class BinaryObjectType {
    constructor({ value, mimeCode, filename }: {
        value: string;
        mimeCode: string;
        filename: string;
    });
    value: string;
    mimeCode: string;
    filename: string;
}
/**
 * Represents a code with optional list identification
 */
declare class CodeType {
    constructor({ value, listID, listVersionID }: {
        value: string;
        listID?: string;
        listVersionID?: string;
    });
    value: string;
    listID?: string;
    listVersionID?: string;
}
/**
 * Represents a datetime with format
 */
declare class DateTimeType {
    constructor({ dateTimeString, format }: {
        dateTimeString: string;
        format: string;
    });
    dateTimeString: string;
    format: string;
}
/**
 * Represents a date with format
 */
declare class DateType {
    constructor({ dateString, format }: {
        dateString: string;
        format: string;
    });
    dateString: string;
    format: string;
}
/**
 * Represents an identifier with optional scheme
 */
declare class IDType {
    constructor({ value, schemeID }: {
        value: string;
        schemeID?: string;
    });
    value: string;
    schemeID?: string;
}
/**
 * Represents a boolean indicator
 */
declare class IndicatorType {
    constructor({ indicator }: {
        indicator: boolean;
    });
    indicator: boolean;
}
/**
 * Represents a measure with optional unit code
 */
declare class MeasureType {
    constructor({ value, unitCode }: {
        value: number;
        unitCode?: string;
    });
    value: number;
    unitCode?: string;
}
/**
 * Represents a numeric value
 */
declare class NumericType {
    constructor({ value }: {
        value: number;
    });
    value: number;
}
/**
 * Represents a percentage value
 */
declare class PercentType {
    constructor({ value }: {
        value: number;
    });
    value: number;
}
/**
 * Represents a quantity with optional unit code
 */
declare class QuantityType {
    constructor({ value, unitCode }: {
        value: number;
        unitCode?: string;
    });
    value: number;
    unitCode?: string;
}
/**
 * Represents a rate value
 */
declare class RateType {
    constructor({ value }: {
        value: number;
    });
    value: number;
}
/**
 * Represents text content
 */
declare class TextType {
    constructor({ value }: {
        value: string;
    });
    value: string;
}

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

/**
 * Specified period type
 */
declare class SpecifiedPeriodType {
    constructor({ description, startDateTime, endDateTime, completeDateTime, }: {
        description?: TextType;
        startDateTime?: DateTimeType;
        endDateTime?: DateTimeType;
        completeDateTime?: DateTimeType;
    });
    description?: TextType;
    startDateTime?: DateTimeType;
    endDateTime?: DateTimeType;
    completeDateTime?: DateTimeType;
}
/**
 * Referenced document type
 */
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;
}
/**
 * Trade delivery terms type
 */
declare class TradeDeliveryTermsType {
    constructor({ deliveryTypeCode, }: {
        deliveryTypeCode: DeliveryTermsCodeType;
    });
    deliveryTypeCode: DeliveryTermsCodeType;
}
/**
 * Procuring project type
 */
declare class ProcuringProjectType {
    constructor({ id, name, }: {
        id: IDType;
        name: TextType;
    });
    id: IDType;
    name: TextType;
}
/**
 * Advance payment type
 */
declare class AdvancePaymentType {
    constructor({ paidAmount, formattedReceivedDateTime, includedTradeTax, }: {
        paidAmount: AmountType;
        formattedReceivedDateTime?: FormattedDateTimeType;
        includedTradeTax: TradeTaxType[];
    });
    paidAmount: AmountType;
    formattedReceivedDateTime?: FormattedDateTimeType;
    includedTradeTax: TradeTaxType[];
}
/**
 * Creditor financial account type
 */
declare class CreditorFinancialAccountType {
    constructor({ ibanID, accountName, proprietaryID, }: {
        ibanID?: IDType;
        accountName?: TextType;
        proprietaryID?: IDType;
    });
    ibanID?: IDType;
    accountName?: TextType;
    proprietaryID?: IDType;
}
/**
 * Creditor financial institution type
 */
declare class CreditorFinancialInstitutionType {
    constructor({ bicID }: {
        bicID: IDType;
    });
    bicID: IDType;
}
/**
 * Debtor financial account type
 */
declare class DebtorFinancialAccountType {
    constructor({ ibanID }: {
        ibanID: IDType;
    });
    ibanID: IDType;
}
/**
 * Document context parameter type
 */
declare class DocumentContextParameterType {
    constructor({ id }: {
        id: IDType;
    });
    id: IDType;
}
/**
 * Note type
 */
declare class NoteType {
    constructor({ contentCode, content, subjectCode, }: {
        contentCode?: CodeType;
        content: TextType;
        subjectCode?: CodeType;
    });
    contentCode?: CodeType;
    content: TextType;
    subjectCode?: CodeType;
}
/**
 * Document line document type
 */
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[];
}
/**
 * Trade tax type
 */
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;
}
/**
 * Trade address type
 */
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[];
}
/**
 * Universal communication type
 */
declare class UniversalCommunicationType {
    constructor({ uriID, completeNumber, }: {
        uriID?: IDType;
        completeNumber?: TextType;
    });
    uriID?: IDType;
    completeNumber?: TextType;
}
/**
 * Trade contact type
 */
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;
}
/**
 * Legal organization type
 */
declare class LegalOrganizationType {
    constructor({ id, tradingBusinessName, postalTradeAddress, }: {
        id?: IDType;
        tradingBusinessName?: TextType;
        postalTradeAddress?: TradeAddressType;
    });
    id?: IDType;
    tradingBusinessName?: TextType;
    postalTradeAddress?: TradeAddressType;
}
/**
 * Tax registration type
 */
declare class TaxRegistrationType {
    constructor({ id }: {
        id: IDType;
    });
    id: IDType;
}
/**
 * Trade party type
 */
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[];
}
/**
 * Supply chain event type
 */
declare class SupplyChainEventType {
    constructor({ occurrenceDateTime, }: {
        occurrenceDateTime: DateTimeType;
    });
    occurrenceDateTime: DateTimeType;
}
/**
 * Supply chain consignment type
 */
declare class SupplyChainConsignmentType {
    constructor({ specifiedLogisticsTransportMovement, }: {
        specifiedLogisticsTransportMovement?: LogisticsTransportMovementType[];
    });
    specifiedLogisticsTransportMovement?: LogisticsTransportMovementType[];
}
/**
 * Logistics transport movement type
 */
declare class LogisticsTransportMovementType {
    constructor({ modeCode, }: {
        modeCode: TransportModeCodeType;
    });
    modeCode: TransportModeCodeType;
}
/**
 * Trade accounting account type
 */
declare class TradeAccountingAccountType {
    constructor({ id, typeCode, }: {
        id: IDType;
        typeCode?: AccountingAccountTypeCodeType;
    });
    id: IDType;
    typeCode?: AccountingAccountTypeCodeType;
}
/**
 * Trade currency exchange type
 */
declare class TradeCurrencyExchangeType {
    constructor({ sourceCurrencyCode, targetCurrencyCode, conversionRate, conversionRateDateTime, }: {
        sourceCurrencyCode: CurrencyCodeType;
        targetCurrencyCode: CurrencyCodeType;
        conversionRate: RateType;
        conversionRateDateTime?: DateTimeType;
    });
    sourceCurrencyCode: CurrencyCodeType;
    targetCurrencyCode: CurrencyCodeType;
    conversionRate: RateType;
    conversionRateDateTime?: DateTimeType;
}
/**
 * Trade allowance charge type
 */
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;
}
/**
 * Logistics service charge type
 */
declare class LogisticsServiceChargeType {
    constructor({ description, appliedAmount, appliedTradeTax, }: {
        description: TextType;
        appliedAmount: AmountType;
        appliedTradeTax?: TradeTaxType[];
    });
    description: TextType;
    appliedAmount: AmountType;
    appliedTradeTax?: TradeTaxType[];
}
/**
 * Trade payment penalty terms type
 */
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;
}
/**
 * Trade payment discount terms type
 */
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;
}
/**
 * Trade payment terms type
 */
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;
}
/**
 * Trade settlement financial card type
 */
declare class TradeSettlementFinancialCardType {
    constructor({ id, cardholderName, }: {
        id: IDType;
        cardholderName?: TextType;
    });
    id: IDType;
    cardholderName?: TextType;
}
/**
 * Trade settlement payment means type
 */
declare class TradeSettlementPaymentMeansType {
    constructor({ typeCode, information, applicableTradeSettlementFinancialCard, payerPartyDebtorFinancialAccount, payeePartyCreditorFinancialAccount, payeeSpecifiedCreditorFinancialInstitution, }: {
        typeCode: PaymentMeansCodeType;
        information?: TextType;
        applicableTradeSettlementFinancialCard?: TradeSettlementFinancialCardType;
        payerPartyDebtorFinancialAccount?: DebtorFinancialAccountType;
        payeePartyCreditorFinancialAccount?: CreditorFinancialAccountType;
        payeeSpecifiedCreditorFinancialInstitution?: CreditorFinancialInstitutionType;
    });
    typeCode: PaymentMeansCodeType;
    information?: TextType;
    applicableTradeSettlementFinancialCard?: TradeSettlementFinancialCardType;
    payerPartyDebtorFinancialAccount?: DebtorFinancialAccountType;
    payeePartyCreditorFinancialAccount?: CreditorFinancialAccountType;
    payeeSpecifiedCreditorFinancialInstitution?: CreditorFinancialInstitutionType;
}
/**
 * Trade settlement header monetary summation type
 */
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;
}
/**
 * Product characteristic type
 */
declare class ProductCharacteristicType {
    constructor({ typeCode, description, valueMeasure, value, }: {
        typeCode?: CodeType;
        description: TextType;
        valueMeasure?: MeasureType;
        value: TextType;
    });
    typeCode?: CodeType;
    description: TextType;
    valueMeasure?: MeasureType;
    value: TextType;
}
/**
 * Product classification type
 */
declare class ProductClassificationType {
    constructor({ classCode, className, }: {
        classCode?: CodeType;
        className?: TextType;
    });
    classCode?: CodeType;
    className?: TextType;
}
/**
 * Trade product instance type
 */
declare class TradeProductInstanceType {
    constructor({ batchID, supplierAssignedSerialID, }: {
        batchID?: IDType;
        supplierAssignedSerialID?: IDType;
    });
    batchID?: IDType;
    supplierAssignedSerialID?: IDType;
}
/**
 * Trade country type
 */
declare class TradeCountryType {
    constructor({ id, }: {
        id?: CountryIDType;
    });
    id?: CountryIDType;
}
/**
 * Referenced product type
 */
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;
}
/**
 * Trade product type
 */
declare class TradeProductType {
    constructor({ id, globalID, sellerAssignedID, buyerAssignedID, name, description, applicableProductCharacteristic, designatedProductClassification, individualTradeProductInstance, originTradeCountry, includedReferencedProduct, }: {
        id?: IDType;
        globalID?: IDType;
        sellerAssignedID?: IDType;
        buyerAssignedID?: IDType;
        name: TextType;
        description?: TextType;
        applicableProductCharacteristic?: ProductCharacteristicType[];
        designatedProductClassification?: ProductClassificationType[];
        individualTradeProductInstance?: TradeProductInstanceType[];
        originTradeCountry?: TradeCountryType;
        includedReferencedProduct?: ReferencedProductType[];
    });
    id?: IDType;
    globalID?: IDType;
    sellerAssignedID?: IDType;
    buyerAssignedID?: IDType;
    name: TextType;
    description?: TextType;
    applicableProductCharacteristic?: ProductCharacteristicType[];
    designatedProductClassification?: ProductClassificationType[];
    individualTradeProductInstance?: TradeProductInstanceType[];
    originTradeCountry?: TradeCountryType;
    includedReferencedProduct?: ReferencedProductType[];
}
/**
 * Trade price type
 */
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 trade agreement type
 */
declare class LineTradeAgreementType {
    constructor({ buyerOrderReferencedDocument, quotationReferencedDocument, contractReferencedDocument, additionalReferencedDocument, grossPriceProductTradePrice, netPriceProductTradePrice, ultimateCustomerOrderReferencedDocument, }: {
        buyerOrderReferencedDocument?: ReferencedDocumentType;
        quotationReferencedDocument?: ReferencedDocumentType;
        contractReferencedDocument?: ReferencedDocumentType;
        additionalReferencedDocument?: ReferencedDocumentType[];
        grossPriceProductTradePrice?: TradePriceType;
        netPriceProductTradePrice: TradePriceType;
        ultimateCustomerOrderReferencedDocument?: ReferencedDocumentType[];
    });
    buyerOrderReferencedDocument?: ReferencedDocumentType;
    quotationReferencedDocument?: ReferencedDocumentType;
    contractReferencedDocument?: ReferencedDocumentType;
    additionalReferencedDocument?: ReferencedDocumentType[];
    grossPriceProductTradePrice?: TradePriceType;
    netPriceProductTradePrice: TradePriceType;
    ultimateCustomerOrderReferencedDocument?: ReferencedDocumentType[];
}
/**
 * Line trade delivery type
 */
declare class LineTradeDeliveryType {
    constructor({ billedQuantity, chargeFreeQuantity, packageQuantity, shipToTradeParty, ultimateShipToTradeParty, actualDeliverySupplyChainEvent, despatchAdviceReferencedDocument, receivingAdviceReferencedDocument, deliveryNoteReferencedDocument, }: {
        billedQuantity: QuantityType;
        chargeFreeQuantity?: QuantityType;
        packageQuantity?: QuantityType;
        shipToTradeParty?: TradePartyType;
        ultimateShipToTradeParty?: TradePartyType;
        actualDeliverySupplyChainEvent?: SupplyChainEventType;
        despatchAdviceReferencedDocument?: ReferencedDocumentType;
        receivingAdviceReferencedDocument?: ReferencedDocumentType;
        deliveryNoteReferencedDocument?: ReferencedDocumentType;
    });
    billedQuantity: QuantityType;
    chargeFreeQuantity?: QuantityType;
    packageQuantity?: QuantityType;
    shipToTradeParty?: TradePartyType;
    ultimateShipToTradeParty?: TradePartyType;
    actualDeliverySupplyChainEvent?: SupplyChainEventType;
    despatchAdviceReferencedDocument?: ReferencedDocumentType;
    receivingAdviceReferencedDocument?: ReferencedDocumentType;
    deliveryNoteReferencedDocument?: ReferencedDocumentType;
}
/**
 * Trade settlement line monetary summation type
 */
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 trade settlement type
 */
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;
}
/**
 * Supply chain trade line item type
 */
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
 */

/**
 * Exchanged document context type
 */
declare class ExchangedDocumentContextType {
    constructor({ testIndicator, businessProcessSpecifiedDocumentContextParameter, guidelineSpecifiedDocumentContextParameter, }: {
        testIndicator?: IndicatorType;
        businessProcessSpecifiedDocumentContextParameter?: DocumentContextParameterType;
        guidelineSpecifiedDocumentContextParameter: DocumentContextParameterType;
    });
    testIndicator?: IndicatorType;
    businessProcessSpecifiedDocumentContextParameter?: DocumentContextParameterType;
    guidelineSpecifiedDocumentContextParameter: DocumentContextParameterType;
}
/**
 * Exchanged document type
 */
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;
}
/**
 * Header trade agreement type
 */
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[];
}
/**
 * Header trade delivery type
 */
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;
}
/**
 * Header trade settlement type
 */
declare class HeaderTradeSettlementType {
    constructor({ creditorReferenceID, paymentReference, taxCurrencyCode, invoiceCurrencyCode, invoiceIssuerReference, invoicerTradeParty, invoiceeTradeParty, payeeTradeParty, payerTradeParty, taxApplicableTradeCurrencyExchange, specifiedTradeSettlementPaymentMeans, applicableTradeTax, billingSpecifiedPeriod, specifiedTradeAllowanceCharge, specifiedLogisticsServiceCharge, specifiedTradePaymentTerms, specifiedTradeSettlementHeaderMonetarySummation, 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;
        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;
    invoiceReferencedDocument?: ReferencedDocumentType;
    receivableSpecifiedTradeAccountingAccount?: TradeAccountingAccountType[];
    specifiedAdvancePayment?: AdvancePaymentType[];
}
/**
 * Supply chain trade transaction type
 */
declare class SupplyChainTradeTransactionType {
    constructor({ includedSupplyChainTradeLineItem, applicableHeaderTradeAgreement, applicableHeaderTradeDelivery, applicableHeaderTradeSettlement, }: {
        includedSupplyChainTradeLineItem?: SupplyChainTradeLineItemType[];
        applicableHeaderTradeAgreement: HeaderTradeAgreementType;
        applicableHeaderTradeDelivery: HeaderTradeDeliveryType;
        applicableHeaderTradeSettlement: HeaderTradeSettlementType;
    });
    includedSupplyChainTradeLineItem?: SupplyChainTradeLineItemType[];
    applicableHeaderTradeAgreement: HeaderTradeAgreementType;
    applicableHeaderTradeDelivery: HeaderTradeDeliveryType;
    applicableHeaderTradeSettlement: HeaderTradeSettlementType;
}
/**
 * Cross industry invoice type - the main class for Factur-X
 */
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, DeliveryTermsCodeType, DocumentCodeType, DocumentContextParameterType, DocumentLineDocumentType, ExchangedDocumentContextType, ExchangedDocumentType, 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, TradePartyType, TradePaymentDiscountTermsType, TradePaymentPenaltyTermsType, TradePaymentTermsType, TradePriceType, TradeProductInstanceType, TradeProductType, TradeSettlementFinancialCardType, TradeSettlementHeaderMonetarySummationType, TradeSettlementLineMonetarySummationType, TradeSettlementPaymentMeansType, TradeTaxType, TransportModeCodeType, UniversalCommunicationType };