Invoice Model¶

Core data types for building and inspecting invoices.

InvoiceBuilder¶

`new`¶

Create builder

Create a builder for a specific invoice type/subtype.

RustPythonC (FFI)

InvoiceBuilder::new(invoice_type: InvoiceType) -> InvoiceBuilder

InvoiceBuilder.new(invoice_type: InvoiceTypeKind, invoice_subtype: InvoiceSubType, original_invoice_id: Optional[str] = None, original_invoice_uuid: Optional[str] = None, original_invoice_issue_date: Optional[str] = None, original_invoice_reason: Optional[str] = None) -> InvoiceBuilder

FfiResult_FfiInvoiceBuilder fatoora_invoice_builder_new(FfiInvoiceTypeKind type_kind, FfiInvoiceSubType subtype, const char* original_id, const char* original_uuid, const char* original_issue_date, const char* original_reason);

`set_id`¶

Set invoice ID

RustPythonC (FFI)

InvoiceBuilder::set_id(id: impl Into<String>) -> &mut Self

InvoiceBuilder.set_id(invoice_id: str) -> None

FfiResult_bool fatoora_invoice_builder_set_id(FfiInvoiceBuilder* builder, const char* id);

`set_uuid`¶

Set invoice UUID

RustPythonC (FFI)

InvoiceBuilder::set_uuid(uuid: impl Into<String>) -> &mut Self

InvoiceBuilder.set_uuid(uuid: str) -> None

FfiResult_bool fatoora_invoice_builder_set_uuid(FfiInvoiceBuilder* builder, const char* uuid);

`set_issue_datetime`¶

Set issue datetime

RustPythonC (FFI)

InvoiceBuilder::set_issue_datetime(value: impl Into<String>) -> &mut Self

InvoiceBuilder.set_issue_datetime(issue_datetime: str) -> None

FfiResult_bool fatoora_invoice_builder_set_issue_datetime(FfiInvoiceBuilder* builder, const char* value);

`set_currency`¶

Set currency

RustPythonC (FFI)

InvoiceBuilder::set_currency(code: impl Into<String>) -> &mut Self

InvoiceBuilder.set_currency(currency_code: str) -> None

FfiResult_bool fatoora_invoice_builder_set_currency(FfiInvoiceBuilder* builder, const char* code);

`set_previous_invoice_hash`¶

Set previous invoice hash

RustPythonC (FFI)

InvoiceBuilder::set_previous_invoice_hash(hash: impl Into<String>) -> &mut Self

InvoiceBuilder.set_previous_invoice_hash(hash: str) -> None

FfiResult_bool fatoora_invoice_builder_set_previous_hash(FfiInvoiceBuilder* builder, const char* hash);

`set_invoice_counter`¶

Set invoice counter

RustPythonC (FFI)

InvoiceBuilder::set_invoice_counter(counter: u64) -> &mut Self

InvoiceBuilder.set_invoice_counter(counter: int) -> None

FfiResult_bool fatoora_invoice_builder_set_invoice_counter(FfiInvoiceBuilder* builder, uint64_t counter);

`set_payment_means_code`¶

Set payment means code

RustPythonC (FFI)

InvoiceBuilder::set_payment_means_code(code: impl Into<String>) -> &mut Self

InvoiceBuilder.set_payment_means_code(code: str) -> None

FfiResult_bool fatoora_invoice_builder_set_payment_means_code(FfiInvoiceBuilder* builder, const char* code);

`set_vat_category`¶

Set invoice VAT category

RustPythonC (FFI)

InvoiceBuilder::set_vat_category(category: VatCategory) -> &mut Self

InvoiceBuilder.set_vat_category(category: VatCategory) -> None

FfiResult_bool fatoora_invoice_builder_set_vat_category(FfiInvoiceBuilder* builder, FfiVatCategory cat);

`set_seller`¶

Set seller party

RustPythonC (FFI)

InvoiceBuilder::set_seller(seller: Seller) -> &mut Self

InvoiceBuilder.set_seller(...) -> None

FfiResult_bool fatoora_invoice_builder_set_seller(FfiInvoiceBuilder* builder, const char* name, const char* country, const char* city, const char* street, const char* additional_street, const char* building_number, const char* additional_number, const char* postal_code, const char* subdivision, const char* district, const char* vat_id, const char* other_id, const char* other_id_scheme);

`set_buyer`¶

Set buyer party

RustPythonC (FFI)

InvoiceBuilder::set_buyer(buyer: Buyer) -> &mut Self

InvoiceBuilder.set_buyer(...) -> None

