@adminiumjs/manifest 0.3.16 → 0.3.18-rc.0

package/dist/ledgers.d.ts

@@ -0,0 +1,691 @@
+/**
+ * LEDGERS AND POSTINGS.
+ *
+ * A ledger is an add-on's own set of tables that only Adminium writes, from
+ * rows the add-on's code works out (stock movements, a gift card's spends).
+ * The add-on declares it under `addOn.ledgers`: its receipt table, the tables
+ * and columns that may be written, and its ACTIONS (use, receive, spend …) —
+ * each with the inputs it takes, the rows it reads first and the rows a lock
+ * is named by.
+ *
+ * A posting is the other half, declared on any table of any manifest
+ * (`postings`): "when a row of this table reaches this point, hand these
+ * columns to that action". An order line reserving stock at checkout and
+ * taking it when the order is picked up is one posting with two points.
+ *
+ * This file holds the words and what one manifest can check of them by
+ * itself. Whether a host's posting fits the ledger it names is checked with
+ * both manifests at hand (`postingFitIssues`), at install and when an owner
+ * stores a rule.
+ *
+ * Pure: no I/O, and nothing imported from the manifest's own schema file, so
+ * that file may import this one.
+ */
+import { z } from 'zod';
+import { type ReferenceIssue } from './refs.js';
+/** The most ledgers one add-on declares. */
+export declare const LEDGERS_MAX = 4;
+/** The most actions one ledger declares. */
+export declare const LEDGER_ACTIONS_MAX = 16;
+/** The most tables one ledger may write. */
+export declare const LEDGER_WRITES_MAX = 12;
+/** The most reads one action declares. */
+export declare const LEDGER_READS_MAX = 6;
+/** The most rows one read returns. */
+export declare const LEDGER_READ_ROWS = 1000;
+/** The most postings one table carries. */
+export declare const POSTINGS_PER_TABLE = 6;
+/** What an action's input is: a link, a number, text, a date, a yes/no, a table's stored name, or a row of any table. */
+export declare const LEDGER_INPUT_TYPES: readonly ["link", "link?", "number", "number?", "decimal", "decimal?", "text", "text?", "date?", "bool?", "tableRef", "rowRef"];
+export type LedgerInputType = (typeof LEDGER_INPUT_TYPES)[number];
+/** Whether a posting may leave the input unmapped. */
+export declare const optionalInput: (type: LedgerInputType) => boolean;
+/** The phases of a posting round: held, taken, given back. */
+export declare const POSTING_PHASES: readonly ["reserve", "post", "reverse"];
+export type PostingPhase = (typeof POSTING_PHASES)[number];
+/**
+ * Where a read's key comes from: an input of the action (`input.item`; a
+ * `rowRef` input as `input.what.table` / `input.what.row`), a column of an
+ * earlier read (`items.unit_id`), the source row (`source.table`,
+ * `source.row`, `source.line`), the round's receipt (`receipt.id`), a column
+ * of the add-on's settings row (`setting.low_below`), or what a price
+ * question recorded (`uses.offer`, `uses.code`, `uses.voucher`).
+ */
+export declare const readFromSchema: z.ZodString;
+/** One read an action makes before its code runs: rows of an own table, by up to three keys. */
+export declare const ledgerReadSchema: z.ZodObject<{
+    as: z.ZodString;
+    table: z.ZodString;
+    by: z.ZodArray<z.ZodObject<{
+        column: z.ZodString;
+        from: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
+    }, z.core.$strict>>;
+    where: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        column: z.ZodString;
+        eq: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+        in: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
+    }, z.core.$strict>>>;
+    limit: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+export type LedgerRead = z.infer<typeof ledgerReadSchema>;
+export declare const ledgerActionSchema: z.ZodObject<{
+    inputs: z.ZodRecord<z.ZodString, z.ZodEnum<{
+        number: "number";
+        decimal: "decimal";
+        link: "link";
+        text: "text";
+        "link?": "link?";
+        "number?": "number?";
+        "decimal?": "decimal?";
+        "text?": "text?";
+        "date?": "date?";
+        "bool?": "bool?";
+        tableRef: "tableRef";
+        rowRef: "rowRef";
+    }>>;
+    phases: z.ZodArray<z.ZodEnum<{
+        reverse: "reverse";
+        reserve: "reserve";
+        post: "post";
+    }>>;
+    reads: z.ZodArray<z.ZodObject<{
+        as: z.ZodString;
+        table: z.ZodString;
+        by: z.ZodArray<z.ZodObject<{
+            column: z.ZodString;
+            from: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
+        }, z.core.$strict>>;
+        where: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            column: z.ZodString;
+            eq: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+            in: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
+        }, z.core.$strict>>>;
+        limit: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+    locks: z.ZodArray<z.ZodObject<{
+        read: z.ZodString;
+        column: z.ZodString;
+        table: z.ZodString;
+    }, z.core.$strict>>;
+    decides: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        input: z.ZodString;
+        min: z.ZodLiteral<"0">;
+        max: z.ZodUnion<readonly [z.ZodObject<{
+            input: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            read: z.ZodString;
+            column: z.ZodString;
+        }, z.core.$strict>]>;
+    }, z.core.$strict>>>;
+    holds: z.ZodOptional<z.ZodLiteral<true>>;
+    unavailable: z.ZodOptional<z.ZodObject<{
+        allow: z.ZodObject<{
+            read: z.ZodString;
+            column: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    writes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+export type LedgerAction = z.infer<typeof ledgerActionSchema>;
+/**
+ * The table a `link` input names a row of: the table of the action's read
+ * that is keyed by its own primary key and fed by that input. Null when no
+ * read says so (an input the add-on's code looks up by another column).
+ * `keyOf` answers a table's primary-key column.
+ */
+export declare function linkInputTable(action: Pick<LedgerAction, 'inputs' | 'reads'>, input: string, keyOf: (table: string) => string | undefined): string | null;
+export declare const ledgerSchema: z.ZodObject<{
+    id: z.ZodString;
+    receipts: z.ZodString;
+    refusal: z.ZodEnum<{
+        value: "value";
+        stock: "stock";
+    }>;
+    writes: z.ZodRecord<z.ZodString, z.ZodObject<{
+        insert: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        update: z.ZodOptional<z.ZodObject<{
+            by: z.ZodArray<z.ZodString>;
+            set: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    actions: z.ZodRecord<z.ZodString, z.ZodObject<{
+        inputs: z.ZodRecord<z.ZodString, z.ZodEnum<{
+            number: "number";
+            decimal: "decimal";
+            link: "link";
+            text: "text";
+            "link?": "link?";
+            "number?": "number?";
+            "decimal?": "decimal?";
+            "text?": "text?";
+            "date?": "date?";
+            "bool?": "bool?";
+            tableRef: "tableRef";
+            rowRef: "rowRef";
+        }>>;
+        phases: z.ZodArray<z.ZodEnum<{
+            reverse: "reverse";
+            reserve: "reserve";
+            post: "post";
+        }>>;
+        reads: z.ZodArray<z.ZodObject<{
+            as: z.ZodString;
+            table: z.ZodString;
+            by: z.ZodArray<z.ZodObject<{
+                column: z.ZodString;
+                from: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
+            }, z.core.$strict>>;
+            where: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                column: z.ZodString;
+                eq: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+                in: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
+            }, z.core.$strict>>>;
+            limit: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>;
+        locks: z.ZodArray<z.ZodObject<{
+            read: z.ZodString;
+            column: z.ZodString;
+            table: z.ZodString;
+        }, z.core.$strict>>;
+        decides: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            input: z.ZodString;
+            min: z.ZodLiteral<"0">;
+            max: z.ZodUnion<readonly [z.ZodObject<{
+                input: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                read: z.ZodString;
+                column: z.ZodString;
+            }, z.core.$strict>]>;
+        }, z.core.$strict>>>;
+        holds: z.ZodOptional<z.ZodLiteral<true>>;
+        unavailable: z.ZodOptional<z.ZodObject<{
+            allow: z.ZodObject<{
+                read: z.ZodString;
+                column: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+        writes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type Ledger = z.infer<typeof ledgerSchema>;
+export declare const ledgersSchema: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    receipts: z.ZodString;
+    refusal: z.ZodEnum<{
+        value: "value";
+        stock: "stock";
+    }>;
+    writes: z.ZodRecord<z.ZodString, z.ZodObject<{
+        insert: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        update: z.ZodOptional<z.ZodObject<{
+            by: z.ZodArray<z.ZodString>;
+            set: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    actions: z.ZodRecord<z.ZodString, z.ZodObject<{
+        inputs: z.ZodRecord<z.ZodString, z.ZodEnum<{
+            number: "number";
+            decimal: "decimal";
+            link: "link";
+            text: "text";
+            "link?": "link?";
+            "number?": "number?";
+            "decimal?": "decimal?";
+            "text?": "text?";
+            "date?": "date?";
+            "bool?": "bool?";
+            tableRef: "tableRef";
+            rowRef: "rowRef";
+        }>>;
+        phases: z.ZodArray<z.ZodEnum<{
+            reverse: "reverse";
+            reserve: "reserve";
+            post: "post";
+        }>>;
+        reads: z.ZodArray<z.ZodObject<{
+            as: z.ZodString;
+            table: z.ZodString;
+            by: z.ZodArray<z.ZodObject<{
+                column: z.ZodString;
+                from: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
+            }, z.core.$strict>>;
+            where: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                column: z.ZodString;
+                eq: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+                in: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
+            }, z.core.$strict>>>;
+            limit: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>;
+        locks: z.ZodArray<z.ZodObject<{
+            read: z.ZodString;
+            column: z.ZodString;
+            table: z.ZodString;
+        }, z.core.$strict>>;
+        decides: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            input: z.ZodString;
+            min: z.ZodLiteral<"0">;
+            max: z.ZodUnion<readonly [z.ZodObject<{
+                input: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                read: z.ZodString;
+                column: z.ZodString;
+            }, z.core.$strict>]>;
+        }, z.core.$strict>>>;
+        holds: z.ZodOptional<z.ZodLiteral<true>>;
+        unavailable: z.ZodOptional<z.ZodObject<{
+            allow: z.ZodObject<{
+                read: z.ZodString;
+                column: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+        writes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>>;
+/**
+ * The moment a posting's phase fires: the row's own create; a move of its
+ * state; a column reaching a value; a column being filled. Under `via` every
+ * point but a create is judged on the parent row, unless it says `own`.
+ */
+export declare const postingPointSchema: z.ZodUnion<readonly [z.ZodObject<{
+    create: z.ZodLiteral<true>;
+}, z.core.$strict>, z.ZodObject<{
+    to: z.ZodArray<z.ZodString>;
+    from: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>, z.ZodObject<{
+    column: z.ZodString;
+    in: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+    from: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
+    own: z.ZodOptional<z.ZodLiteral<true>>;
+}, z.core.$strict>, z.ZodObject<{
+    column: z.ZodString;
+    set: z.ZodLiteral<true>;
+    own: z.ZodOptional<z.ZodLiteral<true>>;
+}, z.core.$strict>]>;
+export type PostingPoint = z.infer<typeof postingPointSchema>;
+/** What an input is filled from: a column of the row, the row itself, a column of the `via` parent, a setting of the add-on, or a fixed value. */
+export declare const postingMappingSchema: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+    row: z.ZodLiteral<true>;
+}, z.core.$strict>, z.ZodObject<{
+    parent: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    setting: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+}, z.core.$strict>]>;
+export type PostingMapping = z.infer<typeof postingMappingSchema>;
+export declare const postingSchema: z.ZodObject<{
+    id: z.ZodString;
+    into: z.ZodObject<{
+        addOn: z.ZodString;
+        ledger: z.ZodString;
+        action: z.ZodString;
+    }, z.core.$strict>;
+    needs: z.ZodOptional<z.ZodString>;
+    via: z.ZodOptional<z.ZodString>;
+    reserve: z.ZodOptional<z.ZodObject<{
+        on: z.ZodUnion<readonly [z.ZodObject<{
+            create: z.ZodLiteral<true>;
+        }, z.core.$strict>, z.ZodObject<{
+            to: z.ZodArray<z.ZodString>;
+            from: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>, z.ZodObject<{
+            column: z.ZodString;
+            in: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+            from: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
+            own: z.ZodOptional<z.ZodLiteral<true>>;
+        }, z.core.$strict>, z.ZodObject<{
+            column: z.ZodString;
+            set: z.ZodLiteral<true>;
+            own: z.ZodOptional<z.ZodLiteral<true>>;
+        }, z.core.$strict>]>;
+    }, z.core.$strict>>;
+    post: z.ZodOptional<z.ZodObject<{
+        on: z.ZodUnion<readonly [z.ZodObject<{
+            create: z.ZodLiteral<true>;
+        }, z.core.$strict>, z.ZodObject<{
+            to: z.ZodArray<z.ZodString>;
+            from: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>, z.ZodObject<{
+            column: z.ZodString;
+            in: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+            from: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
+            own: z.ZodOptional<z.ZodLiteral<true>>;
+        }, z.core.$strict>, z.ZodObject<{
+            column: z.ZodString;
+            set: z.ZodLiteral<true>;
+            own: z.ZodOptional<z.ZodLiteral<true>>;
+        }, z.core.$strict>]>;
+    }, z.core.$strict>>;
+    reverse: z.ZodOptional<z.ZodObject<{
+        on: z.ZodUnion<readonly [z.ZodObject<{
+            create: z.ZodLiteral<true>;
+        }, z.core.$strict>, z.ZodObject<{
+            to: z.ZodArray<z.ZodString>;
+            from: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>, z.ZodObject<{
+            column: z.ZodString;
+            in: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+            from: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
+            own: z.ZodOptional<z.ZodLiteral<true>>;
+        }, z.core.$strict>, z.ZodObject<{
+            column: z.ZodString;
+            set: z.ZodLiteral<true>;
+            own: z.ZodOptional<z.ZodLiteral<true>>;
+        }, z.core.$strict>]>;
+    }, z.core.$strict>>;
+    map: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        row: z.ZodLiteral<true>;
+    }, z.core.$strict>, z.ZodObject<{
+        parent: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        setting: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+    }, z.core.$strict>]>>;
+    multipliers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        row: z.ZodLiteral<true>;
+    }, z.core.$strict>, z.ZodObject<{
+        parent: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        setting: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+    }, z.core.$strict>]>>>;
+    heldUntil: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        row: z.ZodLiteral<true>;
+    }, z.core.$strict>, z.ZodObject<{
+        parent: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        setting: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+    }, z.core.$strict>]>>;
+    refuses: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        table: z.ZodOptional<z.ZodString>;
+        via: z.ZodOptional<z.ZodString>;
+        column: z.ZodString;
+        set: z.ZodLiteral<true>;
+    }, z.core.$strict>>>;
+    unlessSet: z.ZodOptional<z.ZodString>;
+    only: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+        column: z.ZodString;
+        eq: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+    }, z.core.$strict>, z.ZodObject<{
+        column: z.ZodString;
+        in: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+    }, z.core.$strict>, z.ZodObject<{
+        column: z.ZodString;
+        set: z.ZodLiteral<true>;
+    }, z.core.$strict>]>>;
+}, z.core.$strict>;
+export type Posting = z.infer<typeof postingSchema>;
+export declare const postingsSchema: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    into: z.ZodObject<{
+        addOn: z.ZodString;
+        ledger: z.ZodString;
+        action: z.ZodString;
+    }, z.core.$strict>;
+    needs: z.ZodOptional<z.ZodString>;
+    via: z.ZodOptional<z.ZodString>;
+    reserve: z.ZodOptional<z.ZodObject<{
+        on: z.ZodUnion<readonly [z.ZodObject<{
+            create: z.ZodLiteral<true>;
+        }, z.core.$strict>, z.ZodObject<{
+            to: z.ZodArray<z.ZodString>;
+            from: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>, z.ZodObject<{
+            column: z.ZodString;
+            in: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+            from: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
+            own: z.ZodOptional<z.ZodLiteral<true>>;
+        }, z.core.$strict>, z.ZodObject<{
+            column: z.ZodString;
+            set: z.ZodLiteral<true>;
+            own: z.ZodOptional<z.ZodLiteral<true>>;
+        }, z.core.$strict>]>;
+    }, z.core.$strict>>;
+    post: z.ZodOptional<z.ZodObject<{
+        on: z.ZodUnion<readonly [z.ZodObject<{
+            create: z.ZodLiteral<true>;
+        }, z.core.$strict>, z.ZodObject<{
+            to: z.ZodArray<z.ZodString>;
+            from: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>, z.ZodObject<{
+            column: z.ZodString;
+            in: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+            from: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
+            own: z.ZodOptional<z.ZodLiteral<true>>;
+        }, z.core.$strict>, z.ZodObject<{
+            column: z.ZodString;
+            set: z.ZodLiteral<true>;
+            own: z.ZodOptional<z.ZodLiteral<true>>;
+        }, z.core.$strict>]>;
+    }, z.core.$strict>>;
+    reverse: z.ZodOptional<z.ZodObject<{
+        on: z.ZodUnion<readonly [z.ZodObject<{
+            create: z.ZodLiteral<true>;
+        }, z.core.$strict>, z.ZodObject<{
+            to: z.ZodArray<z.ZodString>;
+            from: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>, z.ZodObject<{
+            column: z.ZodString;
+            in: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+            from: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
+            own: z.ZodOptional<z.ZodLiteral<true>>;
+        }, z.core.$strict>, z.ZodObject<{
+            column: z.ZodString;
+            set: z.ZodLiteral<true>;
+            own: z.ZodOptional<z.ZodLiteral<true>>;
+        }, z.core.$strict>]>;
+    }, z.core.$strict>>;
+    map: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        row: z.ZodLiteral<true>;
+    }, z.core.$strict>, z.ZodObject<{
+        parent: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        setting: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+    }, z.core.$strict>]>>;
+    multipliers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        row: z.ZodLiteral<true>;
+    }, z.core.$strict>, z.ZodObject<{
+        parent: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        setting: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+    }, z.core.$strict>]>>>;
+    heldUntil: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        row: z.ZodLiteral<true>;
+    }, z.core.$strict>, z.ZodObject<{
+        parent: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        setting: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+    }, z.core.$strict>]>>;
+    refuses: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        table: z.ZodOptional<z.ZodString>;
+        via: z.ZodOptional<z.ZodString>;
+        column: z.ZodString;
+        set: z.ZodLiteral<true>;
+    }, z.core.$strict>>>;
+    unlessSet: z.ZodOptional<z.ZodString>;
+    only: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+        column: z.ZodString;
+        eq: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+    }, z.core.$strict>, z.ZodObject<{
+        column: z.ZodString;
+        in: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+    }, z.core.$strict>, z.ZodObject<{
+        column: z.ZodString;
+        set: z.ZodLiteral<true>;
+    }, z.core.$strict>]>>;
+}, z.core.$strict>>;
+/** The owner's switch, stored apart from the rule so an app update never switches it back on. */
+export declare const switchedOffSchema: z.ZodObject<{
+    postings: z.ZodArray<z.ZodString>;
+    adjust: z.ZodOptional<z.ZodLiteral<true>>;
+}, z.core.$strict>;
+export type SwitchedOff = z.infer<typeof switchedOffSchema>;
+/** What the checks read of a table. */
+export interface LedgerTableShape {
+    ref: string;
+    columns: readonly {
+        ref: string;
+        type: string;
+        role?: string | undefined;
+        nullable?: boolean | undefined;
+        enum?: readonly string[] | undefined;
+        references?: string | undefined;
+        maxLength?: number | undefined;
+        rules?: {
+            rollup?: {
+                balance?: {
+                    column: string;
+                } | undefined;
+            } | undefined;
+            copy?: {
+                follow?: unknown;
+            } | undefined;
+            tableRef?: true | undefined;
+        } | undefined;
+    }[];
+    states?: {
+        column: string;
+        initial: string;
+        moves: Readonly<Record<string, readonly unknown[]>>;
+        timed?: unknown;
+    } | undefined;
+    postings?: readonly Posting[] | undefined;
+}
+/**
+ * Everything wrong with a table's postings that this manifest can see: its
+ * points, its `via`, the columns it maps, and — for an add-on posting into
+ * its own ledger — the fit with the action it names.
+ */
+export declare function postingIssues(table: LedgerTableShape, ctx: {
+    /** This manifest's key and kind. */
+    key: string;
+    kind: 'app' | 'add-on';
+    tables: ReadonlyMap<string, LedgerTableShape>;
+    /** The add-ons the manifest names (`requires` and `suggests`). */
+    named: ReadonlySet<string>;
+    /** An app's `addOns.features`, by id, with the add-ons each needs. */
+    features: ReadonlyMap<string, readonly string[]>;
+    /** The manifest's own ledgers, when it is an add-on. */
+    ledgers: readonly Ledger[];
+}, at: (...rest: (string | number)[]) => (string | number)[]): ReferenceIssue[];
+/**
+ * Whether a posting fits the ledger action it names: the action exists, every
+ * input it needs is mapped and nothing else is, its phases are ones the
+ * action has, and a hold has an end.
+ *
+ * `timed`: whether the judged row's table moves by itself in time — a round
+ * that Adminium decides at the create must be given back by something.
+ */
+export declare function postingFitIssues(posting: Posting, ledger: Ledger, facts: {
+    timed: boolean;
+}): ReferenceIssue[];
+/** The columns of a receipt table Adminium keys by, in key order. */
+export declare const RECEIPT_KEY: readonly ["source_table", "source_row", "source_line", "posting", "phase", "round"];
+/** Every column of a receipt table, with the type it must have. `held_until` is the one that may be empty. */
+export declare const RECEIPT_COLUMNS: Readonly<Record<string, {
+    type: readonly string[];
+    nullable?: true;
+    enum?: readonly string[];
+    tableRef?: true;
+}>>;
+/**
+ * Whether a table is a receipt table as Adminium writes one: exactly the
+ * columns of `RECEIPT_COLUMNS` beside its key, each of its type, none but
+ * `held_until` nullable, and a bounded width on every text column of the key.
+ */
+export declare function receiptTableIssues(table: LedgerTableShape, at: (...rest: (string | number)[]) => (string | number)[]): ReferenceIssue[];
+/** What the scope checks read of a table, beyond {@link LedgerTableShape}. */
+export interface LedgerScopeTable extends LedgerTableShape {
+    columns: readonly (LedgerTableShape['columns'][number] & {
+        unique?: true | undefined;
+        rules?: (NonNullable<LedgerTableShape['columns'][number]['rules']> & {
+            rollup?: {
+                from?: string;
+                cap?: true | undefined;
+                balance?: {
+                    column: string;
+                    minus?: readonly string[] | undefined;
+                } | undefined;
+            } | undefined;
+            formula?: unknown;
+            stamp?: unknown;
+            sequence?: {
+                gapless?: true | undefined;
+            } | undefined;
+            code?: unknown;
+            copy?: {
+                follow?: unknown;
+            } | undefined;
+        }) | undefined;
+    })[];
+    unique?: readonly (readonly string[])[] | undefined;
+    booking?: unknown;
+    capacity?: unknown;
+}
+export declare const LEDGER_ISSUE_CODES: readonly ["LEDGER_OUT_OF_SCOPE", "LEDGER_WRITES_DECIDED", "LEDGER_UPDATE_KEY", "LEDGER_READ_CHAIN", "LEDGER_LOCK", "LEDGER_TABLE_GUARDED", "LEDGER_DECIDES_TYPE"];
+export type LedgerIssueCode = (typeof LEDGER_ISSUE_CODES)[number];
+export interface LedgerIssue {
+    code: LedgerIssueCode;
+    path: (string | number)[];
+    message: string;
+}
+/**
+ * Everything that would let a ledger reach outside what it declares: a table
+ * that is not the add-on's own, a written column Adminium decides, an update
+ * that could name more than one row, a read whose key comes from nowhere, a
+ * capped total nobody locks, a table another guard already rules, an amount
+ * decided that is no number.
+ *
+ * `addOn.scopes` grants nothing and refuses nothing at run time; a ledger is
+ * bounded by these checks and by the same ones made again on every answer.
+ */
+export declare function ledgerIssues(m: {
+    tables: readonly LedgerScopeTable[];
+    ledgers: readonly Ledger[];
+    settingsTable?: string | undefined;
+}): LedgerIssue[];
+/**
+ * A question asked of a ledger's action with nothing written: one line per
+ * row asked about, a quantity of one, answered `in`, `low` or `out`. `input`
+ * is the action's input that takes the row asked about; `showLeftBelow` names
+ * the settings column holding the owner's "show how many are left below".
+ */
+export declare const wordsSchema: z.ZodObject<{
+    id: z.ZodString;
+    ledger: z.ZodString;
+    action: z.ZodString;
+    input: z.ZodString;
+    showLeftBelow: z.ZodOptional<z.ZodObject<{
+        setting: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type StockWords = z.infer<typeof wordsSchema>;
+export declare const wordsListSchema: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    ledger: z.ZodString;
+    action: z.ZodString;
+    input: z.ZodString;
+    showLeftBelow: z.ZodOptional<z.ZodObject<{
+        setting: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>>;
+/** The most rows one words question asks about. */
+export declare const WORDS_IDS_MAX = 60;
+/** Everything wrong with an add-on's stock words that its own manifest can see. */
+export declare function wordsIssues(m: {
+    words: readonly StockWords[];
+    ledgers: readonly Ledger[];
+    tables: readonly LedgerTableShape[];
+    settingsTable?: string | undefined;
+}): ReferenceIssue[];
+//# sourceMappingURL=ledgers.d.ts.map