/**
 * Admin RPC action specs — declarative contract for admin-only operations.
 *
 * Import this module for the specs, Input/Output schemas, and the
 * `all_admin_action_specs` registry. Handlers live in `auth/admin_actions.ts`.
 *
 * Authorization is declared at the spec level (`auth: {role: ROLE_ADMIN}`)
 * so the RPC dispatcher enforces admin before the handler runs and the
 * generated surface accurately reports the requirement.
 *
 * The registry always includes `app_settings_get` / `app_settings_update` —
 * the runtime factory only wires their handlers when
 * `AdminActionOptions.app_settings` is provided; dispatch falls back to
 * `method_not_found` when absent.
 *
 * @module
 */
import { z } from 'zod';
import type { RequestResponseActionSpec } from '../actions/action_spec.js';
/** Max audit-log page size. */
export declare const AUDIT_LOG_LIST_LIMIT_MAX = 200;
/** Default `admin_account_list` page size. */
export declare const ADMIN_ACCOUNT_LIST_DEFAULT_LIMIT = 50;
/** Max `admin_account_list` page size. */
export declare const ADMIN_ACCOUNT_LIST_LIMIT_MAX = 200;
/** Input for `admin_account_list`. */
export declare const AdminAccountListInput: z.ZodDefault<z.ZodObject<{
    acting: z.ZodOptional<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
    limit: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
    offset: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
    include_deleted: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
}, z.core.$strict>>;
export type AdminAccountListInput = z.infer<typeof AdminAccountListInput>;
/** Output for `admin_account_list`. */
export declare const AdminAccountListOutput: z.ZodObject<{
    accounts: z.ZodArray<z.ZodObject<{
        account: z.ZodObject<{
            id: z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">;
            username: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
            email: z.ZodNullable<z.ZodEmail>;
            email_verified: z.ZodBoolean;
            created_at: z.ZodString;
            updated_at: z.ZodString;
            updated_by: z.ZodNullable<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
            deleted_at: z.ZodNullable<z.ZodString>;
        }, z.core.$strict>;
        actor: z.ZodNullable<z.ZodObject<{
            id: z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">;
            name: z.ZodString;
        }, z.core.$strict>>;
        role_grants: z.ZodArray<z.ZodObject<{
            id: z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">;
            role: z.ZodString;
            scope_kind: z.ZodNullable<z.ZodString>;
            scope_id: z.ZodNullable<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
            created_at: z.ZodString;
            expires_at: z.ZodNullable<z.ZodString>;
            granted_by: z.ZodNullable<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
        }, z.core.$strict>>;
        pending_offers: z.ZodArray<z.ZodObject<{
            id: z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">;
            role: z.ZodString;
            scope_kind: z.ZodNullable<z.ZodString>;
            scope_id: z.ZodNullable<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
            from_actor_id: z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">;
            from_username: z.ZodString;
            created_at: z.ZodString;
            expires_at: z.ZodString;
        }, z.core.$strict>>;
    }, z.core.$strict>>;
    grantable_roles: z.ZodArray<z.ZodString>;
}, z.core.$strict>;
export type AdminAccountListOutput = z.infer<typeof AdminAccountListOutput>;
/** Input for `admin_session_list`. */
export declare const AdminSessionListInput: z.ZodDefault<z.ZodObject<{
    acting: z.ZodOptional<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
}, z.core.$strict>>;
export type AdminSessionListInput = z.infer<typeof AdminSessionListInput>;
/** Output for `admin_session_list`. Cross-account listing; fan-out already scoped by role auth. */
export declare const AdminSessionListOutput: z.ZodObject<{
    sessions: z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        account_id: z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">;
        created_at: z.ZodString;
        expires_at: z.ZodString;
        last_seen_at: z.ZodString;
        username: z.ZodString;
    }, z.core.$strict>>;
}, z.core.$strict>;
export type AdminSessionListOutput = z.infer<typeof AdminSessionListOutput>;
/** Input for `admin_session_revoke_all`. */
export declare const AdminSessionRevokeAllInput: z.ZodObject<{
    account_id: z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">;
    acting: z.ZodOptional<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
}, z.core.$strict>;
export type AdminSessionRevokeAllInput = z.infer<typeof AdminSessionRevokeAllInput>;
/** Output for `admin_session_revoke_all`. */
export declare const AdminSessionRevokeAllOutput: z.ZodObject<{
    ok: z.ZodLiteral<true>;
    count: z.ZodNumber;
}, z.core.$strict>;
export type AdminSessionRevokeAllOutput = z.infer<typeof AdminSessionRevokeAllOutput>;
/** Input for `admin_token_revoke_all`. */
export declare const AdminTokenRevokeAllInput: z.ZodObject<{
    account_id: z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">;
    acting: z.ZodOptional<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
}, z.core.$strict>;
export type AdminTokenRevokeAllInput = z.infer<typeof AdminTokenRevokeAllInput>;
/** Output for `admin_token_revoke_all`. */
export declare const AdminTokenRevokeAllOutput: z.ZodObject<{
    ok: z.ZodLiteral<true>;
    count: z.ZodNumber;
}, z.core.$strict>;
export type AdminTokenRevokeAllOutput = z.infer<typeof AdminTokenRevokeAllOutput>;
/**
 * Input for `audit_log_list`. All filter fields are optional — omit for the
 * default newest-first page. `since_seq` exists for SSE reconnection gap
 * fill (caller supplies the highest seq seen; server returns everything
 * after).
 */