FfiResult_bool fatoora_invoice_builder_set_buyer(FfiInvoiceBuilder* builder, const char* name, const char* country, const char* city, const char* street, const char* additional_street, const char* building_number, const char* additional_number, const char* postal_code, const char* subdivision, const char* district, const char* vat_id, const char* other_id, const char* other_id_scheme);

`set_note`¶

Set invoice note

RustPythonC (FFI)

InvoiceBuilder::set_note(note: InvoiceNote) -> &mut Self

InvoiceBuilder.set_note(language: str, text: str) -> None

FfiResult_bool fatoora_invoice_builder_set_note(FfiInvoiceBuilder* builder, const char* lang, const char* text);

`set_allowance`¶

Set allowance reason and amount

RustPythonC (FFI)

InvoiceBuilder::set_allowance(reason: impl Into<String>, amount: f64) -> &mut Self

InvoiceBuilder.set_allowance(reason: str, amount: float) -> None

FfiResult_bool fatoora_invoice_builder_set_allowance(FfiInvoiceBuilder* builder, const char* reason, double amount);

`invoice_level_charge`¶

Set invoice-level charge

RustPythonC (FFI)

InvoiceBuilder::invoice_level_charge(charge: f64) -> &mut Self

InvoiceBuilder.invoice_level_charge(charge: float) -> None

FfiResult_bool fatoora_invoice_builder_invoice_level_charge(FfiInvoiceBuilder* builder, double charge);

`invoice_level_discount`¶

Set invoice-level discount

RustPythonC (FFI)

InvoiceBuilder::invoice_level_discount(discount: f64) -> &mut Self

InvoiceBuilder.invoice_level_discount(discount: float) -> None

FfiResult_bool fatoora_invoice_builder_invoice_level_discount(FfiInvoiceBuilder* builder, double discount);

`allowance_reason`¶

Set allowance reason

RustPythonC (FFI)

InvoiceBuilder::allowance_reason(reason: impl Into<String>) -> &mut Self

InvoiceBuilder.allowance_reason(reason: str) -> None

FfiResult_bool fatoora_invoice_builder_allowance_reason(FfiInvoiceBuilder* builder, const char* reason);

`flags`¶

Set invoice flags

RustPythonC (FFI)

InvoiceBuilder::flags(flags: InvoiceFlags) -> &mut Self

InvoiceBuilder.flags(flags: int) -> None

FfiResult_bool fatoora_invoice_builder_flags(FfiInvoiceBuilder* builder, uint8_t flags);

`add_line_item`¶

Add line item

RustPythonC (FFI)

InvoiceBuilder::add_line_item(item: LineItem) -> &mut Self

InvoiceBuilder.add_line_item(description: str, quantity: float, unit_code: str, unit_price: float, vat_rate: float, vat_category: VatCategory) -> None

FfiResult_bool fatoora_invoice_builder_add_line_item(FfiInvoiceBuilder* builder, const char* description, double quantity, const char* unit_code, double unit_price, double vat_rate, FfiVatCategory vat_category);

`build`¶

Finalize invoice

RustPythonC (FFI)

InvoiceBuilder::build(self) -> Result<FinalizedInvoice, InvoiceError>

InvoiceBuilder.build() -> FinalizedInvoice

FfiResult_FfiFinalizedInvoice fatoora_invoice_builder_build(FfiInvoiceBuilder* builder);

Field Groups¶

`id`¶

Setter: InvoiceBuilder::set_id / InvoiceBuilder.set_id / fatoora_invoice_builder_set_id
Getters: FinalizedInvoice.id, SignedInvoice.id, fatoora_invoice_id, fatoora_signed_invoice_id

`uuid`¶

Setter: InvoiceBuilder::set_uuid / InvoiceBuilder.set_uuid / fatoora_invoice_builder_set_uuid
Getters: FinalizedInvoice.uuid, SignedInvoice.uuid, fatoora_invoice_uuid, fatoora_signed_invoice_uuid

`issue_datetime`¶

Setter: InvoiceBuilder::set_issue_datetime / InvoiceBuilder.set_issue_datetime / fatoora_invoice_builder_set_issue_datetime
Getters: FinalizedInvoice.issue_datetime, SignedInvoice.issue_datetime, fatoora_invoice_issue_datetime, fatoora_signed_invoice_issue_datetime

`currency`¶

Setter: InvoiceBuilder::set_currency / InvoiceBuilder.set_currency / fatoora_invoice_builder_set_currency
Getters: FinalizedInvoice.currency, SignedInvoice.currency, fatoora_invoice_currency, fatoora_signed_invoice_currency

`previous_invoice_hash`¶

