@adminiumjs/manifest 0.3.5 → 0.3.7

package/dist/public-access.d.ts

@@ -26,6 +26,7 @@
  * entry reaches the parent row: a draft's lines stay as hidden as the draft.
  */
 import { z } from 'zod';
+import { type Capacity } from './capacity.js';
 import { type ReferenceIssue, type TableIndex } from './refs.js';
 /** The key every entry uses unless it names another. */
 export declare const CUSTOMER_KEY = "customer";
@@ -41,6 +42,8 @@ export declare const claimSchema: z.ZodUnion<readonly [z.ZodObject<{
     column: z.ZodString;
     expires: z.ZodOptional<z.ZodString>;
     stopped: z.ZodOptional<z.ZodString>;
+    own: z.ZodOptional<z.ZodLiteral<true>>;
+    address: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodTuple<[z.ZodString, z.ZodString], null>]>>;
 }, z.core.$strict>]>;
 export type Claim = z.infer<typeof claimSchema>;
 /** How an identity entry claims: by details, by an emailed link, or by a token. */
@@ -51,6 +54,258 @@ export declare function claimKind(claim: Claim): 'lookup' | 'link' | 'token';
  * listed, never a value the app's own package gives (its sample rows).
  */
 export declare function shareCodeColumns(entries: readonly PublicAccess[], table: string): string[];