export declare const AuditLogListInput: z.ZodDefault<z.ZodObject<{
    event_type: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    outcome: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
        success: "success";
        failure: "failure";
    }>>>;
    account_id: z.ZodOptional<z.ZodNullable<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>>;
    limit: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
    offset: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
    since_seq: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
    acting: z.ZodOptional<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
}, z.core.$strict>>;
export type AuditLogListInput = z.infer<typeof AuditLogListInput>;
/** Output for `audit_log_list`. */
export declare const AuditLogListOutput: 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">>;
        account_id: z.ZodNullable<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
        target_account_id: z.ZodNullable<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
        target_actor_id: z.ZodNullable<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
        ip: z.ZodNullable<z.ZodString>;
        created_at: z.ZodString;
        metadata: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        username: z.ZodNullable<z.ZodString>;
        target_username: z.ZodNullable<z.ZodString>;
    }, z.core.$strict>>;
}, z.core.$strict>;
export type AuditLogListOutput = z.infer<typeof AuditLogListOutput>;
/** Input for `audit_log_role_grant_history`. */
export declare const AuditLogRoleGrantHistoryInput: z.ZodDefault<z.ZodObject<{
    limit: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
    offset: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
    acting: z.ZodOptional<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
}, z.core.$strict>>;
export type AuditLogRoleGrantHistoryInput = z.infer<typeof AuditLogRoleGrantHistoryInput>;
/** Output for `audit_log_role_grant_history`. */
export declare const AuditLogRoleGrantHistoryOutput: 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">>;
        account_id: z.ZodNullable<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
        target_account_id: z.ZodNullable<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
        target_actor_id: z.ZodNullable<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
        ip: z.ZodNullable<z.ZodString>;
        created_at: z.ZodString;
        metadata: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        username: z.ZodNullable<z.ZodString>;
        target_username: z.ZodNullable<z.ZodString>;
    }, z.core.$strict>>;
}, z.core.$strict>;
export type AuditLogRoleGrantHistoryOutput = z.infer<typeof AuditLogRoleGrantHistoryOutput>;
/** Input for `invite_create`. At least one of `email` / `username` must be provided. */
export declare const InviteCreateInput: z.ZodObject<{
    email: z.ZodOptional<z.ZodNullable<z.ZodEmail>>;
    username: z.ZodOptional<z.ZodNullable<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>>;
    acting: z.ZodOptional<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
}, z.core.$strict>;
export type InviteCreateInput = z.infer<typeof InviteCreateInput>;
/** Output for `invite_create`. */
export declare const InviteCreateOutput: z.ZodObject<{
    ok: z.ZodLiteral<true>;
    invite: z.ZodObject<{
        id: z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">;
        email: z.ZodNullable<z.ZodEmail>;
        username: z.ZodNullable<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
        claimed_by: z.ZodNullable<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
        claimed_at: z.ZodNullable<z.ZodString>;
        created_at: z.ZodString;
        created_by: z.ZodNullable<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
    }, z.core.$strict>;
}, z.core.$strict>;
export type InviteCreateOutput = z.infer<typeof InviteCreateOutput>;
/** Input for `invite_list`. */
export declare const InviteListInput: z.ZodDefault<z.ZodObject<{
    acting: z.ZodOptional<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
}, z.core.$strict>>;
export type InviteListInput = z.infer<typeof InviteListInput>;
/** Output for `invite_list`. Uses the enriched row including creator/claimer usernames. */
export declare const InviteListOutput: z.ZodObject<{
    invites: z.ZodArray<z.ZodObject<{
        id: z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">;
        email: z.ZodNullable<z.ZodEmail>;
        username: z.ZodNullable<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
        claimed_by: z.ZodNullable<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
        claimed_at: z.ZodNullable<z.ZodString>;
        created_at: z.ZodString;
        created_by: z.ZodNullable<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
        created_by_username: z.ZodNullable<z.ZodString>;
        claimed_by_username: z.ZodNullable<z.ZodString>;
    }, z.core.$strict>>;
}, z.core.$strict>;
export type InviteListOutput = z.infer<typeof InviteListOutput>;
/** Input for `invite_delete`. */
export declare const InviteDeleteInput: z.ZodObject<{
    invite_id: z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">;
    acting: z.ZodOptional<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
}, z.core.$strict>;
export type InviteDeleteInput = z.infer<typeof InviteDeleteInput>;
/** Output for `invite_delete`. */
export declare const InviteDeleteOutput: z.ZodObject<{
    ok: z.ZodLiteral<true>;
}, z.core.$strict>;
export type InviteDeleteOutput = z.infer<typeof InviteDeleteOutput>;
/** Input for `app_settings_get`. */
export declare const AppSettingsGetInput: z.ZodDefault<z.ZodObject<{
    acting: z.ZodOptional<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
}, z.core.$strict>>;
export type AppSettingsGetInput = z.infer<typeof AppSettingsGetInput>;
/** Output for `app_settings_get`. */
export declare const AppSettingsGetOutput: z.ZodObject<{
    settings: z.ZodObject<{
        open_signup: z.ZodBoolean;
        updated_at: z.ZodNullable<z.ZodString>;
        updated_by: z.ZodNullable<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
        updated_by_username: z.ZodNullable<z.ZodString>;
    }, z.core.$strict>;
}, z.core.$strict>;
export type AppSettingsGetOutput = z.infer<typeof AppSettingsGetOutput>;
/** Input for `app_settings_update`. */
export declare const AppSettingsUpdateInput: z.ZodObject<{
    open_signup: z.ZodBoolean;
    acting: z.ZodOptional<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
}, z.core.$strict>;
export type AppSettingsUpdateInput = z.infer<typeof AppSettingsUpdateInput>;
/** Output for `app_settings_update`. */
export declare const AppSettingsUpdateOutput: z.ZodObject<{
    ok: z.ZodLiteral<true>;
    settings: z.ZodObject<{
        open_signup: z.ZodBoolean;
        updated_at: z.ZodNullable<z.ZodString>;
        updated_by: z.ZodNullable<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
        updated_by_username: z.ZodNullable<z.ZodString>;
    }, z.core.$strict>;
}, z.core.$strict>;
export type AppSettingsUpdateOutput = z.infer<typeof AppSettingsUpdateOutput>;
/**
 * `data.reason` on `account_purge` when `confirm: true` is absent.
 * Fail-loud: the irreversible purge refuses to run without explicit
 * confirmation. Mirrors the Rust `ERROR_PURGE_NOT_CONFIRMED`.
 */