Setter: InvoiceBuilder::set_previous_invoice_hash / InvoiceBuilder.set_previous_invoice_hash / fatoora_invoice_builder_set_previous_hash
Getters: FinalizedInvoice.previous_invoice_hash, SignedInvoice.previous_invoice_hash, fatoora_invoice_previous_hash, fatoora_signed_invoice_previous_hash

`invoice_counter`¶

Setter: InvoiceBuilder::set_invoice_counter / InvoiceBuilder.set_invoice_counter / fatoora_invoice_builder_set_invoice_counter
Getters: FinalizedInvoice.invoice_counter, SignedInvoice.invoice_counter, fatoora_invoice_counter, fatoora_signed_invoice_counter

`payment_means_code`¶

Setter: InvoiceBuilder::set_payment_means_code / InvoiceBuilder.set_payment_means_code / fatoora_invoice_builder_set_payment_means_code
Getters: FinalizedInvoice.payment_means_code, SignedInvoice.payment_means_code, fatoora_invoice_payment_means_code, fatoora_signed_invoice_payment_means_code

`vat_category`¶

Setter: InvoiceBuilder::set_vat_category / InvoiceBuilder.set_vat_category / fatoora_invoice_builder_set_vat_category
Getters: FinalizedInvoice.vat_category, SignedInvoice.vat_category, fatoora_invoice_vat_category, fatoora_signed_invoice_vat_category

Parties (`seller`, `buyer`)¶

Setters: InvoiceBuilder::set_seller, InvoiceBuilder::set_buyer and matching Python/C builder methods.
Getters: FinalizedInvoice.seller, FinalizedInvoice.buyer, SignedInvoice.seller, SignedInvoice.buyer, fatoora_invoice_seller, fatoora_invoice_buyer, fatoora_signed_invoice_seller, fatoora_signed_invoice_buyer

Notes and Allowance (`note`, `allowance_reason`, charge/discount)¶

Setters: set_note, set_allowance, invoice_level_charge, invoice_level_discount, allowance_reason and matching Python/C builder methods.
Getters: note, allowance_reason, invoice_level_charge, invoice_level_discount on finalized/signed invoices and matching fatoora_invoice_* and fatoora_signed_invoice_* getters.

Flags and Type¶

Setter: InvoiceBuilder::flags / InvoiceBuilder.flags / fatoora_invoice_builder_flags
Getters: flags, is_third_party, is_nominal, is_export, is_summary, is_self_billed, is_simplified, invoice_type_kind, invoice_sub_type on finalized/signed invoices and matching C getters.

Line Items and Totals¶

Setter: InvoiceBuilder::add_line_item / InvoiceBuilder.add_line_item / fatoora_invoice_builder_add_line_item
Getters: line_items, totals on finalized/signed invoices and matching C line-item/totals getters (fatoora_invoice_line_item_*, fatoora_invoice_totals_*, fatoora_signed_invoice_line_item_*, fatoora_signed_invoice_totals_*).

FinalizedInvoice¶

`hash_base64`¶

Get finalized invoice hash (Base64)

RustPythonC (FFI)

FinalizedInvoice::hash_base64(&self) -> Result<String, SigningError>

FinalizedInvoice.hash_base64() -> str

FfiResult_FfiString fatoora_invoice_hash_base64(FfiFinalizedInvoice* invoice);

`sign`¶

Sign finalized invoice

RustPythonC (FFI)

FinalizedInvoice::sign(self, signer: &InvoiceSigner) -> Result<SignedInvoice, SigningError>

FinalizedInvoice.sign(signer: Signer) -> SignedInvoice

FfiResult_FfiSignedInvoice fatoora_invoice_sign(FfiFinalizedInvoice* invoice, FfiSigner* signer);

field accessors¶

Read finalized invoice fields

Accessors for identity, parties, references, flags, line items, and totals are available per field in Python and C.

PythonC (FFI)