+/**
+ * Why a column of another row may never be printed in a list one level down
+ * (an email's `joins`, a document's list of names): a list is read for
+ * whoever the email or document goes to, one row further from them than the
+ * row they asked for, so no reader decides what it shows. A secret, personal
+ * data, a code (the one a shared link opens its row with, one Adminium makes,
+ * one a person typed), or a column an entry withholds from all but its
+ * holder. Null for a column any reader may see listed.
+ */
+export declare function unlistedColumn(m: {
+    publicAccess?: readonly PublicAccess[] | undefined;
+    requiredSchema: {
+        tables: readonly {
+            ref: string;
+            columns: readonly {
+                ref: string;
+                rules?: Record<string, unknown> | undefined;
+            }[];
+        }[];
+    };
+}, table: string, column: string): string | null;
+/**
+ * Whether a column holds personal data: marked so (`personal: true`), or —
+ * unless marked otherwise — guessed so by its name as the install does: an
+ * address, a phone number, a birth date, an ID or account number, a person's
+ * first, last or full name on a table of people. Secrets are not personal
+ * data (they are never shown at all).
+ */
+export declare function personalColumn(table: {
+    ref: string;
+    columns: readonly {
+        ref: string;
+        type: string;
+        rules?: Record<string, unknown> | undefined;
+    }[];
+}, column: string): 'marked' | 'guessed' | null;
+/**
+ * Which rows of a codes table count when a typed code is looked up: a value a
+ * column must hold (`active = true`), or a date it must not be past
+ * (`notBefore: 'now'` on a `valid_until`, `orEmpty` for none) or before.
+ */
+export declare const codeWhereSchema: z.ZodArray<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;
+    notBefore: z.ZodEnum<{
+        today: "today";
+        now: "now";
+    }>;
+    orEmpty: z.ZodOptional<z.ZodLiteral<true>>;
+}, z.core.$strict>, z.ZodObject<{
+    column: z.ZodString;
+    notAfter: z.ZodEnum<{
+        today: "today";
+        now: "now";
+    }>;
+    orEmpty: z.ZodOptional<z.ZodLiteral<true>>;
+}, z.core.$strict>]>>;
+/**
+ * A value of the row that must agree with another: `column` (followed along
+ * `path` through foreign keys) equals, is at most, or is at least the target.
+ * `when` applies it only to rows whose value (along its own `path`) is one of
+ * `in`.
+ */
+export declare const agreeSchema: z.ZodObject<{
+    column: z.ZodString;
+    path: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    when: z.ZodOptional<z.ZodObject<{
+        path: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        in: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+    }, z.core.$strict>>;
+    eq: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+        parent: z.ZodString;
+        path: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>, z.ZodObject<{
+        via: z.ZodString;
+        column: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+    }, z.core.$strict>]>>;
+    lte: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+        parent: z.ZodString;
+        path: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>, z.ZodObject<{
+        via: z.ZodString;
+        column: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+    }, z.core.$strict>]>>;
+    gte: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+        parent: z.ZodString;
+        path: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>, z.ZodObject<{
+        via: z.ZodString;
+        column: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+    }, z.core.$strict>]>>;
+}, z.core.$strict>;
+export type Agree = z.infer<typeof agreeSchema>;
+/**
+ * How many sibling rows may fall in one group: `by` follows this row's
+ * foreign keys to the group (an option's group), whose `min` and `max`
+ * columns bound the count. `every` names the groups judged even when no row
+ * falls in them (a required size left out): those whose `column` equals the
+ * parent row's.
+ */
+export declare const countsSchema: z.ZodObject<{
+    by: z.ZodArray<z.ZodString>;
+    every: z.ZodOptional<z.ZodObject<{
+        column: z.ZodString;
+        eq: z.ZodObject<{
+            parent: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    min: z.ZodString;
+    max: z.ZodString;
+}, z.core.$strict>;
+export type Counts = z.infer<typeof countsSchema>;
+/** A child row of a create (an order's line), with at most one more level below it. */
+export declare const childEntrySchema: z.ZodObject<{
+    children: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        via: z.ZodString;
+        writable: z.ZodArray<z.ZodString>;
+        select: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        defaults: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
+        writableValues: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>>;
+        requires: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        position: z.ZodOptional<z.ZodString>;
+        min: z.ZodOptional<z.ZodNumber>;
+        max: z.ZodNumber;
+        agrees: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            column: z.ZodString;
+            path: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            when: z.ZodOptional<z.ZodObject<{
+                path: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                in: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+            }, z.core.$strict>>;
+            eq: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+                parent: z.ZodString;
+                path: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            }, z.core.$strict>, z.ZodObject<{
+                via: z.ZodString;
+                column: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+            }, z.core.$strict>]>>;
+            lte: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+                parent: z.ZodString;
+                path: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            }, z.core.$strict>, z.ZodObject<{
+                via: z.ZodString;
+                column: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+            }, z.core.$strict>]>>;
+            gte: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+                parent: z.ZodString;
+                path: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            }, z.core.$strict>, z.ZodObject<{
+                via: z.ZodString;
+                column: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+            }, z.core.$strict>]>>;
+        }, z.core.$strict>>>;
+        counts: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            by: z.ZodArray<z.ZodString>;
+            every: z.ZodOptional<z.ZodObject<{
+                column: z.ZodString;
+                eq: z.ZodObject<{
+                    parent: z.ZodString;
+                }, z.core.$strict>;
+            }, z.core.$strict>>;
+            min: z.ZodString;
+            max: z.ZodString;
+        }, z.core.$strict>>>;
+        plainText: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        sumMax: z.ZodOptional<z.ZodObject<{
+            column: z.ZodString;
+            max: z.ZodUnion<readonly [z.ZodNumber, z.ZodObject<{
+                table: z.ZodString;
+                column: z.ZodString;
+            }, z.core.$strict>]>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>>;
+    via: z.ZodString;
+    writable: z.ZodArray<z.ZodString>;
+    select: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    defaults: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
+    writableValues: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>>;
+    requires: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    position: z.ZodOptional<z.ZodString>;
+    min: z.ZodOptional<z.ZodNumber>;
+    max: z.ZodNumber;
+    agrees: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        column: z.ZodString;
+        path: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        when: z.ZodOptional<z.ZodObject<{
+            path: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            in: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+        }, z.core.$strict>>;
+        eq: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+            parent: z.ZodString;
+            path: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>, z.ZodObject<{
+            via: z.ZodString;
+            column: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+        }, z.core.$strict>]>>;
+        lte: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+            parent: z.ZodString;
+            path: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>, z.ZodObject<{
+            via: z.ZodString;
+            column: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+        }, z.core.$strict>]>>;
+        gte: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+            parent: z.ZodString;
+            path: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>, z.ZodObject<{
+            via: z.ZodString;
+            column: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+        }, z.core.$strict>]>>;
+    }, z.core.$strict>>>;
+    counts: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        by: z.ZodArray<z.ZodString>;
+        every: z.ZodOptional<z.ZodObject<{
+            column: z.ZodString;
+            eq: z.ZodObject<{
+                parent: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+        min: z.ZodString;
+        max: z.ZodString;
+    }, z.core.$strict>>>;
+    plainText: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    sumMax: z.ZodOptional<z.ZodObject<{
+        column: z.ZodString;
+        max: z.ZodUnion<readonly [z.ZodNumber, z.ZodObject<{
+            table: z.ZodString;
+            column: z.ZodString;
+        }, z.core.$strict>]>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type ChildEntry = z.infer<typeof childEntrySchema>;
 export declare const publicAccessSchema: z.ZodObject<{
     table: z.ZodString;
     kind: z.ZodOptional<z.ZodEnum<{
@@ -95,6 +350,8 @@ export declare const publicAccessSchema: z.ZodObject<{
         column: z.ZodString;
         expires: z.ZodOptional<z.ZodString>;
         stopped: z.ZodOptional<z.ZodString>;
+        own: z.ZodOptional<z.ZodLiteral<true>>;
+        address: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodTuple<[z.ZodString, z.ZodString], null>]>>;
     }, z.core.$strict>]>>;
     claimedBy: z.ZodOptional<z.ZodObject<{
         table: z.ZodString;
@@ -105,6 +362,37 @@ export declare const publicAccessSchema: z.ZodObject<{
         lookup: "lookup";
         verified: "verified";
     }>>;
+    identity: z.ZodOptional<z.ZodObject<{
+        table: z.ZodString;
+        email: z.ZodString;
+        link: z.ZodString;
+        fill: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        on: z.ZodOptional<z.ZodObject<{
+            to: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    shareLink: z.ZodOptional<z.ZodString>;
+    forget: z.ZodOptional<z.ZodObject<{
+        columns: z.ZodArray<z.ZodString>;
+        stamp: z.ZodOptional<z.ZodString>;
+        links: z.ZodOptional<z.ZodLiteral<true>>;
+    }, z.core.$strict>>;
+    newLink: z.ZodOptional<z.ZodObject<{
+        column: z.ZodString;
+        kind: z.ZodString;
+        when: z.ZodOptional<z.ZodObject<{
+            where: 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]>>>;
+                isNull: z.ZodOptional<z.ZodBoolean>;
+                gt: z.ZodOptional<z.ZodNumber>;
+                gte: z.ZodOptional<z.ZodNumber>;
+                lt: z.ZodOptional<z.ZodNumber>;
+                lte: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
     visibleWith: z.ZodOptional<z.ZodObject<{
         table: z.ZodString;
         via: z.ZodString;
@@ -120,8 +408,201 @@ export declare const publicAccessSchema: z.ZodObject<{
     requires: z.ZodOptional<z.ZodArray<z.ZodString>>;
     writableWhen: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodArray<z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>, z.ZodNull]>>, z.ZodLiteral<"from-now">, z.ZodLiteral<"from-today">, z.ZodLiteral<"before-today">, z.ZodObject<{
         within: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        after: z.ZodOptional<z.ZodObject<{
+            column: z.ZodOptional<z.ZodString>;
+            time: z.ZodOptional<z.ZodType<import("./refs.js").WallTime, unknown, z.core.$ZodTypeInternals<import("./refs.js").WallTime, unknown>>>;
+            plus: z.ZodOptional<z.ZodType<import("./refs.js").MomentOffset, unknown, z.core.$ZodTypeInternals<import("./refs.js").MomentOffset, unknown>>>;
+            minus: z.ZodOptional<z.ZodType<import("./refs.js").MomentOffset, unknown, z.core.$ZodTypeInternals<import("./refs.js").MomentOffset, unknown>>>;
+            or: z.ZodOptional<z.ZodArray<z.ZodType<import("./refs.js").PlainMoment, unknown, z.core.$ZodTypeInternals<import("./refs.js").PlainMoment, unknown>>>>;
+        }, z.core.$strict>>;
+        before: z.ZodOptional<z.ZodObject<{
+            column: z.ZodOptional<z.ZodString>;
+            time: z.ZodOptional<z.ZodType<import("./refs.js").WallTime, unknown, z.core.$ZodTypeInternals<import("./refs.js").WallTime, unknown>>>;
+            plus: z.ZodOptional<z.ZodType<import("./refs.js").MomentOffset, unknown, z.core.$ZodTypeInternals<import("./refs.js").MomentOffset, unknown>>>;
+            minus: z.ZodOptional<z.ZodType<import("./refs.js").MomentOffset, unknown, z.core.$ZodTypeInternals<import("./refs.js").MomentOffset, unknown>>>;
+            or: z.ZodOptional<z.ZodArray<z.ZodType<import("./refs.js").PlainMoment, unknown, z.core.$ZodTypeInternals<import("./refs.js").PlainMoment, unknown>>>>;
+        }, 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]>>>;
+            isNull: z.ZodOptional<z.ZodBoolean>;
+            gt: z.ZodOptional<z.ZodNumber>;
+            gte: z.ZodOptional<z.ZodNumber>;
+            lt: z.ZodOptional<z.ZodNumber>;
+            lte: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>>;
     }, z.core.$strict>]>>>;
     humanCheck: z.ZodOptional<z.ZodLiteral<true>>;
+    children: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        children: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            via: z.ZodString;
+            writable: z.ZodArray<z.ZodString>;
+            select: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            defaults: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
+            writableValues: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>>;
+            requires: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            position: z.ZodOptional<z.ZodString>;
+            min: z.ZodOptional<z.ZodNumber>;
+            max: z.ZodNumber;
+            agrees: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                column: z.ZodString;
+                path: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                when: z.ZodOptional<z.ZodObject<{
+                    path: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    in: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+                }, z.core.$strict>>;
+                eq: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+                    parent: z.ZodString;
+                    path: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                }, z.core.$strict>, z.ZodObject<{
+                    via: z.ZodString;
+                    column: z.ZodString;
+                }, z.core.$strict>, z.ZodObject<{
+                    value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+                }, z.core.$strict>]>>;
+                lte: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+                    parent: z.ZodString;
+                    path: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                }, z.core.$strict>, z.ZodObject<{
+                    via: z.ZodString;
+                    column: z.ZodString;
+                }, z.core.$strict>, z.ZodObject<{
+                    value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+                }, z.core.$strict>]>>;
+                gte: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+                    parent: z.ZodString;
+                    path: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                }, z.core.$strict>, z.ZodObject<{
+                    via: z.ZodString;
+                    column: z.ZodString;
+                }, z.core.$strict>, z.ZodObject<{
+                    value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+                }, z.core.$strict>]>>;
+            }, z.core.$strict>>>;
+            counts: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                by: z.ZodArray<z.ZodString>;
+                every: z.ZodOptional<z.ZodObject<{
+                    column: z.ZodString;
+                    eq: z.ZodObject<{
+                        parent: z.ZodString;
+                    }, z.core.$strict>;
+                }, z.core.$strict>>;
+                min: z.ZodString;
+                max: z.ZodString;
+            }, z.core.$strict>>>;
+            plainText: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            sumMax: z.ZodOptional<z.ZodObject<{
+                column: z.ZodString;
+                max: z.ZodUnion<readonly [z.ZodNumber, z.ZodObject<{
+                    table: z.ZodString;
+                    column: z.ZodString;
+                }, z.core.$strict>]>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>>;
+        via: z.ZodString;
+        writable: z.ZodArray<z.ZodString>;
+        select: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        defaults: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
+        writableValues: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>>;
+        requires: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        position: z.ZodOptional<z.ZodString>;
+        min: z.ZodOptional<z.ZodNumber>;
+        max: z.ZodNumber;
+        agrees: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            column: z.ZodString;
+            path: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            when: z.ZodOptional<z.ZodObject<{
+                path: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                in: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+            }, z.core.$strict>>;
+            eq: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+                parent: z.ZodString;
+                path: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            }, z.core.$strict>, z.ZodObject<{
+                via: z.ZodString;
+                column: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+            }, z.core.$strict>]>>;
+            lte: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+                parent: z.ZodString;
+                path: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            }, z.core.$strict>, z.ZodObject<{
+                via: z.ZodString;
+                column: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+            }, z.core.$strict>]>>;
+            gte: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+                parent: z.ZodString;
+                path: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            }, z.core.$strict>, z.ZodObject<{
+                via: z.ZodString;
+                column: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+            }, z.core.$strict>]>>;
+        }, z.core.$strict>>>;
+        counts: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            by: z.ZodArray<z.ZodString>;
+            every: z.ZodOptional<z.ZodObject<{
+                column: z.ZodString;
+                eq: z.ZodObject<{
+                    parent: z.ZodString;
+                }, z.core.$strict>;
+            }, z.core.$strict>>;
+            min: z.ZodString;
+            max: z.ZodString;
+        }, z.core.$strict>>>;
+        plainText: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        sumMax: z.ZodOptional<z.ZodObject<{
+            column: z.ZodString;
+            max: z.ZodUnion<readonly [z.ZodNumber, z.ZodObject<{
+                table: z.ZodString;
+                column: z.ZodString;
+            }, z.core.$strict>]>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>>;
+    agrees: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        column: z.ZodString;
+        path: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        when: z.ZodOptional<z.ZodObject<{
+            path: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            in: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+        }, z.core.$strict>>;
+        eq: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+            parent: z.ZodString;
+            path: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>, z.ZodObject<{
+            via: z.ZodString;
+            column: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+        }, z.core.$strict>]>>;
+        lte: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+            parent: z.ZodString;
+            path: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>, z.ZodObject<{
+            via: z.ZodString;
+            column: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+        }, z.core.$strict>]>>;
+        gte: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+            parent: z.ZodString;
+            path: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>, z.ZodObject<{
+            via: z.ZodString;
+            column: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+        }, z.core.$strict>]>>;
+    }, z.core.$strict>>>;
+    dryRun: z.ZodOptional<z.ZodLiteral<true>>;
+    expect: z.ZodOptional<z.ZodString>;
+    clientKey: z.ZodOptional<z.ZodString>;
     rank: z.ZodOptional<z.ZodObject<{
         orderBy: z.ZodString;
         where: z.ZodOptional<z.ZodObject<{
@@ -141,6 +622,14 @@ export declare const publicAccessSchema: z.ZodObject<{
             n: z.ZodNumber;
         }, z.core.$strict>>;
         perKeyHour: z.ZodOptional<z.ZodNumber>;
+        perIpHour: z.ZodOptional<z.ZodNumber>;
+        plainText: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>;
+    limits: z.ZodOptional<z.ZodObject<{
+        perValue: z.ZodOptional<z.ZodObject<{
+            columns: z.ZodArray<z.ZodString>;
+            n: z.ZodNumber;
+        }, z.core.$strict>>;
         plainText: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strict>>;
     requireSetting: z.ZodOptional<z.ZodArray<z.ZodObject<{
@@ -166,6 +655,66 @@ export declare const publicAccessSchema: z.ZodObject<{
         }, z.core.$strict>>;
         link: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>>;
+    rule: z.ZodOptional<z.ZodNumber>;
+    showLeft: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+        below: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        belowShare: z.ZodNumber;
+    }, z.core.$strict>]>>;
+    under: z.ZodOptional<z.ZodString>;
+    unlockBy: z.ZodOptional<z.ZodObject<{
+        table: z.ZodString;
+        column: z.ZodString;
+        link: z.ZodString;
+        where: z.ZodOptional<z.ZodArray<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;
+            notBefore: z.ZodEnum<{
+                today: "today";
+                now: "now";
+            }>;
+            orEmpty: z.ZodOptional<z.ZodLiteral<true>>;
+        }, z.core.$strict>, z.ZodObject<{
+            column: z.ZodString;
+            notAfter: z.ZodEnum<{
+                today: "today";
+                now: "now";
+            }>;
+            orEmpty: z.ZodOptional<z.ZodLiteral<true>>;
+        }, z.core.$strict>]>>>;
+    }, z.core.$strict>>;
+    pictures: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    withhold: z.ZodOptional<z.ZodObject<{
+        columns: z.ZodArray<z.ZodString>;
+        unlessHolder: z.ZodOptional<z.ZodString>;
+        when: z.ZodOptional<z.ZodObject<{
+            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]>>>;
+                isNull: z.ZodOptional<z.ZodBoolean>;
+                gt: z.ZodOptional<z.ZodNumber>;
+                gte: z.ZodOptional<z.ZodNumber>;
+                lt: z.ZodOptional<z.ZodNumber>;
+                lte: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strict>>>;
+            linked: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                via: z.ZodString;
+                where: 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]>>>;
+                    isNull: z.ZodOptional<z.ZodBoolean>;
+                    gt: z.ZodOptional<z.ZodNumber>;
+                    gte: z.ZodOptional<z.ZodNumber>;
+                    lt: z.ZodOptional<z.ZodNumber>;
+                    lte: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
 }, z.core.$strict>;
 export type PublicAccess = z.infer<typeof publicAccessSchema>;
 /**
@@ -198,8 +747,14 @@ interface PublicAccessContext {
     index: TableIndex;
     /** Columns Adminium decides on a table: a browser may never write them. */
     decided: (table: string) => ReadonlySet<string>;
