@fuzdev/fuz_app 0.67.1 → 0.68.0

package/dist/auth/cell_action_specs.d.ts

@@ -0,0 +1,1295 @@
+/**
+ * Cell RPC action specs — the declarative contract for the six generic
+ * cell verbs. App vocabulary (galleries, posts, events) lives in
+ * client-side helpers; the wire stays generic.
+ *
+ * @module
+ */
+import { z } from 'zod';
+import { cell_grant_create_action_spec, cell_grant_revoke_action_spec, cell_grant_list_action_spec } from './cell_grant_action_specs.js';
+import { cell_field_set_action_spec, cell_field_delete_action_spec, cell_field_list_action_spec } from './cell_field_action_specs.js';
+import { cell_item_insert_action_spec, cell_item_move_action_spec, cell_item_delete_action_spec, cell_item_list_action_spec } from './cell_item_action_specs.js';
+import { cell_audit_list_action_spec } from './cell_audit_action_specs.js';
+/**
+ * Cell visibility — the coarse-grained access-control axis for a cell.
+ * Sibling to `cell_grant` (the fine-grained allowlist of actor- /
+ * role-shaped principals at `viewer` / `editor` levels). Together they
+ * form the cell-layer access-control surface:
+ *
+ * - `cell.visibility = 'public'` admits everyone, including
+ *   unauthenticated visitors. `cell_grant` rows still apply for edit-
+ *   level admit; read is universal.
+ * - `cell.visibility = 'private'` (default) restricts read to admin /
+ *   owner (`created_by`) / `cell_grant`-admitted callers.
+ *
+ * Stored as a top-level PG enum column (`cell.visibility`) — NOT inside
+ * `cell.data`, which is content metadata only. `can_view_cell` reads
+ * the column directly.
+ */
+export declare const CellVisibility: z.ZodEnum<{
+    private: "private";
+    public: "public";
+}>;
+export type CellVisibility = z.infer<typeof CellVisibility>;
+export { cell_grant_create_action_spec, cell_grant_revoke_action_spec, cell_grant_list_action_spec };
+export { cell_field_set_action_spec, cell_field_delete_action_spec, cell_field_list_action_spec };
+export { cell_item_insert_action_spec, cell_item_move_action_spec, cell_item_delete_action_spec, cell_item_list_action_spec, };
+export { cell_audit_list_action_spec };
+/** Error reason — cell id did not resolve, or caller can't view it. */
+export declare const ERROR_CELL_NOT_FOUND: "cell_not_found";
+/** Error reason — caller is not an admin and supplied a `path` write. */
+export declare const ERROR_CELL_PATH_ADMIN_ONLY: "cell_path_admin_only";
+/**
+ * Error reason — a `path` write collided with an existing active cell's
+ * path. `path` is globally unique on active rows (`idx_cell_path_unique`);
+ * the create / update handlers translate the unique-index violation into
+ * this `conflict` (409) reason rather than leaking a raw internal error.
+ * Soft-deleted rows free their path (the index is partial on
+ * `deleted_at IS NULL`), so reusing a deleted cell's path does not collide.
+ */
+export declare const ERROR_CELL_PATH_TAKEN: "cell_path_taken";
+/**
+ * Error reason — caller tried to write `cell.visibility` without the
+ * manage tier (`can_manage_cell` = admin / owner). Editor-grant holders
+ * may edit `data` but cannot flip a cell's visibility — that is a
+ * manage-tier-only operation.
+ */
+export declare const ERROR_CELL_VISIBILITY_MANAGE_ONLY: "cell_visibility_manage_only";
+/** Error reason — input shape for `cell_get` lacked both `id` and `path`. */
+export declare const ERROR_CELL_GET_REQUIRES_ID_OR_PATH: "cell_get_requires_id_or_path";
+/**
+ * Error reason — `cell_clone` `with_data_patch` would change `data.kind`.
+ * Per-kind shape validation can pass coincidentally (e.g., one kind's
+ * schema accepts most of another's fields), so we reject the cross-kind
+ * patch explicitly to prevent incoherent clones.
+ */
+export declare const ERROR_CELL_CLONE_KIND_MISMATCH: "cell_clone_kind_mismatch";
+/**
+ * Error reason — null-auth `cell_list` caller passed a `created_by`
+ * filter. The filter is a soft account-id enumeration vector ("does
+ * account X have any public cells?"), so we require an authenticated
+ * caller to use it.
+ */
+export declare const ERROR_CELL_LIST_CREATED_BY_REQUIRES_AUTH: "cell_list_created_by_requires_auth";
+/**
+ * Error reason — null-auth `cell_list` caller passed `shared_with: 'me'`.
+ * The filter resolves to the caller's account + role_grants, which only
+ * exist for an authenticated session.
+ */
+export declare const ERROR_CELL_LIST_SHARED_WITH_REQUIRES_AUTH: "cell_list_shared_with_requires_auth";
+/**
+ * Wire form for `cell.path`.
+ *
+ * At the spec level we only enforce that the value is a non-empty string
+ * with a sane upper bound — the cell layer is generic and doesn't impose
+ * a path grammar. App-side curation (well-known names like `/map/main`,
+ * `/site/events`) is admin-driven.
+ */
+export declare const CELL_PATH_LENGTH_MAX = 256;
+/**
+ * Branded so the type system distinguishes a validated path from any other
+ * string. Construct via `CellPath.parse(s)` at external boundaries; the
+ * RPC dispatcher does this automatically when the wire schema (`CellCreateInput`,
+ * `CellGetInput`, `CellUpdateInput`, `CellListInput`) is parsed at the entry
+ * point. Frontend callers handing a raw string to `api.cell_*` cast at the
+ * callsite (`as CellPath`) — the runtime check still runs server-side.
+ */
+export declare const CellPath: z.core.$ZodBranded<z.ZodString, "CellPath", "out">;
+export type CellPath = z.infer<typeof CellPath>;
+/**
+ * Soft cap on the size of a `cell.list` request page. Larger pages chew
+ * memory both server- and client-side; combined with the visibility
+ * predicate's filter cost, 200 is a safe ceiling.
+ */
+export declare const CELL_LIST_LIMIT_MAX = 200;
+export declare const CELL_LIST_LIMIT_DEFAULT = 50;
+/**
+ * Hard cap on bundled relation arrays in `cell_get` (per-relation
+ * `LIMIT`). Beyond this the response sets `*_truncated: true` and the
+ * client paginates via `cell_item_list({parent_id, position_after})` /
+ * `cell_field_list({source_id, name_after})`.
+ */
+export declare const CELL_RELATIONS_BUNDLE_LIMIT = 500;
+/**
+ * Wire form for a cell row. `data` is the typed-but-permissive `CellData`
+ * shape (kind / label / summary typed-and-optional, additional fields
+ * pass through). Per-kind shape validation is sub-API and handled by
+ * the app's `validate_data` deps callback (see `cell_actions.ts`).
+ *
+ * `visibility` is the access-control axis — a top-level column on the
+ * row, not a field inside `data`. `cell_grant` and `visibility` are the
+ * two ACL surfaces; both live as peers, not embedded in content.
+ *
+ * `path` is the global namespace axis (no tenant/hub scoping).
+ *
+ * Relations (`items`, `fields`) are NOT carried on the cell row — they
+ * live in the `cell_item` / `cell_field` sibling tables. Bundled arrays
+ * appear on `CellGetOutput`; other read verbs (`cell_list`) do not bundle.
+ */
+export declare const CellJson: z.ZodObject<{
+    id: z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">;
+    path: z.ZodNullable<z.core.$ZodBranded<z.ZodString, "CellPath", "out">>;
+    data: z.ZodObject<{
+        kind: z.ZodOptional<z.ZodString>;
+        label: z.ZodOptional<z.ZodString>;
+        summary: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>;
+    visibility: z.ZodEnum<{
+        private: "private";
+        public: "public";
+    }>;
+    refs: z.ZodNullable<z.ZodArray<z.core.$ZodBranded<z.ZodString, "FactHash", "out">>>;
+    created_by: z.ZodNullable<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
+    updated_by: z.ZodNullable<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
+    created_at: z.ZodString;
+    updated_at: z.ZodNullable<z.ZodString>;
+    deleted_at: z.ZodNullable<z.ZodString>;
+    grant_count: z.ZodNumber;
+}, z.core.$strict>;
+export type CellJson = z.infer<typeof CellJson>;
+/**
+ * Input for `cell_create`. `created_by` is NOT on the wire — the handler
+ * stamps it from auth.actor.id. `path` is admin-only; non-admin callers
+ * supplying `path` get `ERROR_CELL_PATH_ADMIN_ONLY` (forbidden).
+ */
+export declare const CellCreateInput: z.ZodObject<{
+    data: z.ZodObject<{
+        kind: z.ZodOptional<z.ZodString>;
+        label: z.ZodOptional<z.ZodString>;
+        summary: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>;
+    visibility: z.ZodOptional<z.ZodEnum<{
+        private: "private";
+        public: "public";
+    }>>;
+    path: z.ZodOptional<z.ZodNullable<z.core.$ZodBranded<z.ZodString, "CellPath", "out">>>;
+    acting: z.ZodOptional<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
+}, z.core.$strict>;
+export type CellCreateInput = z.infer<typeof CellCreateInput>;
+export declare const CellCreateOutput: z.ZodObject<{
+    cell: z.ZodObject<{
+        id: z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">;
+        path: z.ZodNullable<z.core.$ZodBranded<z.ZodString, "CellPath", "out">>;
+        data: z.ZodObject<{
+            kind: z.ZodOptional<z.ZodString>;
+            label: z.ZodOptional<z.ZodString>;
+            summary: z.ZodOptional<z.ZodString>;
+        }, z.core.$loose>;
+        visibility: z.ZodEnum<{
+            private: "private";
+            public: "public";
+        }>;
+        refs: z.ZodNullable<z.ZodArray<z.core.$ZodBranded<z.ZodString, "FactHash", "out">>>;
+        created_by: z.ZodNullable<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
+        updated_by: z.ZodNullable<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
+        created_at: z.ZodString;
+        updated_at: z.ZodNullable<z.ZodString>;
+        deleted_at: z.ZodNullable<z.ZodString>;
+        grant_count: z.ZodNumber;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type CellCreateOutput = z.infer<typeof CellCreateOutput>;
+/**
+ * Input for `cell_get`. Pass `id` OR `path` (exactly one expected; both
+ * accepted, `id` takes precedence). The handler responds with 404 when no
+ * row matches OR when `can_view_cell` rejects the caller — same code so
+ * private-cell existence doesn't leak.
+ */
+export declare const CellGetInput: z.ZodObject<{
+    id: z.ZodOptional<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
+    path: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "CellPath", "out">>;
+    acting: z.ZodOptional<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
+}, z.core.$strict>;
+export type CellGetInput = z.infer<typeof CellGetInput>;
+/**
+ * Output for `cell_get`. Bundles relation arrays (`fields` + `items`)
+ * server-side via JOINs so the common "show this cell with its
+ * children" flow needs one round-trip. Targets are filtered to those the
+ * caller may view (strict target-visibility). Per-relation `LIMIT
+ * CELL_RELATIONS_BUNDLE_LIMIT`; clients paginate via
+ * `cell_item_list({parent_id, position_after})` /
+ * `cell_field_list({source_id})` when truncated.
+ */
+export declare const CellGetOutput: z.ZodObject<{
+    cell: z.ZodObject<{
+        id: z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">;
+        path: z.ZodNullable<z.core.$ZodBranded<z.ZodString, "CellPath", "out">>;
+        data: z.ZodObject<{
+            kind: z.ZodOptional<z.ZodString>;
+            label: z.ZodOptional<z.ZodString>;
+            summary: z.ZodOptional<z.ZodString>;
+        }, z.core.$loose>;
+        visibility: z.ZodEnum<{
+            private: "private";
+            public: "public";
+        }>;
+        refs: z.ZodNullable<z.ZodArray<z.core.$ZodBranded<z.ZodString, "FactHash", "out">>>;
+        created_by: z.ZodNullable<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
+        updated_by: z.ZodNullable<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
+        created_at: z.ZodString;
+        updated_at: z.ZodNullable<z.ZodString>;
+        deleted_at: z.ZodNullable<z.ZodString>;
+        grant_count: z.ZodNumber;
+    }, z.core.$strict>;
+    fields: z.ZodArray<z.ZodObject<{
+        source_id: z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">;
+        name: z.ZodString;
+        target_id: z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">;
+        created_at: z.ZodString;
+    }, z.core.$strict>>;
+    fields_truncated: z.ZodBoolean;
+    items: z.ZodArray<z.ZodObject<{
+        parent_id: z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">;
+        position: z.core.$ZodBranded<z.ZodString, "CellItemPosition", "out">;
+        child_id: z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">;
+        created_at: z.ZodString;
+    }, z.core.$strict>>;
+    items_truncated: z.ZodBoolean;
+    can_edit: z.ZodBoolean;
+    can_grant: z.ZodBoolean;
+}, z.core.$strict>;
+export type CellGetOutput = z.infer<typeof CellGetOutput>;
+/**
+ * Input for `cell_update`. Fields left undefined keep their existing value.
+ * `path` writes are admin-only (handler-enforced); non-admin callers
+ * supplying `path` get `ERROR_CELL_PATH_ADMIN_ONLY` even if no other field
+ * is changing. `visibility` writes require the manage tier
+ * (`can_manage_cell` = admin / owner) — editor-grant holders editing
+ * `data` cannot flip visibility (`ERROR_CELL_VISIBILITY_MANAGE_ONLY`).
+ */
+export declare const CellUpdateInput: z.ZodObject<{
+    cell_id: z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">;
+    data: z.ZodOptional<z.ZodObject<{
+        kind: z.ZodOptional<z.ZodString>;
+        label: z.ZodOptional<z.ZodString>;
+        summary: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>>;
+    visibility: z.ZodOptional<z.ZodEnum<{
+        private: "private";
+        public: "public";
+    }>>;
+    path: z.ZodOptional<z.ZodNullable<z.core.$ZodBranded<z.ZodString, "CellPath", "out">>>;
+    acting: z.ZodOptional<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
+}, z.core.$strict>;
+export type CellUpdateInput = z.infer<typeof CellUpdateInput>;
+export declare const CellUpdateOutput: z.ZodObject<{
+    cell: z.ZodObject<{
+        id: z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">;
+        path: z.ZodNullable<z.core.$ZodBranded<z.ZodString, "CellPath", "out">>;
+        data: z.ZodObject<{
+            kind: z.ZodOptional<z.ZodString>;
+            label: z.ZodOptional<z.ZodString>;
+            summary: z.ZodOptional<z.ZodString>;
+        }, z.core.$loose>;
+        visibility: z.ZodEnum<{
+            private: "private";
+            public: "public";
+        }>;
+        refs: z.ZodNullable<z.ZodArray<z.core.$ZodBranded<z.ZodString, "FactHash", "out">>>;
+        created_by: z.ZodNullable<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
+        updated_by: z.ZodNullable<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
+        created_at: z.ZodString;
+        updated_at: z.ZodNullable<z.ZodString>;
+        deleted_at: z.ZodNullable<z.ZodString>;
+        grant_count: z.ZodNumber;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type CellUpdateOutput = z.infer<typeof CellUpdateOutput>;
+export declare const CellDeleteInput: z.ZodObject<{
+    cell_id: z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">;
+    acting: z.ZodOptional<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
+}, z.core.$strict>;
+export type CellDeleteInput = z.infer<typeof CellDeleteInput>;
+export declare const CellDeleteOutput: z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+    deleted: z.ZodBoolean;
+}, z.core.$strict>;
+export type CellDeleteOutput = z.infer<typeof CellDeleteOutput>;
+/**
+ * Input for `cell_list`. Filters are optional and combine with AND. The
+ * handler applies the SQL-side visibility predicate from
+ * `query_cell_list` so the page-window stays correct under pagination —
+ * post-filtering in JS would silently truncate pages.
+ *
+ * `ids` is the batch-read filter — pass a list of cell ids to fetch them
+ * in one round-trip (avoids N+1 when rendering a collection's `items[]`).
+ * The visibility predicate still runs, so callers passing ids they can't
+ * view simply get fewer rows back. Capped at `CELL_LIST_LIMIT_MAX`.
+ *
+ * `shared_with: 'me'` narrows to cells that admit the caller via a
+ * `cell_grant` row (actor-shaped or role-shaped principal) AND that
+ * the caller does not own. Authenticated only; combine with
+ * `data_kind` / `path_prefix` etc. to scope further. Combining with
+ * `created_by: <my-actor-id>` produces an empty result by definition
+ * (owner is implicit, never appears as a grant principal); we don't
+ * reject the combination at the schema layer because SQL emptiness is
+ * correct.
+ */
+export declare const CellListInput: z.ZodDefault<z.ZodObject<{
+    ids: z.ZodOptional<z.ZodArray<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>>;
+    data_kind: z.ZodOptional<z.ZodString>;
+    visibility: z.ZodOptional<z.ZodEnum<{
+        private: "private";
+        public: "public";
+    }>>;
+    ref: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "FactHash", "out">>;
+    created_by: z.ZodOptional<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
+    path_prefix: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "CellPath", "out">>;
+    shared_with: z.ZodOptional<z.ZodLiteral<"me">>;
+    order_by: z.ZodOptional<z.ZodEnum<{
+        created_at: "created_at";
+        updated_at: "updated_at";
+    }>>;
+    order_direction: z.ZodOptional<z.ZodEnum<{
+        asc: "asc";
+        desc: "desc";
+    }>>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    offset: z.ZodOptional<z.ZodNumber>;
+    acting: z.ZodOptional<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
+}, z.core.$strict>>;
+export type CellListInput = z.infer<typeof CellListInput>;
+export declare const CellListOutput: z.ZodObject<{
+    cells: z.ZodArray<z.ZodObject<{
+        id: z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">;
+        path: z.ZodNullable<z.core.$ZodBranded<z.ZodString, "CellPath", "out">>;
+        data: z.ZodObject<{
+            kind: z.ZodOptional<z.ZodString>;
+            label: z.ZodOptional<z.ZodString>;
+            summary: z.ZodOptional<z.ZodString>;
+        }, z.core.$loose>;
+        visibility: z.ZodEnum<{
+            private: "private";
+            public: "public";
+        }>;
+        refs: z.ZodNullable<z.ZodArray<z.core.$ZodBranded<z.ZodString, "FactHash", "out">>>;
+        created_by: z.ZodNullable<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
+        updated_by: z.ZodNullable<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
+        created_at: z.ZodString;
+        updated_at: z.ZodNullable<z.ZodString>;
+        deleted_at: z.ZodNullable<z.ZodString>;
+        grant_count: z.ZodNumber;
+    }, z.core.$strict>>;
+    cell_grants: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodObject<{
+        id: z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">;
+        cell_id: z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">;
+        level: z.ZodEnum<{
+            viewer: "viewer";
+            editor: "editor";
+        }>;
+        actor_id: z.ZodNullable<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
+        role: z.ZodNullable<z.ZodString>;
+        scope_id: z.ZodNullable<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
+        granted_by: z.ZodNullable<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
+        created_at: z.ZodString;
+    }, z.core.$strict>>>>;
+}, z.core.$strict>;
+export type CellListOutput = z.infer<typeof CellListOutput>;
+/**
+ * Input for `cell_clone`. Source must be view-admitted by `can_view_cell`
+ * (404 otherwise — IDOR mask). The clone is owned by the caller; `path`
+ * is always nulled (admin-only paths can't auto-clone). Provenance lives
+ * only in the `cell_clone` audit row's `source_id` — no provenance
+ * fields are stamped into `data`.
+ */
+export declare const CellCloneInput: z.ZodObject<{
+    source_id: z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">;
+    deep: z.ZodOptional<z.ZodBoolean>;
+    with_data_patch: z.ZodOptional<z.ZodObject<{
+        kind: z.ZodOptional<z.ZodString>;
+        label: z.ZodOptional<z.ZodString>;
+        summary: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>>;
+    acting: z.ZodOptional<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
+}, z.core.$strict>;
+export type CellCloneInput = z.infer<typeof CellCloneInput>;
+export declare const CellCloneOutput: z.ZodObject<{
+    cell: z.ZodObject<{
+        id: z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">;
+        path: z.ZodNullable<z.core.$ZodBranded<z.ZodString, "CellPath", "out">>;
+        data: z.ZodObject<{
+            kind: z.ZodOptional<z.ZodString>;
+            label: z.ZodOptional<z.ZodString>;
+            summary: z.ZodOptional<z.ZodString>;
+        }, z.core.$loose>;
+        visibility: z.ZodEnum<{
+            private: "private";
+            public: "public";
+        }>;
+        refs: z.ZodNullable<z.ZodArray<z.core.$ZodBranded<z.ZodString, "FactHash", "out">>>;
+        created_by: z.ZodNullable<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
+        updated_by: z.ZodNullable<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
+        created_at: z.ZodString;
+        updated_at: z.ZodNullable<z.ZodString>;
+        deleted_at: z.ZodNullable<z.ZodString>;
+        grant_count: z.ZodNumber;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type CellCloneOutput = z.infer<typeof CellCloneOutput>;
+export declare const cell_create_action_spec: {
+    method: string;
+    kind: "request_response";
+    initiator: "frontend";
+    auth: {
+        account: "required";
+        actor: "required";
+    };
+    side_effects: true;
+    input: z.ZodObject<{
+        data: z.ZodObject<{
+            kind: z.ZodOptional<z.ZodString>;
+            label: z.ZodOptional<z.ZodString>;
+            summary: z.ZodOptional<z.ZodString>;
+        }, z.core.$loose>;
+        visibility: z.ZodOptional<z.ZodEnum<{
+            private: "private";
+            public: "public";
+        }>>;
+        path: z.ZodOptional<z.ZodNullable<z.core.$ZodBranded<z.ZodString, "CellPath", "out">>>;
+        acting: z.ZodOptional<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
+    }, z.core.$strict>;
+    output: z.ZodObject<{
+        cell: z.ZodObject<{
+            id: z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">;
+            path: z.ZodNullable<z.core.$ZodBranded<z.ZodString, "CellPath", "out">>;
+            data: z.ZodObject<{
+                kind: z.ZodOptional<z.ZodString>;
+                label: z.ZodOptional<z.ZodString>;
+                summary: z.ZodOptional<z.ZodString>;
+            }, z.core.$loose>;
+            visibility: z.ZodEnum<{
+                private: "private";
+                public: "public";
+            }>;
+            refs: z.ZodNullable<z.ZodArray<z.core.$ZodBranded<z.ZodString, "FactHash", "out">>>;
+            created_by: z.ZodNullable<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
+            updated_by: z.ZodNullable<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
+            created_at: z.ZodString;
+            updated_at: z.ZodNullable<z.ZodString>;
+            deleted_at: z.ZodNullable<z.ZodString>;
+            grant_count: z.ZodNumber;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    async: true;
+    rate_limit: "account";
+    description: string;
+};
+export declare const cell_get_action_spec: {
+    method: string;
+    kind: "request_response";
+    initiator: "frontend";
+    auth: {
+        account: "optional";
+        actor: "optional";
+    };
+    side_effects: false;
+    input: z.ZodObject<{
+        id: z.ZodOptional<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
+        path: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "CellPath", "out">>;
+        acting: z.ZodOptional<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
+    }, z.core.$strict>;
+    output: z.ZodObject<{
+        cell: z.ZodObject<{
+            id: z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">;
+            path: z.ZodNullable<z.core.$ZodBranded<z.ZodString, "CellPath", "out">>;
+            data: z.ZodObject<{
+                kind: z.ZodOptional<z.ZodString>;
+                label: z.ZodOptional<z.ZodString>;
+                summary: z.ZodOptional<z.ZodString>;
+            }, z.core.$loose>;
+            visibility: z.ZodEnum<{
+                private: "private";
+                public: "public";
+            }>;
+            refs: z.ZodNullable<z.ZodArray<z.core.$ZodBranded<z.ZodString, "FactHash", "out">>>;
+            created_by: z.ZodNullable<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
+            updated_by: z.ZodNullable<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
+            created_at: z.ZodString;
+            updated_at: z.ZodNullable<z.ZodString>;
+            deleted_at: z.ZodNullable<z.ZodString>;
+            grant_count: z.ZodNumber;
+        }, z.core.$strict>;
+        fields: z.ZodArray<z.ZodObject<{
+            source_id: z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">;
+            name: z.ZodString;
+            target_id: z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">;
+            created_at: z.ZodString;
+        }, z.core.$strict>>;
+        fields_truncated: z.ZodBoolean;
+        items: z.ZodArray<z.ZodObject<{
+            parent_id: z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">;
+            position: z.core.$ZodBranded<z.ZodString, "CellItemPosition", "out">;
+            child_id: z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">;
+            created_at: z.ZodString;
+        }, z.core.$strict>>;
+        items_truncated: z.ZodBoolean;
+        can_edit: z.ZodBoolean;
+        can_grant: z.ZodBoolean;
+    }, z.core.$strict>;
+    async: true;
+    rate_limit: "ip";
+    description: string;
+};
+export declare const cell_update_action_spec: {
+    method: string;
+    kind: "request_response";
+    initiator: "frontend";
+    auth: {
+        account: "required";
+        actor: "required";
+    };
+    side_effects: true;
+    input: z.ZodObject<{
+        cell_id: z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">;
+        data: z.ZodOptional<z.ZodObject<{
+            kind: z.ZodOptional<z.ZodString>;
+            label: z.ZodOptional<z.ZodString>;
+            summary: z.ZodOptional<z.ZodString>;
+        }, z.core.$loose>>;
+        visibility: z.ZodOptional<z.ZodEnum<{
+            private: "private";
+            public: "public";
+        }>>;
+        path: z.ZodOptional<z.ZodNullable<z.core.$ZodBranded<z.ZodString, "CellPath", "out">>>;
+        acting: z.ZodOptional<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
+    }, z.core.$strict>;
+    output: z.ZodObject<{
+        cell: z.ZodObject<{
+            id: z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">;
+            path: z.ZodNullable<z.core.$ZodBranded<z.ZodString, "CellPath", "out">>;
+            data: z.ZodObject<{
+                kind: z.ZodOptional<z.ZodString>;
+                label: z.ZodOptional<z.ZodString>;
+                summary: z.ZodOptional<z.ZodString>;
+            }, z.core.$loose>;
+            visibility: z.ZodEnum<{
+                private: "private";
+                public: "public";
+            }>;
+            refs: z.ZodNullable<z.ZodArray<z.core.$ZodBranded<z.ZodString, "FactHash", "out">>>;
+            created_by: z.ZodNullable<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
+            updated_by: z.ZodNullable<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
+            created_at: z.ZodString;
+            updated_at: z.ZodNullable<z.ZodString>;
+            deleted_at: z.ZodNullable<z.ZodString>;
+            grant_count: z.ZodNumber;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    async: true;
+    description: string;
+};
+export declare const cell_delete_action_spec: {
+    method: string;
+    kind: "request_response";
+    initiator: "frontend";
+    auth: {
+        account: "required";
+        actor: "required";
+    };
+    side_effects: true;
+    input: z.ZodObject<{
+        cell_id: z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">;
+        acting: z.ZodOptional<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
+    }, z.core.$strict>;
+    output: z.ZodObject<{
+        ok: z.ZodLiteral<true>;
+        deleted: z.ZodBoolean;
+    }, z.core.$strict>;
+    async: true;
+    description: string;
+};
+export declare const cell_list_action_spec: {
+    method: string;
+    kind: "request_response";
+    initiator: "frontend";
+    auth: {
+        account: "optional";
+        actor: "optional";
+    };
+    side_effects: false;
+    input: z.ZodDefault<z.ZodObject<{
+        ids: z.ZodOptional<z.ZodArray<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>>;
+        data_kind: z.ZodOptional<z.ZodString>;
+        visibility: z.ZodOptional<z.ZodEnum<{
+            private: "private";
+            public: "public";
+        }>>;
+        ref: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "FactHash", "out">>;
+        created_by: z.ZodOptional<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
+        path_prefix: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "CellPath", "out">>;
+        shared_with: z.ZodOptional<z.ZodLiteral<"me">>;
+        order_by: z.ZodOptional<z.ZodEnum<{
+            created_at: "created_at";
+            updated_at: "updated_at";
+        }>>;
+        order_direction: z.ZodOptional<z.ZodEnum<{
+            asc: "asc";
+            desc: "desc";
+        }>>;
+        limit: z.ZodOptional<z.ZodNumber>;
+        offset: z.ZodOptional<z.ZodNumber>;
+        acting: z.ZodOptional<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
+    }, z.core.$strict>>;
+    output: z.ZodObject<{
+        cells: z.ZodArray<z.ZodObject<{
+            id: z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">;
+            path: z.ZodNullable<z.core.$ZodBranded<z.ZodString, "CellPath", "out">>;
+            data: z.ZodObject<{
+                kind: z.ZodOptional<z.ZodString>;
+                label: z.ZodOptional<z.ZodString>;
+                summary: z.ZodOptional<z.ZodString>;
+            }, z.core.$loose>;
+            visibility: z.ZodEnum<{
+                private: "private";
+                public: "public";
+            }>;
+            refs: z.ZodNullable<z.ZodArray<z.core.$ZodBranded<z.ZodString, "FactHash", "out">>>;
+            created_by: z.ZodNullable<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
+            updated_by: z.ZodNullable<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
+            created_at: z.ZodString;
+            updated_at: z.ZodNullable<z.ZodString>;
+            deleted_at: z.ZodNullable<z.ZodString>;
+            grant_count: z.ZodNumber;
+        }, z.core.$strict>>;
+        cell_grants: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodObject<{
+            id: z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">;
+            cell_id: z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">;
+            level: z.ZodEnum<{
+                viewer: "viewer";
+                editor: "editor";
+            }>;
+            actor_id: z.ZodNullable<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
+            role: z.ZodNullable<z.ZodString>;
+            scope_id: z.ZodNullable<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
+            granted_by: z.ZodNullable<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
+            created_at: z.ZodString;
+        }, z.core.$strict>>>>;
+    }, z.core.$strict>;
+    async: true;
+    rate_limit: "ip";
+    description: string;
+};
+export declare const cell_clone_action_spec: {
+    method: string;
+    kind: "request_response";
+    initiator: "frontend";
+    auth: {
+        account: "required";
+        actor: "required";
+    };
+    side_effects: true;
+    input: z.ZodObject<{
+        source_id: z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">;
+        deep: z.ZodOptional<z.ZodBoolean>;
+        with_data_patch: z.ZodOptional<z.ZodObject<{
+            kind: z.ZodOptional<z.ZodString>;
+            label: z.ZodOptional<z.ZodString>;
+            summary: z.ZodOptional<z.ZodString>;
+        }, z.core.$loose>>;
+        acting: z.ZodOptional<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
+    }, z.core.$strict>;
+    output: z.ZodObject<{
+        cell: z.ZodObject<{
+            id: z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">;
+            path: z.ZodNullable<z.core.$ZodBranded<z.ZodString, "CellPath", "out">>;
+            data: z.ZodObject<{
+                kind: z.ZodOptional<z.ZodString>;
+                label: z.ZodOptional<z.ZodString>;
+                summary: z.ZodOptional<z.ZodString>;
+            }, z.core.$loose>;
+            visibility: z.ZodEnum<{
+                private: "private";
+                public: "public";
+            }>;
+            refs: z.ZodNullable<z.ZodArray<z.core.$ZodBranded<z.ZodString, "FactHash", "out">>>;
+            created_by: z.ZodNullable<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
+            updated_by: z.ZodNullable<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
+            created_at: z.ZodString;
+            updated_at: z.ZodNullable<z.ZodString>;
+            deleted_at: z.ZodNullable<z.ZodString>;
+            grant_count: z.ZodNumber;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    async: true;
+    rate_limit: "account";
+    description: string;
+};
+/**
+ * All cell-layer action specs — composed by app registries. Bundles the
+ * six generic verbs (this module), the three `cell_grant_*` specs, the
+ * three `cell_field_*` specs, the four `cell_item_*` specs, and the
+ * `cell_audit_list` spec so codegen + UI clients see a single cell
+ * namespace.
+ */
+export declare const all_cell_action_specs: readonly [{
+    method: string;
+    kind: "request_response";
+    initiator: "frontend";
+    auth: {
+        account: "required";
+        actor: "required";
+    };
+    side_effects: true;
+    input: z.ZodObject<{
+        data: z.ZodObject<{
+            kind: z.ZodOptional<z.ZodString>;
+            label: z.ZodOptional<z.ZodString>;
+            summary: z.ZodOptional<z.ZodString>;
+        }, z.core.$loose>;
+        visibility: z.ZodOptional<z.ZodEnum<{
+            private: "private";
+            public: "public";
+        }>>;
+        path: z.ZodOptional<z.ZodNullable<z.core.$ZodBranded<z.ZodString, "CellPath", "out">>>;
+        acting: z.ZodOptional<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
+    }, z.core.$strict>;
+    output: z.ZodObject<{
+        cell: z.ZodObject<{
+            id: z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">;
+            path: z.ZodNullable<z.core.$ZodBranded<z.ZodString, "CellPath", "out">>;
+            data: z.ZodObject<{
+                kind: z.ZodOptional<z.ZodString>;
+                label: z.ZodOptional<z.ZodString>;
+                summary: z.ZodOptional<z.ZodString>;
+            }, z.core.$loose>;
+            visibility: z.ZodEnum<{
+                private: "private";
+                public: "public";
+            }>;
+            refs: z.ZodNullable<z.ZodArray<z.core.$ZodBranded<z.ZodString, "FactHash", "out">>>;
+            created_by: z.ZodNullable<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
+            updated_by: z.ZodNullable<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
+            created_at: z.ZodString;
+            updated_at: z.ZodNullable<z.ZodString>;
+            deleted_at: z.ZodNullable<z.ZodString>;
+            grant_count: z.ZodNumber;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    async: true;
+    rate_limit: "account";
+    description: string;
+}, {
+    method: string;
+    kind: "request_response";
+    initiator: "frontend";
+    auth: {
+        account: "optional";
+        actor: "optional";
+    };
+    side_effects: false;
+    input: z.ZodObject<{
+        id: z.ZodOptional<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
+        path: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "CellPath", "out">>;
+        acting: z.ZodOptional<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
+    }, z.core.$strict>;
+    output: z.ZodObject<{
+        cell: z.ZodObject<{
+            id: z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">;
+            path: z.ZodNullable<z.core.$ZodBranded<z.ZodString, "CellPath", "out">>;
+            data: z.ZodObject<{
+                kind: z.ZodOptional<z.ZodString>;
+                label: z.ZodOptional<z.ZodString>;
+                summary: z.ZodOptional<z.ZodString>;
+            }, z.core.$loose>;
+            visibility: z.ZodEnum<{
+                private: "private";
+                public: "public";
+            }>;
+            refs: z.ZodNullable<z.ZodArray<z.core.$ZodBranded<z.ZodString, "FactHash", "out">>>;
+            created_by: z.ZodNullable<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
+            updated_by: z.ZodNullable<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
+            created_at: z.ZodString;
+            updated_at: z.ZodNullable<z.ZodString>;
+            deleted_at: z.ZodNullable<z.ZodString>;
+            grant_count: z.ZodNumber;
+        }, z.core.$strict>;
+        fields: z.ZodArray<z.ZodObject<{
+            source_id: z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">;
+            name: z.ZodString;
+            target_id: z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">;
+            created_at: z.ZodString;
+        }, z.core.$strict>>;
+        fields_truncated: z.ZodBoolean;
+        items: z.ZodArray<z.ZodObject<{
+            parent_id: z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">;
+            position: z.core.$ZodBranded<z.ZodString, "CellItemPosition", "out">;
+            child_id: z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">;
+            created_at: z.ZodString;
+        }, z.core.$strict>>;
+        items_truncated: z.ZodBoolean;
+        can_edit: z.ZodBoolean;
+        can_grant: z.ZodBoolean;
+    }, z.core.$strict>;
+    async: true;
+    rate_limit: "ip";
+    description: string;
+}, {
+    method: string;
+    kind: "request_response";
+    initiator: "frontend";
+    auth: {
+        account: "required";
+        actor: "required";
+    };
+    side_effects: true;
+    input: z.ZodObject<{
+        cell_id: z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">;
+        data: z.ZodOptional<z.ZodObject<{
+            kind: z.ZodOptional<z.ZodString>;
+            label: z.ZodOptional<z.ZodString>;
+            summary: z.ZodOptional<z.ZodString>;
+        }, z.core.$loose>>;
+        visibility: z.ZodOptional<z.ZodEnum<{
+            private: "private";
+            public: "public";
+        }>>;
+        path: z.ZodOptional<z.ZodNullable<z.core.$ZodBranded<z.ZodString, "CellPath", "out">>>;
+        acting: z.ZodOptional<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
+    }, z.core.$strict>;
+    output: z.ZodObject<{
+        cell: z.ZodObject<{
+            id: z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">;
+            path: z.ZodNullable<z.core.$ZodBranded<z.ZodString, "CellPath", "out">>;
+            data: z.ZodObject<{
+                kind: z.ZodOptional<z.ZodString>;
+                label: z.ZodOptional<z.ZodString>;
+                summary: z.ZodOptional<z.ZodString>;
+            }, z.core.$loose>;
+            visibility: z.ZodEnum<{
+                private: "private";
+                public: "public";
+            }>;
+            refs: z.ZodNullable<z.ZodArray<z.core.$ZodBranded<z.ZodString, "FactHash", "out">>>;
+            created_by: z.ZodNullable<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
+            updated_by: z.ZodNullable<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
+            created_at: z.ZodString;
+            updated_at: z.ZodNullable<z.ZodString>;
+            deleted_at: z.ZodNullable<z.ZodString>;
+            grant_count: z.ZodNumber;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    async: true;
+    description: string;
+}, {
+    method: string;
+    kind: "request_response";
+    initiator: "frontend";
+    auth: {
+        account: "required";
+        actor: "required";
+    };
+    side_effects: true;
+    input: z.ZodObject<{
+        cell_id: z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">;
+        acting: z.ZodOptional<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
+    }, z.core.$strict>;
+    output: z.ZodObject<{
+        ok: z.ZodLiteral<true>;
+        deleted: z.ZodBoolean;
+    }, z.core.$strict>;
+    async: true;
+    description: string;
+}, {
+    method: string;
+    kind: "request_response";
+    initiator: "frontend";
+    auth: {
+        account: "optional";
+        actor: "optional";
+    };
+    side_effects: false;
+    input: z.ZodDefault<z.ZodObject<{
+        ids: z.ZodOptional<z.ZodArray<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>>;
+        data_kind: z.ZodOptional<z.ZodString>;
+        visibility: z.ZodOptional<z.ZodEnum<{
+            private: "private";
+            public: "public";
+        }>>;
+        ref: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "FactHash", "out">>;
+        created_by: z.ZodOptional<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
+        path_prefix: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "CellPath", "out">>;
+        shared_with: z.ZodOptional<z.ZodLiteral<"me">>;
+        order_by: z.ZodOptional<z.ZodEnum<{
+            created_at: "created_at";
+            updated_at: "updated_at";
+        }>>;
+        order_direction: z.ZodOptional<z.ZodEnum<{
+            asc: "asc";
+            desc: "desc";
+        }>>;
+        limit: z.ZodOptional<z.ZodNumber>;
+        offset: z.ZodOptional<z.ZodNumber>;
+        acting: z.ZodOptional<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
+    }, z.core.$strict>>;
+    output: z.ZodObject<{
+        cells: z.ZodArray<z.ZodObject<{
+            id: z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">;
+            path: z.ZodNullable<z.core.$ZodBranded<z.ZodString, "CellPath", "out">>;
+            data: z.ZodObject<{
+                kind: z.ZodOptional<z.ZodString>;
+                label: z.ZodOptional<z.ZodString>;
+                summary: z.ZodOptional<z.ZodString>;
+            }, z.core.$loose>;
+            visibility: z.ZodEnum<{
+                private: "private";
+                public: "public";
+            }>;
+            refs: z.ZodNullable<z.ZodArray<z.core.$ZodBranded<z.ZodString, "FactHash", "out">>>;
+            created_by: z.ZodNullable<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
+            updated_by: z.ZodNullable<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
+            created_at: z.ZodString;
+            updated_at: z.ZodNullable<z.ZodString>;
+            deleted_at: z.ZodNullable<z.ZodString>;
+            grant_count: z.ZodNumber;
+        }, z.core.$strict>>;
+        cell_grants: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodObject<{
+            id: z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">;
+            cell_id: z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">;
+            level: z.ZodEnum<{
+                viewer: "viewer";
+                editor: "editor";
+            }>;
+            actor_id: z.ZodNullable<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
+            role: z.ZodNullable<z.ZodString>;
+            scope_id: z.ZodNullable<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
+            granted_by: z.ZodNullable<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
+            created_at: z.ZodString;
+        }, z.core.$strict>>>>;
+    }, z.core.$strict>;
+    async: true;
+    rate_limit: "ip";
+    description: string;
+}, {
+    method: string;
+    kind: "request_response";
+    initiator: "frontend";
+    auth: {
+        account: "required";
+        actor: "required";
+    };
+    side_effects: true;
+    input: z.ZodObject<{
+        source_id: z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">;
+        deep: z.ZodOptional<z.ZodBoolean>;
+        with_data_patch: z.ZodOptional<z.ZodObject<{
+            kind: z.ZodOptional<z.ZodString>;
+            label: z.ZodOptional<z.ZodString>;
+            summary: z.ZodOptional<z.ZodString>;
+        }, z.core.$loose>>;
+        acting: z.ZodOptional<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
+    }, z.core.$strict>;
+    output: z.ZodObject<{
+        cell: z.ZodObject<{
+            id: z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">;
+            path: z.ZodNullable<z.core.$ZodBranded<z.ZodString, "CellPath", "out">>;
+            data: z.ZodObject<{
+                kind: z.ZodOptional<z.ZodString>;
+                label: z.ZodOptional<z.ZodString>;
+                summary: z.ZodOptional<z.ZodString>;
+            }, z.core.$loose>;
+            visibility: z.ZodEnum<{
+                private: "private";
+                public: "public";
+            }>;
+            refs: z.ZodNullable<z.ZodArray<z.core.$ZodBranded<z.ZodString, "FactHash", "out">>>;
+            created_by: z.ZodNullable<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
+            updated_by: z.ZodNullable<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
+            created_at: z.ZodString;
+            updated_at: z.ZodNullable<z.ZodString>;
+            deleted_at: z.ZodNullable<z.ZodString>;
+            grant_count: z.ZodNumber;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    async: true;
+    rate_limit: "account";
+    description: string;
+}, {
+    method: string;
+    kind: "request_response";
+    initiator: "frontend";
+    auth: {
+        account: "required";
+        actor: "required";
+    };
+    side_effects: true;
+    input: z.ZodObject<{
+        cell_id: z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">;
+        level: z.ZodEnum<{
+            viewer: "viewer";
+            editor: "editor";
+        }>;
+        principal: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"actor">;
+            actor_id: z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"role">;
+            role: z.ZodString;
+            scope_id: z.ZodOptional<z.ZodNullable<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>>;
+        }, z.core.$strict>], "kind">;
+        acting: z.ZodOptional<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
+    }, z.core.$strict>;
+    output: z.ZodObject<{
+        grant: z.ZodObject<{
+            id: z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">;
+            cell_id: z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">;
+            level: z.ZodEnum<{
+                viewer: "viewer";
+                editor: "editor";
+            }>;
+            actor_id: z.ZodNullable<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
+            role: z.ZodNullable<z.ZodString>;
+            scope_id: z.ZodNullable<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
+            granted_by: z.ZodNullable<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
+            created_at: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    async: true;
+    description: string;
+}, {
+    method: string;
+    kind: "request_response";
+    initiator: "frontend";
+    auth: {
+        account: "required";
+        actor: "required";
+    };
+    side_effects: true;
+    input: z.ZodObject<{
+        grant_id: z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">;
+        acting: z.ZodOptional<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
+    }, z.core.$strict>;
+    output: z.ZodObject<{
+        ok: z.ZodLiteral<true>;
+        still_admitted: z.ZodBoolean;
+    }, z.core.$strict>;
+    async: true;
+    description: string;
+}, {
+    method: string;
+    kind: "request_response";
+    initiator: "frontend";
+    auth: {
+        account: "required";
+        actor: "required";
+    };
+    side_effects: false;
+    input: z.ZodObject<{
+        cell_id: z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">;
+        acting: z.ZodOptional<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
+    }, z.core.$strict>;
+    output: z.ZodObject<{
+        grants: z.ZodArray<z.ZodObject<{
+            id: z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">;
+            cell_id: z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">;
+            level: z.ZodEnum<{
+                viewer: "viewer";
+                editor: "editor";
+            }>;
+            actor_id: z.ZodNullable<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
+            role: z.ZodNullable<z.ZodString>;
+            scope_id: z.ZodNullable<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
+            granted_by: z.ZodNullable<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
+            created_at: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    async: true;
+    description: string;
+}, {
+    method: string;
+    kind: "request_response";
+    initiator: "frontend";
+    auth: {
+        account: "required";
+        actor: "required";
+    };
+    side_effects: true;
+    input: z.ZodObject<{
+        source_id: z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">;
+        name: z.core.$ZodBranded<z.ZodString, "CellFieldName", "out">;
+        target_id: z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">;
+        acting: z.ZodOptional<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
+    }, z.core.$strict>;
+    output: z.ZodObject<{
+        field: z.ZodObject<{
+            source_id: z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">;
+            name: z.ZodString;
+            target_id: z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">;
+            created_at: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    async: true;
+    description: string;
+}, {
+    method: string;
+    kind: "request_response";
+    initiator: "frontend";
+    auth: {
+        account: "required";
+        actor: "required";
+    };
+    side_effects: true;
+    input: z.ZodObject<{
+        source_id: z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">;
+        name: z.core.$ZodBranded<z.ZodString, "CellFieldName", "out">;
+        acting: z.ZodOptional<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
+    }, z.core.$strict>;
+    output: z.ZodObject<{
+        ok: z.ZodLiteral<true>;
+        deleted: z.ZodBoolean;
+    }, z.core.$strict>;
+    async: true;
+    description: string;
+}, {
+    method: string;
+    kind: "request_response";
+    initiator: "frontend";
+    auth: {
+        account: "optional";
+        actor: "optional";
+    };
+    side_effects: false;
+    input: z.ZodObject<{
+        source_id: z.ZodOptional<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
+        target_id: z.ZodOptional<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
+        name_after: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "CellFieldName", "out">>;
+        limit: z.ZodOptional<z.ZodNumber>;
+        acting: z.ZodOptional<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
+    }, z.core.$strict>;
+    output: z.ZodObject<{
+        fields: z.ZodArray<z.ZodObject<{
+            source_id: z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">;
+            name: z.ZodString;
+            target_id: z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">;
+            created_at: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    async: true;
+    rate_limit: "ip";
+    description: string;
+}, {
+    method: string;
+    kind: "request_response";
+    initiator: "frontend";
+    auth: {
+        account: "required";
+        actor: "required";
+    };
+    side_effects: true;
+    input: z.ZodObject<{
+        parent_id: z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">;
+        child_id: z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">;
+        position: z.core.$ZodBranded<z.ZodString, "CellItemPosition", "out">;
+        acting: z.ZodOptional<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
+    }, z.core.$strict>;
+    output: z.ZodObject<{
+        item: z.ZodObject<{
+            parent_id: z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">;
+            position: z.core.$ZodBranded<z.ZodString, "CellItemPosition", "out">;
+            child_id: z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">;
+            created_at: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    async: true;
+    description: string;
+}, {
+    method: string;
+    kind: "request_response";
+    initiator: "frontend";
+    auth: {
+        account: "required";
+        actor: "required";
+    };
+    side_effects: true;
+    input: z.ZodObject<{
+        parent_id: z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">;
+        position: z.core.$ZodBranded<z.ZodString, "CellItemPosition", "out">;
+        new_position: z.core.$ZodBranded<z.ZodString, "CellItemPosition", "out">;
+        acting: z.ZodOptional<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
+    }, z.core.$strict>;
+    output: z.ZodObject<{
+        item: z.ZodObject<{
+            parent_id: z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">;
+            position: z.core.$ZodBranded<z.ZodString, "CellItemPosition", "out">;
+            child_id: z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">;
+            created_at: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    async: true;
+    description: string;
+}, {
+    method: string;
+    kind: "request_response";
+    initiator: "frontend";
+    auth: {
+        account: "required";
+        actor: "required";
+    };
+    side_effects: true;
+    input: z.ZodObject<{
+        parent_id: z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">;
+        position: z.core.$ZodBranded<z.ZodString, "CellItemPosition", "out">;
+        acting: z.ZodOptional<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
+    }, z.core.$strict>;
+    output: z.ZodObject<{
+        ok: z.ZodLiteral<true>;
+        deleted: z.ZodBoolean;
+    }, z.core.$strict>;
+    async: true;
+    description: string;
+}, {
+    method: string;
+    kind: "request_response";
+    initiator: "frontend";
+    auth: {
+        account: "optional";
+        actor: "optional";
+    };
+    side_effects: false;
+    input: z.ZodObject<{
+        parent_id: z.ZodOptional<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
+        child_id: z.ZodOptional<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
+        position_after: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "CellItemPosition", "out">>;
+        limit: z.ZodOptional<z.ZodNumber>;
+        acting: z.ZodOptional<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
+    }, z.core.$strict>;
+    output: z.ZodObject<{
+        items: z.ZodArray<z.ZodObject<{
+            parent_id: z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">;
+            position: z.core.$ZodBranded<z.ZodString, "CellItemPosition", "out">;
+            child_id: z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">;
+            created_at: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    async: true;
+    rate_limit: "ip";
+    description: string;
+}, {
+    method: string;
+    kind: "request_response";
+    initiator: "frontend";
+    auth: {
+        account: "required";
+        actor: "required";
+    };
+    side_effects: false;
+    input: z.ZodObject<{
+        cell_id: z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">;
+        acting: z.ZodOptional<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
+    }, z.core.$strict>;
+    output: z.ZodObject<{
+        events: z.ZodArray<z.ZodObject<{
+            id: z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">;
+            seq: z.ZodNumber;
+            event_type: z.ZodString;
+            outcome: z.ZodEnum<{
+                success: "success";
+                failure: "failure";
+            }>;
+            actor_id: z.ZodNullable<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
+            created_at: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    async: true;
+    description: string;
+}];
+//# sourceMappingURL=cell_action_specs.d.ts.map