FinalizedInvoice.id() -> str
FinalizedInvoice.uuid() -> str
FinalizedInvoice.issue_datetime() -> str
FinalizedInvoice.currency() -> str
FinalizedInvoice.previous_invoice_hash() -> str
FinalizedInvoice.invoice_counter() -> int
FinalizedInvoice.payment_means_code() -> str
FinalizedInvoice.vat_category() -> VatCategory
FinalizedInvoice.invoice_level_charge() -> float
FinalizedInvoice.invoice_level_discount() -> float
FinalizedInvoice.allowance_reason() -> Optional[str]
FinalizedInvoice.invoice_type_kind() -> InvoiceTypeKind
FinalizedInvoice.invoice_sub_type() -> InvoiceSubType
FinalizedInvoice.original_invoice_ref() -> Optional[OriginalInvoiceRef]
FinalizedInvoice.original_invoice_reason() -> Optional[str]
FinalizedInvoice.seller() -> Party
FinalizedInvoice.buyer() -> Optional[Party]
FinalizedInvoice.note() -> Optional[InvoiceNote]
FinalizedInvoice.line_items() -> list[InvoiceLineItem]
FinalizedInvoice.totals() -> InvoiceTotals
FinalizedInvoice.flags() -> set[InvoiceFlag]
FinalizedInvoice.is_third_party() -> bool
FinalizedInvoice.is_nominal() -> bool
FinalizedInvoice.is_export() -> bool
FinalizedInvoice.is_summary() -> bool
FinalizedInvoice.is_self_billed() -> bool
FinalizedInvoice.is_simplified() -> bool
FinalizedInvoice.xml() -> str

/* field-level getters: fatoora_invoice_* */
FfiResult_FfiString fatoora_invoice_id(FfiFinalizedInvoice* invoice);
FfiResult_FfiString fatoora_invoice_uuid(FfiFinalizedInvoice* invoice);
FfiResult_FfiString fatoora_invoice_to_xml(FfiFinalizedInvoice* invoice);
FfiResult_u64 fatoora_invoice_line_item_count(FfiFinalizedInvoice* invoice);
FfiResult_f64 fatoora_invoice_totals_tax_inclusive(FfiFinalizedInvoice* invoice);
/* plus remaining fatoora_invoice_* accessors */

SignedInvoice¶

`xml`¶

Get signed invoice XML

RustPythonC (FFI)

SignedInvoice::xml(&self) -> &str

SignedInvoice.xml() -> str

FfiResult_FfiString fatoora_signed_invoice_xml(FfiSignedInvoice* signed);

`to_xml_base64`¶

Get signed XML as Base64

RustPythonC (FFI)

SignedInvoice::to_xml_base64(&self) -> String

SignedInvoice.to_xml_base64() -> str

FfiResult_FfiString fatoora_signed_invoice_to_xml_base64(FfiSignedInvoice* signed);

`hash_base64`¶

Get signed invoice hash (Base64)

RustPythonC (FFI)

SignedInvoice::hash_base64(&self) -> Result<String, SigningError>

SignedInvoice.hash_base64() -> str

FfiResult_FfiString fatoora_signed_invoice_hash_base64(FfiSignedInvoice* signed);

signature metadata accessors¶

Read signature metadata

RustPythonC (FFI)

SignedInvoice::invoice_hash(&self) -> &str
SignedInvoice::signature(&self) -> &str
SignedInvoice::public_key(&self) -> &str
SignedInvoice::zatca_key_signature(&self) -> Option<&str>
SignedProperties::issuer(&self) -> &str
SignedProperties::serial(&self) -> &str

SignedInvoice.invoice_hash() -> str
SignedInvoice.signature() -> str
SignedInvoice.public_key() -> str
SignedInvoice.zatca_key_signature() -> Optional[str]
SignedInvoice.cert_hash() -> str
SignedInvoice.signed_props_hash() -> str
SignedInvoice.signing_time() -> str
SignedInvoice.issuer() -> str
SignedInvoice.serial() -> str

FfiResult_FfiString fatoora_signed_invoice_hash(FfiSignedInvoice* signed);
FfiResult_FfiString fatoora_signed_invoice_signature(FfiSignedInvoice* signed);
FfiResult_FfiString fatoora_signed_invoice_public_key(FfiSignedInvoice* signed);
FfiResult_FfiString fatoora_signed_invoice_zatca_key_signature(FfiSignedInvoice* signed);
FfiResult_FfiString fatoora_signed_invoice_cert_hash(FfiSignedInvoice* signed);
FfiResult_FfiString fatoora_signed_invoice_signed_props_hash(FfiSignedInvoice* signed);
FfiResult_FfiString fatoora_signed_invoice_signing_time(FfiSignedInvoice* signed);
FfiResult_FfiString fatoora_signed_invoice_issuer(FfiSignedInvoice* signed);
FfiResult_FfiString fatoora_signed_invoice_serial(FfiSignedInvoice* signed);

`Address.new`¶

Create address value

PythonC (FFI)

Address.new(
    country_code: str,
    city: str,
    street: str,
    building_number: str,
    postal_code: str,
    additional_street: Optional[str] = None,
    additional_number: Optional[str] = None,
    subdivision: Optional[str] = None,
    district: Optional[str] = None,
) -> Address