export declare const ERROR_PURGE_NOT_CONFIRMED: "purge_not_confirmed";
/**
 * `data.reason` (403) on `account_delete` / `account_purge` when the
 * target account holds an active keeper role_grant. The keeper account
 * is never deletable or purgeable through the API: auth resolution and
 * daemon-token resolution both pivot on the keeper account, so tombstoning
 * or cascading it away would brick keeper/daemon auth with no recovery
 * path (the keeper role is not web-revocable, and `account_purge` itself
 * requires keeper auth). Keeper-account removal stays out-of-band
 * (bootstrap / DB surgery). Mirrors the Rust `ERROR_CANNOT_DELETE_KEEPER`.
 */
export declare const ERROR_CANNOT_DELETE_KEEPER: "cannot_delete_keeper";
/**
 * `data.reason` (403) on `account_delete` / `account_purge` when the target
 * is the **sole remaining active admin** — removing it would leave the
 * system with no account that can authenticate into the admin surface (and
 * `account_undelete` is itself admin-gated). Unlike the keeper guard this is
 * keeper-recoverable (a keeper can re-grant admin), but the guard avoids the
 * foot-gun of an admin tombstoning the last admin in one call. Soft-deleted
 * admins don't count toward the tally (they can't log in). Mirrors the Rust
 * `ERROR_CANNOT_DELETE_LAST_ADMIN`.
 */
