@opencxh/domain 1.297.0 → 1.301.0

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

@@ -63,11 +63,10 @@ export interface Commitment {
 }
 /** A price fixed on the line when it was agreed, instead of the ladder at billing time. */
 export interface LinePrice {
+    /** Per the line's `unitKey`. */
     cents: Cents;
     currency: string;
     per?: PricePer;
-    /** The unit the price is for, when it is not the product's (a supplier's box of 10). */
-    unit?: string;
 }
 export type AgreementInterval = "month" | "quarter" | "year";
 export interface AgreementLine {
@@ -75,6 +74,10 @@ export interface AgreementLine {
     productId: string;
     /** Copied from the product, like a transaction line: the agreement must stay readable. */
     name: string;
+    /** The unit it is counted in (a supplier's box of 10); absent = the article's base unit. */
+    unitKey?: string;
+    /** Base units in one `unitKey`, fixed when the line was made (plan 046 #14). Absent = 1. */
+    factor?: number;
     /**
      * One line through its changes: 10 seats ending on 12 May and 12 seats from then share it. A
      * billed line never changes; a change ends it and starts a successor in the same series.
@@ -161,6 +164,8 @@ export interface RunLine {
     name: string;
     productId: string;
     unitKey: string;
+    /** Base units in one `unitKey`, from the agreement line (a box of 10). Absent = 1. */
+    factor?: number;
     taxRateKey: string;
     quantity: number;
     unitPriceCents: Cents;

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

@@ -112,5 +112,6 @@ export interface WorkQueueItem {
 /**
  * The rule a line books under: product, then category, then VAT code, then the rule without a
  * match. `undefined` when nothing applies — the caller refuses rather than guessing an account.
+ * With a `direction`, only rules for that direction count: a sale rule never books a purchase.
  */
-export declare function ledgerRuleFor(line: Pick<BookingLine, "productId" | "ledgerCategoryKey" | "taxRateKey">, rules: readonly LedgerMappingRule[]): LedgerMappingRule | undefined;
+export declare function ledgerRuleFor(line: Pick<BookingLine, "productId" | "ledgerCategoryKey" | "taxRateKey">, rules: readonly LedgerMappingRule[], direction?: "sale" | "purchase"): LedgerMappingRule | undefined;

package/dist/entities/business-entity/types.d.ts

@@ -67,6 +67,12 @@ export interface BusinessEntity {
     vatCadence?: "quarter" | "month" | "year";
     /** Kleineondernemersregeling: no VAT charged or deducted, so no return. */
     vatKor?: boolean;
+    /**
+     * The first debtor and creditor number crm hands out here (plan 050); absent = 10001 and 40001.
+     * A change counts for new numbers only: one handed out keeps its number.
+     */
+    firstDebtorNumber?: number;
+    firstCreditorNumber?: number;
     /** The one a new document lands on. Exactly one row carries it. */
     isDefault?: boolean;
     /** Archived, never deleted: an issued quote names the entity it went out as. */

package/dist/entities/catalog/article.d.ts

@@ -0,0 +1,28 @@
+import { Cents } from '../money/money';
+import { PricePer } from '../money/period-price';
+import { Product, ProductRelease, ReferenceCost } from './types';
+/**
+ * `qty` of `unitKey` in the article's base unit: 3 rolls of 500 m are 1,500 m. Throws on a unit
+ * the article does not know — a guessed factor of 1 is how a box of ten gets billed as one.
+ */
+export declare function toBaseUnits(product: Pick<Product, "unitKey" | "units">, unitKey: string, qty: number): number;
+/** Base units in one `unitKey`; 1 for the base unit itself. */
+export declare function unitFactor(product: Pick<Product, "unitKey" | "units">, unitKey: string): number;
+/** What is wrong with a set of units, as an error code; `null` when nothing is. */
+export declare function unitsProblem(product: Pick<Product, "unitKey" | "units">): string | null;
+/** A parent with variants is a container, never on a line: its variants are what is traded. */
+export declare function isTradeable(product: Pick<Product, "id">, all: readonly Pick<Product, "parentId">[]): boolean;
+/**
+ * Why a variant does not fit its parent, as an error code; `null` when it does. Every variant
+ * carries exactly the parent's option keys, and no two share a combination — what a shop sync
+ * (Shopify's `selectedOptions`) requires.
+ */
+export declare function variantOptionsProblem(parent: Pick<Product, "optionKeys">, variant: Pick<Product, "id" | "options">, siblings: readonly Pick<Product, "id" | "options">[]): string | null;
+/**
+ * Whether a **new** commitment may name this article in this administration (a line added, a
+ * quote sent, an order confirmed, a PO sent) — as an error code, `null` when it may. Carrying out
+ * a commitment that already exists (an agreement run, receiving a sent PO) never asks this.
+ */
+export declare function commitProblem(product: Pick<Product, "archived">, release: Pick<ProductRelease, "blocked"> | undefined): string | null;
+/** The reference cost restated to another period, in its own currency (€ 240/year → € 20/month). */
+export declare function referenceCostIn(cost: ReferenceCost, per: PricePer | undefined): Cents;

package/dist/entities/catalog/article.test.d.ts

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

package/dist/entities/catalog/index.d.ts

@@ -1,3 +1,4 @@
+export * from './article';
 export * from './codes';
 export * from './pricing';
 export * from './rate-csv';

package/dist/entities/catalog/pricing.d.ts

@@ -1,7 +1,9 @@
 import { Cents } from '../money/money';
 import { PricePer } from '../money/period-price';
 import { TransactionLine } from '../transaction/types';
-import { PriceRule, Product } from './types';
+import { PriceRule, SellableProduct } from './types';
+/** What the ladder reads of an article: its identity and sales' price row. */
+export type PricedProduct = Pick<SellableProduct, "id" | "categoryKey" | "listPriceCents" | "currency" | "pricePer" | "rateCardId">;
 /**
  * The ladder: the most specific rule wins, whole. No sum, no stacking.
  *
@@ -24,21 +26,23 @@ export interface PriceContext {
     companyId?: string;
     segmentKey?: string;
     contractId?: string;
+    /** In the article's **base** unit: 2 boxes of 10 reach a tier "from 20" (plan 046 #10). */
     quantity: number;
     /** Epoch ms; the validity window is judged against this, not against "now". */
     at: number;
 }
 /** Amount, currency and period travel together: € 222 means nothing without "per year". */
 export interface ResolvedPrice {
-    unitPriceCents: Cents;
+    /** Absent with `sourceKey: "missing"`: no list price and no rule. Never a silent € 0. */
+    unitPriceCents?: Cents;
     currency: string;
     /** Absent = once, or per unit. */
     per?: PricePer;
-    /** Where this amount came from. Almost free, and the only question a salesperson asks. */
+    /** Where this amount came from. Almost free, and the only question a salesperson asks. `missing` = no price. */
     sourceKey: string;
     ruleId?: string;
 }
-export declare function resolvePrice(product: Product, ctx: PriceContext, rules: readonly PriceRule[]): ResolvedPrice;
+export declare function resolvePrice(product: PricedProduct, ctx: PriceContext, rules: readonly PriceRule[]): ResolvedPrice;
 export interface ResolvedRateCard {
     rateCardId: string;
     sourceKey: string;
@@ -48,12 +52,14 @@ export interface ResolvedRateCard {
  * The rate card a `rated` product is billed on for this customer: the same ladder as a price,
  * over the rules whose outcome is a card, then the product's own card. `null` = it has none.
  */
-export declare function resolveRateCard(product: Product, ctx: PriceContext, rules: readonly PriceRule[]): ResolvedRateCard | null;
+export declare function resolveRateCard(product: PricedProduct, ctx: PriceContext, rules: readonly PriceRule[]): ResolvedRateCard | null;
 /** The `priceSourceKey` of a price somebody typed themselves. The ladder never overwrites it. */
 export declare const MANUAL_PRICE_SOURCE = "manual";
+/** Nothing priced it: sending or confirming refuses (`price_missing`) until a person types one. */
+export declare const MISSING_PRICE_SOURCE = "missing";
 /**
  * The ladder again, for lines already on a document: after the quantity or the customer changed,
  * a tier or an agreement may now apply. A typed price stays, and so does a line whose product
  * is no longer in `products`.
  */
-export declare function repriceLines(lines: readonly TransactionLine[], products: readonly Product[], rules: readonly PriceRule[], ctx: Omit<PriceContext, "quantity">): TransactionLine[];
+export declare function repriceLines(lines: readonly TransactionLine[], products: readonly PricedProduct[], rules: readonly PriceRule[], ctx: Omit<PriceContext, "quantity">): TransactionLine[];

package/dist/entities/catalog/rating.d.ts

@@ -120,3 +120,33 @@ export interface RatingResult {
 }
 /** A period's records, rated and grouped per rate. Cents are rounded once per group. */
 export declare function rateRecords(records: readonly UsageRecord[], rates: readonly Rate[], aggregation?: UsageAggregation): RatingResult;
+/**
+ * A rated group as an invoice line: hours × the hourly price when a flat rate says so exactly,
+ * else 1 piece × the group's total (tiers, a markup, a setup fee, a price below a cent).
+ */
+export declare function ratedLineAmount(group: RatedGroup, rate: Rate | undefined, display: {
+    unit: string;
+    per: number;
+}): {
+    quantity: number;
+    unitKey: string;
+    unitPriceCents: Cents;
+};
+/**
+ * What a rated line counted, in the meter's display unit (372 min), for a line billed as
+ * 1 piece × its total — `null` for every other line, whose own quantity already says it.
+ * The allowance is off: the reader sees what was billed.
+ */
+export declare function ratedQuantity(line: {
+    unitKey: string;
+    usage?: {
+        rateId?: string;
+        measured: number;
+        included?: number;
+        per: number;
+        unit: string;
+    };
+}): {
+    amount: number;
+    unit: string;
+} | null;

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

@@ -1,18 +1,21 @@
 import { Cents } from '../money/money';
 import { PricePer } from '../money/period-price';
 /**
- * What we sell, variants included.
+ * An article: what we sell, buy, stock or make, variants included (plan 046). Catalog's, shared by
+ * every administration; what differs per administration is its {@link ProductRelease}. Prices are
+ * sales' ({@link SalesProduct}), offers purchase's.
  *
  * One self-referencing table instead of a product/variant pair: a variant has exactly the same
- * fields as its parent and misses none of them. What it adds is {@link Product.options} — and that
- * is a column, not an entity.
+ * fields as its parent and misses none of them. What it adds is {@link Product.options}.
  */
 export interface Product {
     id: string;
     organizationId: string;
-    /** The parent this is a variant of. Absent = a product in its own right. */
+    /** The parent this is a variant of. Absent = a product in its own right. A parent is never traded. */
     parentId?: string;
-    /** What makes this variant different: `[{ key: "colour", value: "black" }]`. A label, nothing more. */
+    /** On a parent: the option keys every variant carries, in this order (`["colour", "size"]`). */
+    optionKeys?: string[];
+    /** What makes this variant different: `[{ key: "colour", value: "black" }]`. */
     options?: {
         key: string;
         value: string;
@@ -23,28 +26,115 @@ export interface Product {
     sku?: string;
     /** The global code: EAN-13, UPC-12, GTIN-14. Stored normalised — see `normalizeGtin`. */
     gtin?: string;
-    /** Whatever else is scannable (outer case, our own Code128), as scanned. */
+    /** Whatever else is scannable without a quantity of its own, as scanned. */
     barcodes?: string[];
-    /**
-     * The category this falls under — a key from a small table of its own, not free text.
-     *
-     * Having to be stable is the whole requirement: together with {@link Product.taxRateKey} this is
-     * the key the bookkeeping bridge picks a ledger account on. A free text field where one person
-     * types "Services" and another "services " cannot carry that.
-     */
+    /** References to this product elsewhere (`shopify:<shop>:<gid>`). A reference, never a copy. */
+    externalIds?: string[];
+    /** A {@link ProductCategory} key: groups the offering, and price agreements name it. */
     categoryKey?: string;
+    /** Is anything delivered? Fulfilment reads it; a service is done, goods are shipped. */
+    kind: ProductKind;
+    /** Serial or batch numbers on receipt and delivery. Absent = none; goods only. */
+    tracking?: ProductTracking;
+    /** The base unit everything counts in: stock, deliveries, allocations. Locked once used. */
+    unitKey: string;
+    /** Other units it comes in: a roll of 500 m, a box of 10. See {@link toBaseUnits}. */
+    units?: ProductUnit[];
+    /** On quotes, invoices and agreements. Absent = yes; steel plate you only buy is `false`. */
+    sellable?: boolean;
+    /** On purchase orders. Absent = no. */
+    purchasable?: boolean;
+    /** When it was first put on a document: locks {@link Product.unitKey} and forbids a delete. */
+    usedAt?: number;
+    archived?: boolean;
+    order?: number;
+    createdBy: string;
+    createdAt?: number;
+    updatedAt?: number;
+}
+export type ProductKind = "goods" | "service";
+export type ProductTracking = "none" | "serial" | "batch";
+/** Another unit an article comes in. `factor` = base units in one: a roll of 500 m is 500. */
+export interface ProductUnit {
+    key: string;
+    /** A pack of this article's own ("tray van 24"); absent = the fixed unit's name for `key`. */
+    label?: string;
+    factor: number;
+    /** One GTIN per packaging level (GS1): scanning the box counts ten at once. */
+    gtin?: string;
+}
+/**
+ * An article in use in one administration. No release = not offered there. A variant has its own
+ * (its own cost); a parent with variants has none.
+ */
+export interface ProductRelease {
+    id: string;
+    organizationId: string;
+    productId: string;
+    businessEntityId: string;
+    /** Key into that administration's VAT codes, never the percentage itself. */
+    taxRateKey: string;
+    /** A {@link ProductLedgerCategory} key: which revenue or cost account a line books to. */
+    ledgerCategoryKey?: string;
     /**
-     * Which revenue account a line books to, copied onto the line. Not `categoryKey`: that one
-     * groups the offering for price agreements, and "discount on services" names no account.
+     * What we normally pay for this. **Not** a cost price out of an inventory valuation. Shielded by
+     * `catalog.product.cost`, and never in a template context.
      */
-    ledgerCategoryKey?: string;
-    /** References to this product elsewhere (`moneybird:412`). A reference, never a copy. */
-    externalIds?: string[];
+    referenceCost?: ReferenceCost;
+    /** Stopped in this administration only: no new commitments, running ones carry on. */
+    blocked?: boolean;
+    createdBy: string;
+    createdAt?: number;
+    updatedAt?: number;
+}
+/** A cost with its own currency, period and date: $ 240 per year, as of 28-09. */
+export interface ReferenceCost {
+    cents: Cents;
+    currency: string;
+    per?: PricePer;
+    asOf: number;
+    /** The purchase offer it comes from; absent = typed by hand. Read-only in the form then. */
+    offerId?: string;
+    supplierCompanyId?: string;
+}
+/** A small table of its own, never free text: price agreements and reports name it. */
+export interface ProductCategory {
+    id: string;
+    organizationId: string;
+    key: string;
+    name: string;
+    order?: number;
+    archived?: boolean;
+}
+/**
+ * Which account a line books to, in either direction: "hardware" is revenue 8000 on a sale and
+ * cost 7000 on a purchase, through finance's mapping. Catalog's list; finance reads it as the
+ * contract's `LedgerCategory { key, label }` and maps it.
+ */
+export interface ProductLedgerCategory {
+    id: string;
+    organizationId: string;
+    key: string;
+    name: string;
+    order?: number;
+    archived?: boolean;
+}
+/**
+ * Sales' own row per article and administration: the price and how it bills. Absent row, or no
+ * `listPriceCents` = no price — which is not € 0 (plan 046 #12).
+ */
+export interface SalesProduct {
+    id: string;
+    organizationId: string;
+    productId: string;
+    businessEntityId: string;
+    listPriceCents?: Cents;
+    currency: string;
     /**
-     * Hours booked on this `WorkType.key` are invoiced as this product. Here and not on the work
-     * type: time must not know sales, and several products may share one type (junior/senior).
+     * The period the list price is for: € 222 per year. Absent = once, or per unit. A recurring
+     * agreement line needs one; the run bills its share of each window.
      */
-    workTypeKey?: string;
+    pricePer?: PricePer;
     /**
      * `unit`: a price per unit through the ladder (list price, tiers, customer agreements).
      * `rated`: every record priced on a rate card by its dimensions (calls, traffic).
@@ -52,61 +142,34 @@ export interface Product {
     pricing?: ProductPricing;
     /** The default card of a `rated` product. A price agreement may name another. */
     rateCardId?: string;
-    /** See {@link FIXED_UNITS}. Drives the form and the word after the quantity. */
-    unitKey: string;
-    /** Key into the organisation's VAT table, never the percentage itself. */
-    taxRateKey: string;
-    listPriceCents: Cents;
-    currency: string;
-    /**
-     * The period the list and cost price are for: € 222 per year. Absent = once, or per unit.
-     * A recurring agreement line needs one; the run bills its share of each window.
-     */
-    pricePer?: PricePer;
-    /**
-     * What we normally pay for this. **Not** a cost price out of an inventory valuation.
-     *
-     * Copied onto the line when it is added, and shielded: margin is not for everyone holding
-     * `sales.product.read`. It never reaches a template context either — `{line.cost}` on a quote
-     * would be one typo away.
-     */
-    costPriceCents?: Cents;
-    /** The period the cost price is for, when it differs from {@link Product.pricePer}. */
-    costPricePer?: PricePer;
-    /** The purchase offer the cost comes from; absent = typed by hand. Read-only in the form then. */
-    costOfferId?: string;
-    /** Who we buy it from. A `Company` in crm, so free — and all a later purchase order needs. */
-    supplierCompanyId?: string;
-    /**
-     * The administration this belongs to. Unset = the default one — see `belongsToEntity`.
-     *
-     * Exactly one, not a list: two administrations that both sell this keep two rows, with their
-     * own sku, their own price and their own ledger category. That is the price of a hard split and
-     * it is what was chosen.
-     */
-    businessEntityId?: string;
-    /** On quotes, invoices and agreements. Absent = yes; steel plate you only buy is `false`. */
-    sellable?: boolean;
-    /** On purchase orders. Absent = no. */
-    purchasable?: boolean;
-    archived?: boolean;
-    order?: number;
-    createdBy: string;
-    createdAt?: number;
+    /** The unit a new line starts in (a box); absent = the base unit. */
+    unitKey?: string;
     updatedAt?: number;
 }
-/** The cost price in the period of the list price, for a margin. Absent without a cost price. */
-export declare function costInPricePeriod(product: Pick<Product, "costPriceCents" | "costPricePer" | "pricePer">): Cents | undefined;
+/**
+ * An article as sales sees it in one administration: catalog's article, its release, and sales'
+ * own row, flat. A read model — nothing stores it. See {@link sellableProduct}.
+ */
+export interface SellableProduct extends Product, Partial<Pick<ProductRelease, "taxRateKey" | "ledgerCategoryKey" | "referenceCost" | "blocked">>, Omit<Partial<SalesProduct>, "id" | "organizationId" | "productId" | "unitKey" | "updatedAt"> {
+    /** The price list's currency, else the administration's: what price rules are matched on. */
+    currency: string;
+    /** Sales' default unit for a new line. */
+    salesUnitKey?: string;
+    /** Whether this administration has released it at all. */
+    released: boolean;
+}
+/** Puts the three rows together. `currency` is the administration's, for an article without a price. */
+export declare function sellableProduct(product: Product, release: ProductRelease | undefined, sales: SalesProduct | undefined, currency: string): SellableProduct;
 /** Whether a sales picker offers it: absent counts as sellable, so older products stay. */
 export declare function isSellable(product: Pick<Product, "sellable" | "archived">): boolean;
 /** Whether a purchase picker offers it. */
 export declare function isPurchasable(product: Pick<Product, "purchasable" | "archived">): boolean;
+export type ProductPricing = "unit" | "rated";
 /**
  * Units follow work's `FIXED_TYPES` pattern: a fixed list plus a namespaced fallback, so an
  * unknown key reads as itself instead of breaking.
  */
-export type ProductPricing = "unit" | "rated";
-export declare const FIXED_UNITS: readonly ["piece", "hour", "day", "month", "km", "license", "minute", "kg", "ton", "m", "m2", "m3", "liter"];
+export declare const FIXED_UNITS: readonly ["piece", "hour", "day", "month", "km", "license", "minute", "kg", "ton", "m", "m2", "m3", "liter", "box", "roll", "pallet", "pack"];
 export type FixedUnit = (typeof FIXED_UNITS)[number];
 /**
  * A price for a customer, a segment or a contract.
@@ -179,6 +242,10 @@ export interface SaveProductRequest extends Partial<Omit<Product, "id" | "organi
     id?: string;
     name: string;
 }
+export interface SaveReleaseRequest extends Partial<Omit<ProductRelease, "id" | "organizationId" | "createdBy" | "createdAt" | "updatedAt">> {
+    productId: string;
+    businessEntityId: string;
+}
 export interface SavePriceRuleRequest extends Partial<Omit<PriceRule, "id" | "organizationId" | "createdBy" | "createdAt">> {
     id?: string;
 }

package/dist/entities/catalog/usage-source.d.ts

@@ -34,6 +34,17 @@ export interface UsageMeter {
      * is nothing to pick, and the customer's id is the account. Absent = `source`.
      */
     account?: "source" | "customer";
+    /**
+     * Billing increments worth offering beyond the generic ones (as used, first unit whole, per
+     * started unit): hours per started quarter. In meter units; `label` is a `locales` key.
+     */
+    increments?: UsageIncrement[];
+}
+/** `{ first: 900, next: 900 }` = per started quarter of an hour, in seconds. */
+export interface UsageIncrement {
+    first: number;
+    next: number;
+    label: string;
 }
 export interface UsageDimension {
     key: string;

package/dist/entities/company/address.d.ts

@@ -0,0 +1,30 @@
+import { PostalAddress } from '../organization/types';
+/** What an address is for. One address can be several: billing and visiting at one door. */
+export type CompanyAddressKind = "billing" | "delivery" | "site" | "visit";
+export declare const COMPANY_ADDRESS_KINDS: readonly CompanyAddressKind[];
+/** The kinds a document takes by default when nobody picks. */
+export type PrimaryAddressKind = "billing" | "delivery";
+/**
+ * One address of a company, with an id to point at (plan 050): a qualification, a delivery to a
+ * site, a portal order. Archived, never deleted — whatever points at it keeps pointing. A sent
+ * document freezes the address on its paper; it never reads the row again.
+ */
+export interface CompanyAddress {
+    id: string;
+    organizationId: string;
+    companyId: string;
+    kinds: CompanyAddressKind[];
+    /** "Vestiging Utrecht"; absent = the street says enough. */
+    label?: string;
+    address: PostalAddress;
+    primaryFor?: PrimaryAddressKind[];
+    archived?: boolean;
+    createdBy: string;
+    createdAt?: number;
+    updatedAt?: number;
+}
+/**
+ * The address a document takes for `kind`: the primary one, else the first live one of that
+ * kind. A delivery falls back to billing — most small companies have one address for both.
+ */
+export declare function primaryAddress(addresses: readonly CompanyAddress[], kind: PrimaryAddressKind): CompanyAddress | undefined;

package/dist/entities/company/address.test.d.ts

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

package/dist/entities/company/index.d.ts

@@ -1,2 +1,4 @@
+export * from './address';
 export * from './identifiers';
+export * from './role';
 export * from './types';

package/dist/entities/company/role.d.ts

@@ -0,0 +1,33 @@
+/** Which side of the table a company sits on, for one administration. */
+export type CompanyRoleKind = "customer" | "supplier";
+export declare const COMPANY_ROLE_KINDS: readonly CompanyRoleKind[];
+/**
+ * A company in one role for one administration (plan 050): customer 10023 at BV A, supplier 40017
+ * in USD at BV B. One per `(companyId, businessEntityId, role)`; crm hands out the numbers, per
+ * administration and role, so an organisation without sales still gets creditor numbers.
+ */
+export interface CompanyRole {
+    id: string;
+    organizationId: string;
+    companyId: string;
+    businessEntityId: string;
+    role: CompanyRoleKind;
+    /** Debtor or creditor number; unique per administration and role. */
+    number?: string;
+    /** An organization `PaymentTerm.code`, in the direction of the role. */
+    paymentTermKey?: string;
+    /** Empty = the administration's currency. */
+    currency?: string;
+    /** Nothing new in this role: no quote to a blocked customer, no PO to a blocked supplier. */
+    blocked?: boolean;
+    createdAt?: number;
+    updatedAt?: number;
+}
+/** "Make sure this company is our supplier at BV B": idempotent, the existing role if there is one. */
+export interface EnsureCompanyRoleRequest {
+    companyId: string;
+    businessEntityId: string;
+    role: CompanyRoleKind;
+}
+/** The payment-term direction a role pays in: a customer pays us, we pay a supplier. */
+export declare const roleDirection: (role: CompanyRoleKind) => "sales" | "purchase";

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

@@ -1,5 +1,4 @@
 import { LifecycleStage } from '../contact/lifecycle';
-import { PostalAddress } from '../organization/types';
 import { OwnerScope } from '../scope/types';
 /** Same meaning as {@link ContactOrigin}: `shadow` is a lazily cached hit, a landed row is `own`. */
 export type CompanyOrigin = "own" | "shadow";
@@ -48,19 +47,6 @@ export interface Company {
     lifecycleStage?: LifecycleStage;
     /** The group this company belongs to. One level up per row; a cycle is refused on write. */
     parentCompanyId?: string;
-    /**
-     * Where the company sits. Needed by anything that puts this company on paper — a quote's
-     * recipient block is the first, and the issue gate refuses a document with a hole in it.
-     */
-    address?: PostalAddress;
-    /**
-     * This customer's default payment condition, as a code `apps/sales` owns.
-     *
-     * An opaque key, exactly like {@link Company.locale} is an opaque language: crm stores it and
-     * never interprets it. It is a default and not a rule — a document copies the condition when it
-     * is created and keeps it from then on, so changing this never rewrites what already went out.
-     */
-    paymentTermCode?: string;
     /** Normalised: upper case, no spaces (`NL123456789B01`). */
     vatNumber?: string;
     kvkNumber?: string;
@@ -68,14 +54,6 @@ export interface Company {
     ibans?: string[];
     /** `<scheme>:<id>` (`0106:12345678`), for Peppol e-invoicing. */
     peppolId?: string;
-    debtorNumber?: string;
-    creditorNumber?: string;
-    /** We buy from them. Loose fields on the company, as in Exact — not a supplier entity. */
-    isSupplier?: boolean;
-    /** Their payment condition towards us; {@link Company.paymentTermCode} is ours towards them. */
-    supplierPaymentTermKey?: string;
-    /** The currency they invoice us in; empty = the administration's. */
-    supplierCurrency?: string;
     /** Raw, human-readable phone/website as entered, for display. */
     phone?: string;
     website?: string;

package/dist/entities/contact/segment.d.ts

@@ -6,7 +6,7 @@ import { SavedView, SavedViewSort } from '../saved-view/types';
  */
 export type SegmentKind = "contact" | "company";
 /** Multi-value filters: empty or absent = no filter on that axis. */
-export declare const SEGMENT_LIST_FILTERS: readonly ["stages", "leadStatuses", "sources", "scopes", "cities", "parentCompanyIds"];
+export declare const SEGMENT_LIST_FILTERS: readonly ["stages", "leadStatuses", "sources", "scopes", "cities", "parentCompanyIds", "roles"];
 export type SegmentListFilter = (typeof SEGMENT_LIST_FILTERS)[number];
 /** Yes/no filters that need another store to answer: open deals in work, people at a company. */
 export declare const SEGMENT_PRESENCE_FILTERS: readonly ["openDeal", "hasContacts"];