+    /** The columns of a table a money figure Adminium works out reads (a formula, a total, a copy into one). */
+    figures?: (table: string) => ReadonlySet<string>;
+    /** Whether the app's outbox writes a message when a row of the table is created. */
+    mailsOnCreate?: (table: string) => boolean;
     /** Whether the table carries a capacity or a booking rule to answer availability from. */
     answersAvailability: (table: string) => boolean;
+    /** The table's limits, as it declares them (absent: the caller does not say). */
+    capacityOf?: (table: string) => Capacity | undefined;
     publicKeys: Readonly<Record<string, PublicKey>> | undefined;
     roles: readonly {
         key: string;
@@ -207,7 +762,89 @@ interface PublicAccessContext {
         cloneFrom?: string | undefined;
         permissions?: readonly string[] | undefined;
     }[];
+    /** The app's outbox, for a new link it emails (absent: the app has none). */
+    outbox?: {
+        table: string;
+        kinds: Readonly<Record<string, string>>;
+        columns: {
+            repeatKey?: string | undefined;
+        };
+        links?: Readonly<Record<string, string>> | undefined;
+        recipient?: ResendOutbox['recipient'] | undefined;
+        producers?: ResendOutbox['producers'];
+    } | undefined;
+}
+/** A row's own link a person reaches: its table, the code column that opens it, and the columns that link its rows to the person. */
+export interface PersonOwnLink {
+    table: string;
+    column: string;
+    people: string[];
 }