export declare const ERROR_CANNOT_DELETE_LAST_ADMIN: "cannot_delete_last_admin";
/**
 * Input for `account_delete` (soft delete). `account_id` is optional —
 * omitted (or equal to the caller's own account) is a self-delete; a
 * different account requires the admin role (handler-enforced
 * elevation, like `role_grant_offer_list`).
 */
export declare const AccountDeleteInput: z.ZodDefault<z.ZodObject<{
    account_id: z.ZodOptional<z.ZodNullable<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>>;
    acting: z.ZodOptional<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
}, z.core.$strict>>;
export type AccountDeleteInput = z.infer<typeof AccountDeleteInput>;
/** Output for `account_delete`. */
export declare const AccountDeleteOutput: z.ZodObject<{
    ok: z.ZodLiteral<true>;
    deleted: z.ZodBoolean;
}, z.core.$strict>;
export type AccountDeleteOutput = z.infer<typeof AccountDeleteOutput>;
/** Input for `account_purge` (hard, irreversible delete). Keeper-only. */
export declare const AccountPurgeInput: z.ZodObject<{
    account_id: z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">;
    confirm: z.ZodOptional<z.ZodBoolean>;
    acting: z.ZodOptional<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
}, z.core.$strict>;
export type AccountPurgeInput = z.infer<typeof AccountPurgeInput>;
/** Output for `account_purge`. */
export declare const AccountPurgeOutput: z.ZodObject<{
    ok: z.ZodLiteral<true>;
    purged: z.ZodBoolean;
}, z.core.$strict>;
export type AccountPurgeOutput = z.infer<typeof AccountPurgeOutput>;
/**
 * Input for `account_undelete` (reactivation). `account_id` is required —
 * unlike `account_delete` there is no self path: a soft-deleted account
 * can't authenticate (auth resolution excludes it, sessions are revoked),
 * so reactivation is always an admin acting on another account.
 */
export declare const AccountUndeleteInput: z.ZodObject<{
    account_id: z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">;
    acting: z.ZodOptional<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
}, z.core.$strict>;
export type AccountUndeleteInput = z.infer<typeof AccountUndeleteInput>;
/** Output for `account_undelete`. */
export declare const AccountUndeleteOutput: z.ZodObject<{
    ok: z.ZodLiteral<true>;
    undeleted: z.ZodBoolean;
}, z.core.$strict>;
export type AccountUndeleteOutput = z.infer<typeof AccountUndeleteOutput>;
/**
 * `rate_limit: 'account'` bounds admin-side scraping of the account table
 * via `(limit, offset)` walking — admin trust is not a substitute for a
 * read-rate cap when the listing is paginated and cross-account (yields
 * every account + actor + active role_grant in the system).
 */
