/**
 * 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