+/**
+ * The own links of the rows a person of `identityTable` holds: each table a
+ * token claims with `own: true`, by its code column, and the columns of it
+ * that point at the person — the ones a signed-in read claims by, or a found
+ * person is linked through.
+ */
+export declare function ownLinksOfPerson(entries: readonly PublicAccess[], identityTable: string): PersonOwnLink[];
+/** The outbox as a resend reads it: its recipient, its links and the producers that declare a kind's recipient. */
+export interface ResendOutbox {
+    table: string;
+    recipient: {
+        table: string;
+        via: string;
+        email: string;
+        fallback?: {
+            via: string;
+            email: string;
+        } | undefined;
+    };
+    producers?: readonly {
+        kind: string;
+        link: string;
+        hold?: boolean | undefined;
+        repeatBy?: string | undefined;
+        recipient?: {
+            setting: unknown;
+        } | {
+            column: string;
+            name?: string | undefined;
+            language?: string | undefined;
+        } | undefined;
+    }[] | undefined;
+}
+/** Where a resend of a row's own link is read from: the kind's column recipient, or none (the outbox's own), and the columns the address comes from. */
+export interface ResendAddress {
+    /** The kind's own producer mails an address a column of the row holds. */
+    recipient?: {
+        column: string;
+        name?: string | undefined;
+        language?: string | undefined;
+    } | undefined;
+    /** The row's columns the address is read from (or through). */
+    columns: string[];
+    /** The person's table and address column, when the address is read from the person the row links. */
+    person?: {
+        table: string;
+        column: string;
+    } | undefined;
+}
+/** A table's columns as a resend reads them: each name, and the table it references (null: no link). */
+export type ResendColumns = (table: string) => readonly {
+    name: string;
+    references: string | null;
+}[] | undefined;
+/**
+ * How a message of `kind` about a row of `table` is addressed when it is
+ * sent again through the row's own link — as the kind's own producer
+ * declares it (the first producer of the kind, as the sender reads it), and
+ * only from the row: a column of the row, the person it links (the column
+ * named as the outbox's recipient link, else its one key to the recipient's
+ * table), or the outbox's fallback through this table. Null when nothing on
+ * the row addresses it (a setting's address, a column of another row, two
+ * keys to the recipient). The validator and the server ask this one function.
+ */
+export declare function resendAddressOf(outbox: ResendOutbox, kind: string, table: string, columnsOf: ResendColumns): ResendAddress | null;
 /** Everything in `publicAccess` and `publicKeys` that names something undeclared, or breaks a rule. */
 export declare function publicAccessIssues(entries: readonly PublicAccess[], ctx: PublicAccessContext): ReferenceIssue[];
 export {};