export declare const admin_account_list_action_spec: {
    method: string;
    kind: "request_response";
    initiator: "frontend";
    auth: {
        account: "required";
        actor: "required";
        roles: string[];
    };
    side_effects: false;
    input: z.ZodDefault<z.ZodObject<{
        acting: z.ZodOptional<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
        limit: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
        offset: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
        include_deleted: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
    }, z.core.$strict>>;
    output: z.ZodObject<{
        accounts: z.ZodArray<z.ZodObject<{
            account: z.ZodObject<{
                id: z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">;
                username: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
                email: z.ZodNullable<z.ZodEmail>;
                email_verified: z.ZodBoolean;
                created_at: z.ZodString;
                updated_at: z.ZodString;
                updated_by: z.ZodNullable<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
                deleted_at: z.ZodNullable<z.ZodString>;
            }, z.core.$strict>;
            actor: z.ZodNullable<z.ZodObject<{
                id: z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">;
                name: z.ZodString;
            }, z.core.$strict>>;
            role_grants: z.ZodArray<z.ZodObject<{
                id: z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">;
                role: z.ZodString;
                scope_kind: z.ZodNullable<z.ZodString>;
                scope_id: z.ZodNullable<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
                created_at: z.ZodString;
                expires_at: z.ZodNullable<z.ZodString>;
                granted_by: z.ZodNullable<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
            }, z.core.$strict>>;
            pending_offers: z.ZodArray<z.ZodObject<{
                id: z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">;
                role: z.ZodString;
                scope_kind: z.ZodNullable<z.ZodString>;
                scope_id: z.ZodNullable<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
                from_actor_id: z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">;
                from_username: z.ZodString;
                created_at: z.ZodString;
                expires_at: z.ZodString;
            }, z.core.$strict>>;
        }, z.core.$strict>>;
        grantable_roles: z.ZodArray<z.ZodString>;
    }, z.core.$strict>;
    async: true;
    description: string;
    rate_limit: "account";
};
/**
 * `rate_limit: 'account'` bounds cross-account scraping of every active
 * `auth_session` row — no pagination, but the read is unbounded across
 * accounts and reveals one row per live cookie globally.
 */
export declare const admin_session_list_action_spec: {
    method: string;
    kind: "request_response";
    initiator: "frontend";
    auth: {
        account: "required";
        actor: "required";
        roles: string[];
    };
    side_effects: false;
    input: z.ZodDefault<z.ZodObject<{
        acting: z.ZodOptional<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
    }, z.core.$strict>>;
    output: z.ZodObject<{
        sessions: z.ZodArray<z.ZodObject<{
            id: z.ZodString;
            account_id: z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">;
            created_at: z.ZodString;
            expires_at: z.ZodString;
            last_seen_at: z.ZodString;
            username: z.ZodString;
        }, z.core.$strict>>;
    }, z.core.$strict>;
    async: true;
    description: string;
    rate_limit: "account";
};
export declare const admin_session_revoke_all_action_spec: {
    method: string;
    kind: "request_response";
    initiator: "frontend";
    auth: {
        account: "required";
        actor: "required";
        roles: string[];
    };
    side_effects: true;
    input: z.ZodObject<{
        account_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>;
        count: z.ZodNumber;
    }, z.core.$strict>;
    async: true;
    description: string;
    rate_limit: "account";
};
export declare const admin_token_revoke_all_action_spec: {
    method: string;
    kind: "request_response";
    initiator: "frontend";
    auth: {
        account: "required";
        actor: "required";
        roles: string[];
    };
    side_effects: true;
    input: z.ZodObject<{
        account_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>;
        count: z.ZodNumber;
    }, z.core.$strict>;
    async: true;
    description: string;
    rate_limit: "account";
};
/**
 * `rate_limit: 'account'` bounds admin-side enumeration of the entire
 * audit log via `(limit, offset)` walking — same shape as
 * `admin_account_list_action_spec`. The listing carries cross-account
 * forensic detail (target ids, IPs, metadata), so the read-rate cap is
 * the only check that distinguishes a human reviewer from a scraping
 * script.
 */
export declare const audit_log_list_action_spec: {
    method: string;
    kind: "request_response";
    initiator: "frontend";
    auth: {
        account: "required";
        actor: "required";
        roles: string[];
    };
    side_effects: false;
    input: z.ZodDefault<z.ZodObject<{
        event_type: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        outcome: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
            success: "success";
            failure: "failure";
        }>>>;
        account_id: z.ZodOptional<z.ZodNullable<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>>;
        limit: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
        offset: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
        since_seq: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
        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">>;
            account_id: z.ZodNullable<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
            target_account_id: z.ZodNullable<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
            target_actor_id: z.ZodNullable<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
            ip: z.ZodNullable<z.ZodString>;
            created_at: z.ZodString;
            metadata: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            username: z.ZodNullable<z.ZodString>;
            target_username: z.ZodNullable<z.ZodString>;
        }, z.core.$strict>>;
    }, z.core.$strict>;
    async: true;
    description: string;
    rate_limit: "account";
};
/**
 * `rate_limit: 'account'` bounds admin-side enumeration of the role_grant
 * history via `(limit, offset)` walking — same shape as `audit_log_list`,
 * narrower projection but identical scraping vector.
 */
