@trypattern/sdk 0.0.0-stage → 0.1.1

package/dist/shortcuts.js

@@ -0,0 +1,40 @@
+import { useEffect } from 'react';
+const MODIFIER_KEYS = new Set(['Shift', 'Meta', 'Control', 'Alt', 'CapsLock']);
+const OWNS_KEYS = 'input, textarea, select, [contenteditable], [role=menu], [role=listbox], [role=dialog]';
+function isApplePlatform() {
+    if (typeof navigator === 'undefined')
+        return false;
+    return /Mac|iPhone|iPad/.test(navigator.userAgent);
+}
+function isOwnedByControl(target) {
+    return target instanceof Element && target.closest(OWNS_KEYS) !== null;
+}
+function shortcutOf(event) {
+    if (event.defaultPrevented || event.isComposing)
+        return undefined;
+    const hasMod = isApplePlatform() ? event.metaKey : event.ctrlKey;
+    if (hasMod && !event.altKey)
+        return `mod+${event.key.toLowerCase()}`;
+    if (event.metaKey || event.ctrlKey || event.altKey || event.repeat) {
+        return undefined;
+    }
+    if (MODIFIER_KEYS.has(event.key) || isOwnedByControl(event.target)) {
+        return undefined;
+    }
+    return event.key;
+}
+export function useShortcuts(pressKey) {
+    useEffect(() => {
+        const onKeyDown = (event) => {
+            const shortcut = shortcutOf(event);
+            if (shortcut === undefined)
+                return;
+            const ran = pressKey(shortcut);
+            if (ran !== undefined && shortcut.startsWith('mod+')) {
+                event.preventDefault();
+            }
+        };
+        window.addEventListener('keydown', onKeyDown);
+        return () => window.removeEventListener('keydown', onKeyDown);
+    }, [pressKey]);
+}

package/dist/start.d.ts

@@ -0,0 +1,20 @@
+import type { Theme } from '@stylexjs/stylex';
+import './theme/reset.css';
+import type { AppClass, RunningApp } from './app.ts';
+import type { IconDrawing } from './components/icons.ts';
+import type { Interaction } from './components/interaction.ts';
+import type { ReactApp } from './hooks/appContext.ts';
+import type { Tables } from './table.ts';
+import { borders, colors, controls, fontSizes, fonts, iconSizes, lineHeights, radii, shadows, space, widths } from './theme/tokens.stylex.ts';
+type Themeable = typeof colors | typeof radii | typeof fonts | typeof shadows | typeof space | typeof fontSizes | typeof lineHeights | typeof controls | typeof iconSizes | typeof borders | typeof widths;
+export type StartOptions = {
+    theme?: readonly Theme<Themeable>[];
+    icons?: Readonly<Record<string, IconDrawing>>;
+    onInteraction?: (interaction: Interaction) => void;
+};
+type AnyRunningApp = RunningApp<unknown, {
+    readonly path: string;
+}>;
+type RenderableApp = AnyRunningApp & ReactApp;
+export declare function startApp<Group extends Tables, Instance extends RenderableApp>(App: AppClass<Group, Instance>, { theme, icons, onInteraction }?: StartOptions): Instance;
+export {};

package/dist/start.js

