@opencxh/domain 1.243.0 → 1.245.0

package/dist/entities/document-template/sender.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/entities/document-template/tokens.d.ts

@@ -9,8 +9,15 @@ export interface FillResult {
     /** Paths that resolved to nothing, in the order they appeared. Deduplicated. */
     unresolved: string[];
 }
-/** One string, filled in. */
-export declare function fillText(text: string, context: TemplateContext): FillResult;
+/**
+ * One string, filled in.
+ *
+ * `missing` is what an unresolved token becomes. Left out, the token itself stays — the raw
+ * form, which a template editor needs to see. A reader does not: `{customer.address}` looks
+ * like a bug, where "[nog niet bekend]" says what it is. Either way the path is *reported*, so
+ * the issue gate judges the same document whichever form was asked for.
+ */
+export declare function fillText(text: string, context: TemplateContext, missing?: string): FillResult;
 /** Does this block appear? A block with no condition always does. */
 export declare function conditionHolds(condition: TemplateCondition | undefined, context: TemplateContext): boolean;
 export interface FillDocumentResult {
@@ -36,4 +43,6 @@ export type DocumentSlots = Record<string, readonly DocumentBlock[]>;
  * value is the ordinary case for an invoice, and missing one would leave `{invoice.number}`
  * printed on a document that went out the door.
  */
-export declare function fillDocument(blocks: readonly DocumentBlock[], context: TemplateContext, conditions?: Record<string, TemplateCondition>, slots?: DocumentSlots): FillDocumentResult;
+export declare function fillDocument(blocks: readonly DocumentBlock[], context: TemplateContext, conditions?: Record<string, TemplateCondition>, slots?: DocumentSlots, 
+/** What an unresolved token reads as. See {@link fillText}. */
+missing?: string): FillDocumentResult;

package/dist/entities/document-template/types.d.ts

@@ -1,4 +1,5 @@
 import { DocumentBlock } from '../../platform/document-blocks';
+import { PostalAddress } from '../organization/types';
 /**
  * A document template: the blocks a generated document is built from.
  *
@@ -85,3 +86,44 @@ export interface OrganizationHouseStyle {
      */
     iban?: string;
 }
+/**
+ * The sender, as a document shows it: the organisation's own details, already turned into lines.
+ *
+ * Drawn **around** a document rather than written into it — the reason `DocumentBlock` has no
+ * sender block. It is computed on the server so the print, the preview and whatever mails a PDF
+ * one day all show the same letterhead, and so the renderer needs to know nothing about
+ * `Organization`.
+ */
+export interface DocumentSender {
+    name: string;
+    /** Street, postcode + city, country — only the lines that exist. */
+    addressLines: string[];
+    /** KvK, VAT, IBAN, plus the organisation's own footer sentence. Only what is filled in. */
+    footerLines: string[];
+    /** Inline data-URI; there is no publicly readable URL for an uploaded file. */
+    logo?: string;
+}
+/**
+ * An organisation's details as a letterhead.
+ *
+ * Every field is optional on `Organization`, so every line here is conditional: a half-filled
+ * organisation gets a short letterhead, never `undefined, undefined`. The billing name wins over
+ * the display name — what is on a quote is the legal entity.
+ */
+export declare function organizationSender(organization: OrganizationLike | null | undefined): DocumentSender;
+/**
+ * What {@link organizationSender} reads. Structural rather than `Organization` itself, so this
+ * file keeps pointing at the organisation entity instead of the other way round.
+ */
+export interface OrganizationLike {
+    name?: string;
+    displayName?: string;
+    logo?: string;
+    address?: PostalAddress;
+    billing?: {
+        companyName?: string;
+        vatNumber?: string;
+        kvkNumber?: string;
+    };
+    houseStyle?: OrganizationHouseStyle;
+}

package/dist/entities/money/totals.d.ts

@@ -30,5 +30,8 @@ export interface PricedTransaction {
  *
  * `overrideKey` is the "reverse charge / exempt" tick on the transaction: it replaces every line's
  * rate, because that is a property of the sale and not of the product.
+ *
+ * An **optional** line is priced like any other and then left out of every sum — see
+ * `TransactionLine.optional`.
  */
 export declare function transactionTotals(lines: readonly TransactionLine[], rates: readonly TaxRate[], overrideKey?: string): PricedTransaction;

package/dist/entities/transaction/document.d.ts

@@ -49,6 +49,8 @@ export declare function transactionContext(transaction: Transaction, sources?: T
 export declare function transactionSlots(transaction: Transaction, rates?: readonly TaxRate[], labels?: SlotLabels): DocumentSlots;
 export interface SlotLabels {
     description: string;
+    /** Marks a line that is priced but not counted. */
+    optional: string;
     quantity: string;
     unitPrice: string;
     net: string;

package/dist/entities/transaction/types.d.ts

@@ -110,6 +110,23 @@ export interface TransactionLine {
     costPriceCents?: Cents;
     /** The mapping axis onto a chart of accounts, copied from the product's category. */
     ledgerCategoryKey?: string;
+    /**
+     * The work item this line is for. Same referent as {@link Transaction.dealItemId}, one level
+     * down: a quote may cover one deal while its lines belong to different items under it.
+     *
+     * An id and never a copied title — whoever owns the item renames it, and a name stored here
+     * would be stale the same afternoon. Not printed on the document; it is what the work is
+     * booked against, not what the customer reads.
+     */
+    dealItemId?: string;
+    /**
+     * An option: priced and shown, but **not** in the total.
+     *
+     * The amount still stands on the line — the customer has to be able to read what the option
+     * costs — so this is a flag on the line and not a second list. Accepting an option is a new
+     * version of the quote with the flag off, the same way every other change to a sent quote is.
+     */
+    optional?: boolean;
 }
 export interface TransactionTotals {
     netCents: Cents;