export declare const audit_log_role_grant_history_action_spec: {
    method: string;
    kind: "request_response";
    initiator: "frontend";
    auth: {
        account: "required";
        actor: "required";
        roles: string[];
    };
    side_effects: false;
    input: z.ZodDefault<z.ZodObject<{
        limit: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
        offset: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
        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">>;
            account_id: z.ZodNullable<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
            target_account_id: z.ZodNullable<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
            target_actor_id: z.ZodNullable<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
            ip: z.ZodNullable<z.ZodString>;
            created_at: z.ZodString;
            metadata: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            username: z.ZodNullable<z.ZodString>;
            target_username: z.ZodNullable<z.ZodString>;
        }, z.core.$strict>>;
    }, z.core.$strict>;
    async: true;
    description: string;
    rate_limit: "account";
};
export declare const invite_create_action_spec: {
    method: string;
    kind: "request_response";
    initiator: "frontend";
    auth: {
        account: "required";
        actor: "required";
        roles: string[];
    };
    side_effects: true;
    input: z.ZodObject<{
        email: z.ZodOptional<z.ZodNullable<z.ZodEmail>>;
        username: z.ZodOptional<z.ZodNullable<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>>;
        acting: z.ZodOptional<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
    }, z.core.$strict>;
    output: z.ZodObject<{
        ok: z.ZodLiteral<true>;
        invite: z.ZodObject<{
            id: z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">;
            email: z.ZodNullable<z.ZodEmail>;
            username: z.ZodNullable<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
            claimed_by: z.ZodNullable<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
            claimed_at: z.ZodNullable<z.ZodString>;
            created_at: z.ZodString;
            created_by: z.ZodNullable<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
        }, z.core.$strict>;
    }, z.core.$strict>;
    async: true;
    description: string;
    rate_limit: "account";
};
/**
 * `rate_limit: 'account'` bounds admin-side scraping of the invite table —
 * bounded by table size, but every row carries email + username +
 * creator/claimer identifiers worth defense-in-depth against an admin
 * mutation oracle running scripted reads alongside `invite_create`.
 */
export declare const invite_list_action_spec: {
    method: string;
    kind: "request_response";
    initiator: "frontend";
    auth: {
        account: "required";
        actor: "required";
        roles: string[];
    };
    side_effects: false;
    input: z.ZodDefault<z.ZodObject<{
        acting: z.ZodOptional<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
    }, z.core.$strict>>;
    output: z.ZodObject<{
        invites: z.ZodArray<z.ZodObject<{
            id: z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">;
            email: z.ZodNullable<z.ZodEmail>;
            username: z.ZodNullable<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
            claimed_by: z.ZodNullable<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
            claimed_at: z.ZodNullable<z.ZodString>;
            created_at: z.ZodString;
            created_by: z.ZodNullable<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
            created_by_username: z.ZodNullable<z.ZodString>;
            claimed_by_username: z.ZodNullable<z.ZodString>;
        }, z.core.$strict>>;
    }, z.core.$strict>;
    async: true;
    description: string;
    rate_limit: "account";
};
export declare const invite_delete_action_spec: {
    method: string;
    kind: "request_response";
    initiator: "frontend";
    auth: {
        account: "required";
        actor: "required";
        roles: string[];
    };
    side_effects: true;
    input: z.ZodObject<{
        invite_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>;
    }, z.core.$strict>;
    async: true;
    description: string;
    rate_limit: "account";
};
/**
 * Soft-delete an account (reversible tombstone). Self-or-admin: the
 * caller may delete their own account; deleting another requires the
 * admin role (handler-enforced elevation). No `admin_` prefix — the
 * privilege lives in the auth check, not the name, so self-service
 * deletion stays open (`delete` = soft, `purge` = hard).
 */