@@ -0,0 +1,145 @@
+import * as stylex from '@stylexjs/stylex';
+import { StrictMode, createElement } from 'react';
+import { createRoot } from 'react-dom/client';
+import { createBrowserRouter } from 'react-router';
+import { RouterProvider } from 'react-router/dom';
+import './theme/reset.css';
+import { browserApi } from "./api.js";
+import { Cache } from "./cache.js";
+import { setAppIcons } from "./components/icons.js";
+import { setInteractionSink } from "./components/interaction.js";
+import { manualClock, realClock } from "./clock.js";
+import { Gate } from "./gate.js";
+import { AppProvider } from "./hooks/appContext.js";
+import { routeObjects } from "./routes.js";
+import { borders, breakpoints, colors, controls, fontFeatures, fontSizes, fontWeights, fonts, iconSizes, lineHeights, radii, shadows, space, widths } from "./theme/tokens.stylex.js";
+const TEST_SEED = 'patternSeed';
+const TEST_ADMINS = 'patternAdmins';
+const TEST_WORLD = 'patternWorld';
+function testSeed() {
+    const seed = Reflect.get(window, TEST_SEED);
+    return typeof seed === 'object' && seed !== null ? seed : {};
+}
+function testAdmins() {
+    const admins = Reflect.get(window, TEST_ADMINS);
+    return Array.isArray(admins)
+        ? admins.filter((email) => typeof email === 'string')
+        : [];
+}
+export function startApp(App, { theme = [], icons = {}, onInteraction } = {}) {
+    setAppIcons(icons);
+    document.body.className = stylex.props(base.body, theme).className ?? '';
+    const hot = import.meta.hot;
+    const testParams = new URLSearchParams(hot ? location.search : '');
+    const gate = new Gate(testParams.getAll('fail'));
+    for (const call of testParams.getAll('hold'))
+        gate.hold(call);
+    const { tables, routes, services, memory } = App.definition;
+    const inMemory = testParams.has('memory');
+    const world = inMemory ? (Reflect.get(window, TEST_WORLD) ?? {}) : {};
+    const router = createBrowserRouter(routeObjects(routes));
+    const app = new App(router, {
+        api: browserApi(tables, inMemory ? testSeed() : {}, gate, {
+            inMemory,
+            admins: inMemory ? testAdmins() : [],
+            ...(services === undefined ? {} : { services }),
+            ...(memory === undefined ? {} : { memory }),
+            world
+        }),
+        cache: Cache.local(),
+        gate,
+        clock: inMemory ? manualClock() : realClock()
+    });
+    if (hot)
+        exposeToDevTools(app, gate, hot, world);
+    followAppearance(app);
+    followTitle(app);
+    if (onInteraction !== undefined) {
+        setInteractionSink((interaction) => onInteraction({
+            ...interaction,
+            page: app.router.state.matches.at(-1)?.route.id ?? null
+        }));
+    }
+    const root = document.getElementById('root');
+    if (root === null)
+        throw new Error('index.html needs a <div id="root">');
+    createRoot(root).render(createElement(StrictMode, null, createElement(AppProvider, {
+        app,
+        children: createElement(RouterProvider, { router: app.router })
+    })));
+    return app;
+}
+function followAppearance(app) {
+    const account = app.models.account;
+    const apply = () => {
+        const { appearance } = account.currentState;
+        document.documentElement.style.colorScheme =
+            appearance === 'system' ? 'light dark' : appearance;
+    };
+    account.subscribe(apply);
+    apply();
+}
+function followTitle(app) {
+    const store = app.stores.app;
+    const apply = () => {
+        const { title } = store.currentState;
+        if (title !== '')
+            document.title = title;
+    };
+    store.subscribe(apply);
+    apply();
+}
+function exposeToDevTools(app, gate, hot, world) {
+    async function snapshotWhenIdle() {
+        await app.whenIdle();
+        return app.getSnapshot();
+    }
+    function dispatch(raw) {
+        const command = app.parse(raw);
+        if (typeof command === 'object' && command !== null && 'error' in command) {
+            return { error: String(command.error) };
+        }
+        void app.send(command);
+        return { ok: true };
+    }
+    Object.assign(window, {
+        pattern: {
+            send: dispatch,
+            snapshot: snapshotWhenIdle,
+            hold: (call) => gate.hold(call),
+            release: (call) => gate.release(call),
+            tick: () => app.tick(),
+            world: (patch) => {
+                if (typeof world === 'object' && world !== null) {
+                    Object.assign(world, patch);
+                }
+            }
+        }
+    });
+    if (navigator.webdriver)
+        return;
+    hot.on('pattern:command', async (message) => {
+        const sent = dispatch(message.command);
+        hot.send('pattern:reply', {
+            id: message.id,
+            ...('error' in sent ? sent : { snapshot: await snapshotWhenIdle() })
+        });
+    });
+}
+const base = stylex.create({
+    body: {
+        fontFamily: fonts.sans,
+        fontSize: {
+            default: fontSizes.bodySm,
+            [breakpoints.compact]: fontSizes.bodyBase
+        },
+        fontWeight: fontWeights.normal,
+        fontFeatureSettings: fontFeatures.sans,
+        lineHeight: {
+            default: lineHeights.bodySm,
+            [breakpoints.compact]: lineHeights.body
+        },
+        color: colors.primaryForeground,
+        backgroundColor: colors.shell
+    }
+});