FfiResult_FfiAddress fatoora_address_new(
    const char* country_code,
    const char* city,
    const char* street,
    const char* additional_street,
    const char* building_number,
    const char* additional_number,
    const char* postal_code,
    const char* subdivision,
    const char* district
);

field accessors¶

Read signed invoice data fields

Signed invoices expose the same business-field accessors as finalized invoices, plus signature metadata.

PythonC (FFI)

SignedInvoice.id() -> str
SignedInvoice.uuid() -> str
SignedInvoice.issue_datetime() -> str
SignedInvoice.currency() -> str
SignedInvoice.previous_invoice_hash() -> str
SignedInvoice.invoice_counter() -> int
SignedInvoice.payment_means_code() -> str
SignedInvoice.vat_category() -> VatCategory
SignedInvoice.invoice_level_charge() -> float
SignedInvoice.invoice_level_discount() -> float
SignedInvoice.allowance_reason() -> Optional[str]
SignedInvoice.invoice_type_kind() -> InvoiceTypeKind
SignedInvoice.invoice_sub_type() -> InvoiceSubType
SignedInvoice.original_invoice_ref() -> Optional[OriginalInvoiceRef]
SignedInvoice.original_invoice_reason() -> Optional[str]
SignedInvoice.seller() -> Party
SignedInvoice.buyer() -> Optional[Party]
SignedInvoice.note() -> Optional[InvoiceNote]
SignedInvoice.line_items() -> list[InvoiceLineItem]
SignedInvoice.totals() -> InvoiceTotals
SignedInvoice.flags() -> set[InvoiceFlag]
SignedInvoice.is_third_party() -> bool
SignedInvoice.is_nominal() -> bool
SignedInvoice.is_export() -> bool
SignedInvoice.is_summary() -> bool
SignedInvoice.is_self_billed() -> bool
SignedInvoice.is_simplified() -> bool

/* field-level getters: fatoora_signed_invoice_* */
FfiResult_FfiString fatoora_signed_invoice_id(FfiSignedInvoice* signed);
FfiResult_FfiString fatoora_signed_invoice_uuid(FfiSignedInvoice* signed);
FfiResult_u64 fatoora_signed_invoice_line_item_count(FfiSignedInvoice* signed);
FfiResult_f64 fatoora_signed_invoice_totals_tax_inclusive(FfiSignedInvoice* signed);
/* plus remaining fatoora_signed_invoice_* accessors */

Supporting Types¶

Types

CountryCode, CurrencyCode, InvoiceTimestamp, InvoiceDate, VatId, OtherId.
InvoiceNote, OriginalInvoiceRef, LineItem, Party (Seller/Buyer roles).

Invoice Model¶

InvoiceBuilder¶

new¶

set_id¶

set_uuid¶

set_issue_datetime¶

set_currency¶

set_previous_invoice_hash¶

set_invoice_counter¶

set_payment_means_code¶

set_vat_category¶

set_seller¶

set_buyer¶

set_note¶

set_allowance¶

invoice_level_charge¶

invoice_level_discount¶

allowance_reason¶

flags¶

add_line_item¶

build¶

Field Groups¶

id¶

uuid¶

issue_datetime¶

currency¶

previous_invoice_hash¶

invoice_counter¶

payment_means_code¶

vat_category¶

Parties (seller, buyer)¶

Notes and Allowance (note, allowance_reason, charge/discount)¶

Flags and Type¶

Line Items and Totals¶

FinalizedInvoice¶

hash_base64¶

sign¶

field accessors¶

SignedInvoice¶

xml¶

to_xml_base64¶

hash_base64¶

signature metadata accessors¶

Address.new¶

field accessors¶

Supporting Types¶

`new`¶

`set_id`¶

`set_uuid`¶

`set_issue_datetime`¶

`set_currency`¶

`set_previous_invoice_hash`¶

`set_invoice_counter`¶

`set_payment_means_code`¶

`set_vat_category`¶

`set_seller`¶

`set_buyer`¶

`set_note`¶

`set_allowance`¶

`invoice_level_charge`¶

`invoice_level_discount`¶

`allowance_reason`¶

`flags`¶

`add_line_item`¶

`build`¶

`id`¶

`uuid`¶

`issue_datetime`¶

`currency`¶

`previous_invoice_hash`¶

`invoice_counter`¶

`payment_means_code`¶

`vat_category`¶

Parties (`seller`, `buyer`)¶

Notes and Allowance (`note`, `allowance_reason`, charge/discount)¶

`hash_base64`¶

`sign`¶

`xml`¶

`to_xml_base64`¶

`hash_base64`¶

`Address.new`¶