export declare const account_delete_action_spec: {
    method: string;
    kind: "request_response";
    initiator: "frontend";
    auth: {
        account: "required";
        actor: "required";
    };
    side_effects: true;
    input: z.ZodDefault<z.ZodObject<{
        account_id: z.ZodOptional<z.ZodNullable<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;
    rate_limit: "account";
};
/**
 * Hard-purge an account (keeper-gated, irreversible). Keeper credential
 * (`daemon_token`) + keeper role + explicit `confirm: true`. Not
 * admin-reachable and not self-service — the most dangerous operation is
 * the most restricted. `purge` = hard; the word + gating + WARN flag the
 * danger (fail-loud).
 */
export declare const account_purge_action_spec: {
    method: string;
    kind: "request_response";
    initiator: "frontend";
    auth: {
        account: "required";
        actor: "required";
        roles: string[];
        credential_types: string[];
    };
    side_effects: true;
    input: z.ZodObject<{
        account_id: z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">;
        confirm: z.ZodOptional<z.ZodBoolean>;
        acting: z.ZodOptional<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
    }, z.core.$strict>;
    output: z.ZodObject<{
        ok: z.ZodLiteral<true>;
        purged: z.ZodBoolean;
    }, z.core.$strict>;
    async: true;
    description: string;
    rate_limit: "account";
};
/**
 * Reactivate a soft-deleted account (clears the tombstone). Admin-only —
 * there is no self path because a soft-deleted account can't authenticate
 * (auth resolution excludes it and its sessions are revoked), so
 * reactivation is always an admin acting on another account. The inverse
 * of `account_delete`; does not restore revoked sessions/tokens
 * (delete = soft, purge = hard).
 */
export declare const account_undelete_action_spec: {
    method: string;
    kind: "request_response";
    initiator: "frontend";
    auth: {
        account: "required";
        actor: "required";
        roles: string[];
    };
    side_effects: true;
    input: z.ZodObject<{
        account_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>;
        undeleted: z.ZodBoolean;
    }, z.core.$strict>;
    async: true;
    description: string;
    rate_limit: "account";
};
export declare const app_settings_get_action_spec: {
    method: string;
    kind: "request_response";
    initiator: "frontend";
    auth: {
        account: "required";
        actor: "required";
        roles: string[];
    };
    side_effects: false;
    input: z.ZodDefault<z.ZodObject<{
        acting: z.ZodOptional<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
    }, z.core.$strict>>;
    output: z.ZodObject<{
        settings: z.ZodObject<{
            open_signup: z.ZodBoolean;
            updated_at: z.ZodNullable<z.ZodString>;
            updated_by: z.ZodNullable<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
            updated_by_username: z.ZodNullable<z.ZodString>;
        }, z.core.$strict>;
    }, z.core.$strict>;
    async: true;
    description: string;
};
export declare const app_settings_update_action_spec: {
    method: string;
    kind: "request_response";
    initiator: "frontend";
    auth: {
        account: "required";
        actor: "required";
        roles: string[];
    };
    side_effects: true;
    input: z.ZodObject<{
        open_signup: z.ZodBoolean;
        acting: z.ZodOptional<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
    }, z.core.$strict>;
    output: z.ZodObject<{
        ok: z.ZodLiteral<true>;
        settings: z.ZodObject<{
            open_signup: z.ZodBoolean;
            updated_at: z.ZodNullable<z.ZodString>;
            updated_by: z.ZodNullable<z.core.$ZodBranded<z.ZodUUID, "Uuid", "out">>;
            updated_by_username: z.ZodNullable<z.ZodString>;
        }, z.core.$strict>;
    }, z.core.$strict>;
    async: true;
    description: string;
    rate_limit: "account";
};
/**
 * All admin action specs — a codegen-ready registry. Consumers spread this
 * into their own action-spec array to include admin methods in a typed
 * client surface. Includes the two app-settings specs, whose handlers the
 * runtime factory always wires.
 */
export declare const all_admin_action_specs: Array<RequestResponseActionSpec>;
//# sourceMappingURL=admin_action_specs.d.ts.map