package/dist/state.d.ts

@@ -0,0 +1,14 @@
+import type { z } from 'zod';
+export type Json = string | number | boolean | null | readonly Json[] | {
+    readonly [key: string]: Json;
+};
+export type StateSpec = Record<string, z.ZodDefault<z.ZodType<Json>>>;
+export type StateOf<Spec extends StateSpec> = {
+    [Key in keyof Spec]: z.output<Spec[Key]>;
+};
+export type Persisted = {
+    read: (key: string) => unknown;
+    write: (key: string, value: unknown) => void;
+};
+export declare function defaultsOf<Spec extends StateSpec>(spec: Spec): StateOf<Spec>;
+export declare function restore<Spec extends StateSpec>(spec: Spec, persist: readonly (keyof Spec & string)[], device: Persisted): StateOf<Spec>;

package/dist/state.js

@@ -0,0 +1,17 @@
+export function defaultsOf(spec) {
+    const entries = Object.entries(spec).map(([key, schema]) => [
+        key,
+        schema.parse(undefined)
+    ]);
+    return Object.fromEntries(entries);
+}
+export function restore(spec, persist, device) {
+    const state = defaultsOf(spec);
+    for (const key of persist) {
+        const parsed = spec[key]?.safeParse(device.read(key));
+        if (parsed?.success) {
+            state[key] = parsed.data;
+        }
+    }
+    return state;
+}

package/dist/store.d.ts

@@ -0,0 +1,45 @@
+import type { Persisted, StateOf, StateSpec } from './state.ts';
+export declare function isDevelopment(): boolean;
+export declare function plainJsonProblem(value: unknown, path: string): string | undefined;
+export declare function keepEqualParts<Value>(previous: unknown, next: Value): Value;
+export type Reads = Map<StoreBase<object, unknown>, Map<string, unknown>>;
+export declare function tracked<Value>(run: () => Value): {
+    value: Value;
+    reads: Reads;
+};
+export declare function mergeReads(from: Reads): void;
+export declare function readsAreCurrent(reads: Reads): boolean;
+export declare function whileBuilding<Value>(run: () => Value): Value;
+export declare function assertNotBuilding(what: string): void;
+export declare abstract class StoreBase<State extends object, Deps = undefined> {
+    #private;
+    protected readonly deps: Deps;
+    constructor(...args: Deps extends undefined ? [] : [deps: Deps]);
+    protected abstract initialState(): State;
+    get state(): State;
+    get currentState(): State;
+    readonly subscribe: (listener: () => void) => (() => void);
+    protected set(patch: Partial<State>): void;
+    protected changed(): void;
+}
+export type StoreConfig<S extends StateSpec, P extends readonly (keyof S & string)[]> = {
+    state?: S;
+    persist?: P;
+};
+export declare abstract class DeclaredStore<State extends object, Client = Record<never, never>> extends StoreBase<State> {
+    protected readonly services: Client;
+    constructor(services: Client);
+    protected initialState(): State;
+}
+export type StoreClass<S extends StateSpec, P extends readonly (keyof S & string)[], Client = Record<never, never>> = (abstract new (persisted: Persisted, services: Client) => DeclaredStore<StateOf<S>, Client>) & {
+    readonly config: StoreConfig<S, P>;
+};
+export declare function defineStore<Client>(): <S extends StateSpec = Record<never, never>, const P extends readonly (keyof S & string)[] = []>(config: StoreConfig<S, P>) => StoreClass<S, P, Client>;
+export type Snapshots<Group> = {
+    [Key in keyof Group]: Group[Key] extends {
+        readonly state: infer State;
+    } ? State : never;
+};
+export declare function snapshotsOf<Group extends Record<string, {
+    readonly state: object;
+}>>(group: Group): Snapshots<Group>;

package/dist/store.js

@@ -0,0 +1,208 @@
+import { restore } from "./state.js";
+import { Subscribers } from "./subscribers.js";
+export function isDevelopment() {
+    return import.meta.env?.DEV === true;
+}
+export function plainJsonProblem(value, path) {
+    if (value === null || value === undefined)
+        return undefined;
+    if (typeof value === 'string' || typeof value === 'boolean')
+        return undefined;
+    if (typeof value === 'number') {
+        return Number.isFinite(value) ? undefined : `${path} is ${String(value)}`;
+    }
+    if (Array.isArray(value)) {
+        for (const [index, item] of value.entries()) {
+            const problem = plainJsonProblem(item, `${path}[${index}]`);
+            if (problem !== undefined)
+                return problem;
+        }
+        return undefined;
+    }
+    if (typeof value === 'object') {
+        const prototype = Object.getPrototypeOf(value);
+        if (prototype !== Object.prototype && prototype !== null) {
+            return `${path} is a ${value.constructor.name}`;
+        }
+        for (const [key, item] of Object.entries(value)) {
+            const problem = plainJsonProblem(item, `${path}.${key}`);
+            if (problem !== undefined)
+                return problem;
+        }
+        return undefined;
+    }
+    return `${path} is a ${typeof value}`;
+}
+export function keepEqualParts(previous, next) {
+    if (Object.is(previous, next))
+        return next;
+    if (typeof previous !== 'object' ||
+        typeof next !== 'object' ||
+        previous === null ||
+        next === null ||
+        Array.isArray(previous) !== Array.isArray(next)) {
+        return next;
+    }
+    const previousKeys = Object.keys(previous);
+    const nextKeys = Object.keys(next);
+    let allSame = previousKeys.length === nextKeys.length;
+    const merged = Array.isArray(next)
+        ? Array.from({ length: next.length })
+        : {};
+    for (const key of nextKeys) {
+        const kept = keepEqualParts(Reflect.get(previous, key), Reflect.get(next, key));
+        merged[key] = kept;
+        if (!Object.is(kept, Reflect.get(previous, key)))
+            allSame = false;
+    }
+    return allSame ? previous : merged;
+}
+let tracking;
+let building = 0;
+const unproxied = new WeakMap();
+export function tracked(run) {
+    const outer = tracking;
+    const reads = new Map();
+    const session = { reads, isLive: true };
+    tracking = session;
+    try {
+        const value = run();
+        const plain = typeof value === 'object' && value !== null
+            ? unproxied.get(value)
+            : undefined;
+        return { value: plain ?? value, reads };
+    }
+    finally {
+        session.isLive = false;
+        tracking = outer;
+    }
+}
+export function mergeReads(from) {
+    if (tracking === undefined)
+        return;
+    for (const [store, keys] of from) {
+        const into = tracking.reads.get(store) ?? new Map();
+        for (const [key, value] of keys)
+            into.set(key, value);
+        tracking.reads.set(store, into);
+    }
+}
+export function readsAreCurrent(reads) {
+    for (const [store, keys] of reads) {
+        const state = store.currentState;
+        for (const [key, value] of keys) {
+            if (!Object.is(Reflect.get(state, key), value))
+                return false;
+        }
+    }
+    return true;
+}
+export function whileBuilding(run) {
+    building += 1;
+    try {
+        return run();
+    }
+    finally {
+        building -= 1;
+    }
+}
+export function assertNotBuilding(what) {
+    if (building > 0) {
+        throw new Error(`A getter tried to ${what}. Getters only work answers out from state and stores; put changes in a command.`);
+    }
+}
+function hasChanges(state, patch) {
+    return Object.entries(patch).some(([key, value]) => !Object.is(state[key], value));
+}
+export class StoreBase {
+    deps;
+    #state;
+    #subscribers = new Subscribers();
+    constructor(...args) {
+        this.deps = args[0];
+    }
+    get state() {
+        const state = this.currentState;
+        const session = tracking;
+        if (session === undefined)
+            return state;
+        const reads = session.reads.get(this) ?? new Map();
+        session.reads.set(this, reads);
+        const proxy = new Proxy(state, {
+            get(target, key) {
+                const value = Reflect.get(target, key);
+                if (session.isLive && typeof key === 'string')
+                    reads.set(key, value);
+                return value;
+            }
+        });
+        unproxied.set(proxy, state);
+        return proxy;
+    }
+    get currentState() {
+        this.#state ??= this.initialState();
+        return this.#state;
+    }
+    subscribe = (listener) => this.#subscribers.subscribe(listener);
+    set(patch) {
+        assertNotBuilding(`change ${this.constructor.name}`);
+        const state = this.currentState;
+        if (!hasChanges(state, patch))
+            return;
+        this.#state = { ...state, ...patch };
+        if (isDevelopment()) {
+            const problem = plainJsonProblem(this.#state, 'state');
+            if (problem !== undefined) {
+                throw new Error(`${this.constructor.name} state must be plain JSON, because flows compare it and the cache stores it: ${problem}`);
+            }
+        }
+        this.changed();
+    }
+    changed() {
+        this.#subscribers.notify();
+    }
+}
+export class DeclaredStore extends StoreBase {
+    services;
+    constructor(services) {
+        super();
+        this.services = services;
+    }
+    initialState() {
+        throw new Error(`${this.constructor.name} must extend Store({ state }) so its first state comes from the config`);
+    }
+}
+export function defineStore() {
+    return function Store(config) {
+        return declaredStore(config);
+    };
+}
+function declaredStore(config) {
+    const persist = config.persist ?? [];
+    class Declared extends DeclaredStore {
+        static config = config;
+        #persisted;
+        constructor(persisted, services) {
+            super(services);
+            this.#persisted = persisted;
+        }
+        initialState() {
+            return restore(config.state ?? {}, persist, this.#persisted);
+        }
+        set(patch) {
+            super.set(patch);
+            for (const key of persist) {
+                if (key in patch)
+                    this.#persisted.write(key, this.state[key]);
+            }
+        }
+    }
+    return Declared;
+}
+export function snapshotsOf(group) {
+    const entries = Object.entries(group).map(([key, store]) => [
+        key,
+        store.state
+    ]);
+    return Object.fromEntries(entries);
+}

package/dist/subscribers.d.ts

@@ -0,0 +1,5 @@
+export declare class Subscribers {
+    #private;
+    readonly subscribe: (listener: () => void) => (() => void);
+    notify(): void;
+}

package/dist/subscribers.js

@@ -0,0 +1,13 @@
+export class Subscribers {
+    #listeners = new Set();
+    subscribe = (listener) => {
+        this.#listeners.add(listener);
+        return () => {
+            this.#listeners.delete(listener);
+        };
+    };
+    notify() {
+        for (const listener of this.#listeners)
+            listener();
+    }
+}

package/dist/table.d.ts

@@ -0,0 +1,143 @@
+import { z } from 'zod';
+import type { SameOnTheWire } from './wire.ts';
+export type Value = string | number | boolean | null;
+export type Columns = Record<string, z.ZodType<Value>>;
+export type Level = 'anyone' | 'signedIn' | 'owner' | 'admin' | 'server';
+export type Access = {
+    readonly read: Level;
+    readonly create: Level;
+    readonly update: Level;
+    readonly delete: Level;
+};
+export type Writes = 'optimistic' | 'confirmed';
+export type TableDefinition = {
+    readonly columns: Columns;
+    readonly access: Access;
+    readonly writes: Writes;
+    readonly owned?: boolean;
+    readonly public?: readonly string[];
+    readonly unique?: readonly (readonly string[])[];
+};
+type OwnerColumn<Owned> = [Owned] extends [true] ? {
+    ownerId: z.ZodString;
+} : Record<never, never>;
+export type Table = {
+    readonly name: string;
+    readonly columns: Columns;
+    readonly access: Access;
+    readonly writes: Writes;
+    readonly owned: boolean;
+    readonly public: readonly string[];
+    readonly unique: readonly (readonly string[])[];
+    readonly fields: z.ZodObject<Columns>;
+    readonly incoming: z.ZodObject<{
+        id: z.ZodString;
+    } & Columns>;
+    readonly row: z.ZodObject<{
+        id: z.ZodString;
+        createdAt: z.ZodString;
+    } & Columns>;
+    readonly publicRow: z.ZodObject<{
+        id: z.ZodString;
+    } & Columns>;
+};
+export type TableOf<Name extends string, Definition extends TableDefinition> = {
+    readonly name: Name;
+    readonly columns: Definition['columns'];
+    readonly access: Definition['access'];
+    readonly writes: Definition['writes'];
+    readonly owned: Definition['owned'] extends true ? true : false;
+    readonly public: readonly PublicColumn<Definition>[];
+    readonly unique: readonly (readonly string[])[];
+    readonly fields: z.ZodObject<Definition['columns']>;
+    readonly incoming: z.ZodObject<{
+        id: z.ZodString;
+    } & Definition['columns']>;
+    readonly row: z.ZodObject<{
+        id: z.ZodString;
+        createdAt: z.ZodString;
+    } & OwnerColumn<Definition['owned']> & Definition['columns']>;
+    readonly publicRow: z.ZodObject<{
+        id: z.ZodString;
+    } & Pick<{
+        createdAt: z.ZodString;
+    } & Definition['columns'], PublicColumn<Definition>>>;
+};
+type PublicColumn<Definition extends TableDefinition> = Definition['public'] extends readonly (infer Column)[] ? Column & (keyof Definition['columns'] | 'createdAt') & string : never;
+export type Fields<T extends Table> = z.output<T['fields']>;
+type OwnerOf<T extends Table> = T['owned'] extends true ? {
+    ownerId: string;
+} : Record<never, never>;
+export type Row<T extends Table> = {
+    id: string;
+    createdAt: string;
+} & OwnerOf<T> & Fields<T>;
+export type PublicRow<T extends Table> = {
+    id: string;
+} & Pick<{
+    createdAt: string;
+} & Fields<T>, T['public'][number] & ('createdAt' | keyof Fields<T>)>;
+export type Tables = Record<string, Table>;
+export type SeedRow<T extends Table> = {
+    id: string;
+} & (T['owned'] extends true ? {
+    owner: string;
+} : Record<never, never>) & Fields<T>;
+export type Seed<Group extends Tables> = {
+    [Key in keyof Group]?: readonly SeedRow<Group[Key]>[];
+};
+export type TablesOf<Definitions extends Record<string, DraftTable>> = {
+    [Key in keyof Definitions & string]: Definitions[Key] extends TableDefinition ? TableOf<Key, Definitions[Key]> : Table;
+};
+type DraftTable = {
+    readonly columns: Columns;
+    readonly access?: Partial<Access>;
+    readonly writes?: Writes;
+    readonly owned?: boolean;
+    readonly public?: readonly string[];
+    readonly unique?: readonly (readonly string[])[];
+};
+type StaticTypeError<Message extends string> = Message;
+type IsOwned<Definition> = Definition extends {
+    readonly owned: true;
+} ? true : false;
+type HasUnique<Definition> = Definition extends {
+    readonly unique: readonly [unknown, ...unknown[]];
+} ? true : false;
+type ReadOf<Definition> = Definition extends {
+    readonly access: {
+        readonly read: infer Read;
+    };
+} ? Read : never;
+type ColumnOf<Definition> = Definition extends {
+    readonly columns: infer C;
+} ? keyof C & string : never;
+type OwnerNeedsOwned = StaticTypeError<"'owner' needs owned: true on this table, so every row records who made it">;
+type CreateIsNeverOwner = StaticTypeError<"create can't be 'owner': nobody owns a row before it exists. Use 'signedIn' and the person who creates it becomes its owner">;
+type OwnedNeedsSignedInCreate = StaticTypeError<"An owned table can't let anyone create rows: a signed-out visitor has no account to own the row. Use 'signedIn'">;
+type UniqueNeedsConfirmed = StaticTypeError<"This table has a unique constraint, so the server can refuse a write. Declare writes: 'confirmed' so the screen waits for the server instead of showing a row that then disappears">;
+type PublicNeedsPrivateRead = StaticTypeError<"public only matters when read is stricter than 'anyone': with read: 'anyone' every column is already public">;
+type AccessIsRequired = StaticTypeError<"Every table says who may read, create, update and delete its rows: add access: { read, create, update, delete }, each 'anyone', 'signedIn', 'owner', 'admin' or 'server'">;
+type EveryOperation = StaticTypeError<'access names all four operations: read, create, update and delete'>;
+type WritesIsRequired = StaticTypeError<"Every table says whether a write shows at once or waits for the server: add writes: 'optimistic' or writes: 'confirmed'">;
+type Missing<Shape, Required extends string, Message> = {
+    [Key in Exclude<Required, keyof Shape>]: Message;
+};
+type OwnerIdIsPattern = StaticTypeError<'Pattern adds ownerId to owned tables and fills it from the session: remove this column and set owned: true'>;
+type CheckedLevel<Definition, Operation, Chosen> = Chosen extends 'owner' ? Operation extends 'create' ? CreateIsNeverOwner : IsOwned<Definition> extends true ? Chosen : OwnerNeedsOwned : Operation extends 'create' ? Chosen extends 'anyone' ? IsOwned<Definition> extends true ? OwnedNeedsSignedInCreate : Chosen : Chosen : Chosen;
+type CheckedAccess<Definition, A> = {
+    [Operation in keyof A]: CheckedLevel<Definition, Operation, A[Operation]>;
+} & Missing<A, keyof Access, EveryOperation>;
+type CheckedColumns<C> = {
+    [Key in keyof C]: Key extends 'ownerId' ? OwnerIdIsPattern : C[Key];
+};
+type CheckedTable<Definition> = {
+    [Key in keyof Definition]: Key extends 'columns' ? CheckedColumns<SameOnTheWire<Definition[Key] & z.ZodRawShape>> : Key extends 'access' ? CheckedAccess<Definition, Definition[Key]> : Key extends 'writes' ? HasUnique<Definition> extends true ? Definition[Key] extends 'confirmed' ? Definition[Key] : UniqueNeedsConfirmed : Definition[Key] : Key extends 'public' ? ReadOf<Definition> extends 'anyone' ? PublicNeedsPrivateRead : Definition[Key] & readonly (ColumnOf<Definition> | 'createdAt')[] : Key extends 'unique' ? Definition[Key] & readonly (readonly ColumnOf<Definition>[])[] : Definition[Key];
+} & Missing<Definition, 'access', AccessIsRequired> & Missing<Definition, 'writes', WritesIsRequired>;
+export declare function defineTables<const Definitions extends Record<string, DraftTable> = Record<never, never>>(definitions: {
+    [Key in keyof Definitions]: CheckedTable<Definitions[Key]>;
+}): TablesOf<Definitions>;
+export declare function ownerIdOf(email: string): string;
+export declare function seededRows(seed: Seed<Tables>, name: string): readonly Row<Table>[];
+export declare function snakeCase(name: string): string;
+export {};