@belonguniverseai/react-sdk 0.1.0

package/dist/api/client.d.ts

@@ -0,0 +1,2053 @@
+/**
+ * Hono RPC client typed against the belong-cloud `AppType`. The whole
+ * point of this file: every method call below is end-to-end type-checked
+ * — request body, params, query, response shape, status code.
+ *
+ * The host calls `setBelongToken` after `init` (or via
+ * `window.belong.setToken`); each request reads the current value and
+ * attaches `Authorization: Bearer <jwt>`.
+ */
+export declare const setBelongToken: (token: string) => void;
+/** Register a fresh-per-request token source (takes precedence over setToken). */
+export declare const setBelongTokenProvider: (provider: () => string | null) => void;
+/**
+ * Register the async per-request token getter used by the React-component embed
+ * (`<BelongWidget getToken>`). Takes precedence over the sync provider / static
+ * token. Pass null to clear. Awaited on every request; its result is never
+ * cached (see `resolveBelongToken`).
+ */
+export declare const setBelongTokenGetter: (getter: (() => Promise<string>) | null) => void;
+/** Register the host agent id sent as `X-Belong-Agent-Id` on every request. */
+export declare const setBelongAgentId: (agentId: string | null) => void;
+/**
+ * Register the async token refresher (auth0-refresh.ts). Pass null to clear.
+ * Awaited by `ensureFreshBelongToken` / `forceRotateBelongToken`.
+ */
+export declare const setBelongTokenRefresher: (refresher: ((opts?: {
+    readonly force?: boolean;
+}) => Promise<void>) | null) => void;
+export declare const clearBelongToken: () => void;
+export declare const peekBelongToken: () => string | null;
+/**
+ * Whether ANY auth source is registered — async getter, sync provider, or a
+ * non-empty static token. The dock login gate (`app/BelongDock.tsx`) reads this
+ * instead of `peekBelongToken()`: the component embed registers only an ASYNC
+ * getter, so the gate can't synchronously read a JWT, but it CAN know the host
+ * provided one. No token is read or cached here.
+ */
+export declare const hasBelongAuthSource: () => boolean;
+/**
+ * The token for the NEXT request. Prefers the async getter (the component DI
+ * path) — awaited fresh every call, result never stored — then falls back to the
+ * sync provider / static token (the `window.belong` path). A getter that rejects
+ * falls back too, so one transient Auth0 error is no worse than the sync path.
+ */
+export declare const resolveBelongToken: () => Promise<string | null>;
+/**
+ * Observability correlation headers every Belong request should carry:
+ *  - `X-Belong-Client-Version` — which SDK bundle the request came from
+ *    (baked by vite, "dev" on unbuilt surfaces), so a stale-bundle report is
+ *    diagnosable from the backend span/logs alone.
+ *  - `X-Belong-Session-Id` — the active chat session id, so endpoints keyed
+ *    only by `runId` in the URL (the SSE run stream, run cancel) are still
+ *    filterable by the session id the user copies from the dock. The backend
+ *    otel middleware stamps both onto the server span (middleware/otel.ts).
+ *
+ * `sessionId` is passed by the chat transport (its `this.#sessionId` is
+ * authoritative even before the stream-state store is persisted); callers
+ * without one fall back to the store's active pointer.
+ */
+export declare const belongTelemetryHeaders: (sessionId?: string | null) => Record<string, string>;
+/**
+ * The full header set for an authed Belong backend request: the telemetry
+ * headers above plus `Authorization: Bearer <token>` when one resolves. Async
+ * because the component DI getter is awaited per request (BEL-111). EVERY raw
+ * `fetch` to the backend should use this; the typed `hc` client uses it via its
+ * `headers` callback. An empty / whitespace token is treated as absent so the
+ * request stays cleanly unauthenticated rather than sending a malformed bare
+ * `Authorization: Bearer `.
+ */
+export declare const authHeaders: (sessionId?: string | null) => Promise<Record<string, string>>;
+/**
+ * Best-effort: rotate the host token if it's near/expired, so the NEXT
+ * `peekBelongToken` returns a fresh value. Safe to call before any authed
+ * request; a no-op when no refresher is registered (programmatic hosts that
+ * own token rotation themselves) or when rotation fails (the sync read still
+ * returns whatever is cached — no worse than today).
+ */
+export declare const ensureFreshBelongToken: () => Promise<void>;
+/**
+ * Force-mint a brand-new host token (skips the cache), so the NEXT request
+ * carries a web JWT the provider has never seen. Use before the agent-grant
+ * exchange, whose anti-replay 409s a token that already minted a grant — a
+ * plain `ensureFreshBelongToken` would hand back that same spent-but-valid
+ * token. No-op / best-effort like `ensureFreshBelongToken`.
+ */
+export declare const forceRotateBelongToken: () => Promise<void>;
+export type ApiClient = ReturnType<typeof createApiClient>;
+export declare const createApiClient: (baseUrl: string) => {
+    api: {
+        health: import('hono/client').ClientRequest<string, "/api/health", {
+            $get: {
+                input: {};
+                output: {
+                    ok: true;
+                    ts: string;
+                };
+                outputFormat: "json";
+                status: import('hono/utils/http-status').ContentfulStatusCode;
+            };
+        }>;
+    };
+} & {
+    api: {
+        health: {
+            deep: import('hono/client').ClientRequest<string, "/api/health/deep", {
+                $get: {
+                    input: {};
+                    output: {
+                        ts: string;
+                        ok: boolean;
+                        db: "error" | "ok";
+                        redis: "error" | "ok";
+                    };
+                    outputFormat: "json";
+                    status: 200 | 503;
+                } | {
+                    input: {};
+                    output: {
+                        ok: false;
+                        error: string;
+                        ts: string;
+                    };
+                    outputFormat: "json";
+                    status: 429;
+                };
+            }>;
+        };
+    };
+} & {
+    api: {
+        health: import('hono/client').ClientRequest<string, "/api/health", {
+            $get: {
+                input: {};
+                output: {
+                    ok: true;
+                    ts: string;
+                };
+                outputFormat: "json";
+                status: import('hono/utils/http-status').ContentfulStatusCode;
+            };
+        }>;
+    };
+} & {
+    api: {
+        health: {
+            deep: import('hono/client').ClientRequest<string, "/api/health/deep", {
+                $get: {
+                    input: {};
+                    output: {
+                        ts: string;
+                        ok: boolean;
+                        db: "error" | "ok";
+                        redis: "error" | "ok";
+                    };
+                    outputFormat: "json";
+                    status: 200 | 503;
+                } | {
+                    input: {};
+                    output: {
+                        ok: false;
+                        error: string;
+                        ts: string;
+                    };
+                    outputFormat: "json";
+                    status: 429;
+                };
+            }>;
+        };
+    };
+} & {
+    v1: {
+        sessions: import('hono/client').ClientRequest<string, "/v1/sessions", {
+            $post: {
+                input: {
+                    json: {
+                        title?: string | undefined;
+                    };
+                };
+                output: {
+                    sessionId: import('node_modules/@belong/cloud/src/platform/ids').SessionId;
+                };
+                outputFormat: "json";
+                status: 201;
+            } | {
+                input: {
+                    json: {
+                        title?: string | undefined;
+                    };
+                };
+                output: {
+                    error: {
+                        type: string;
+                    };
+                };
+                outputFormat: "json";
+                status: 403;
+            };
+            $get: {
+                input: {};
+                output: {
+                    sessions: readonly {
+                        readonly sessionId: import('node_modules/@belong/cloud/src/platform/ids').SessionId;
+                        readonly title: string | null;
+                        readonly status: import('node_modules/@belong/cloud/src/features/sessions/session.repo').SessionRow["status"];
+                        readonly updatedAt: string;
+                    }[];
+                };
+                outputFormat: "json";
+                status: import('hono/utils/http-status').ContentfulStatusCode;
+            };
+        }>;
+    };
+} & {
+    v1: {
+        sessions: {
+            ":sessionId": import('hono/client').ClientRequest<string, "/v1/sessions/:sessionId", {
+                $get: {
+                    input: {
+                        param: {
+                            sessionId: string;
+                        };
+                    };
+                    output: {
+                        readonly sessionId: import('node_modules/@belong/cloud/src/platform/ids').SessionId;
+                        readonly title: string | null;
+                        readonly status: import('node_modules/@belong/cloud/src/features/sessions/session.repo').SessionRow["status"];
+                        readonly createdAt: string;
+                        readonly updatedAt: string;
+                    };
+                    outputFormat: "json";
+                    status: import('hono/utils/http-status').ContentfulStatusCode;
+                } | {
+                    input: {
+                        param: {
+                            sessionId: string;
+                        };
+                    };
+                    output: {
+                        error: {
+                            type: string;
+                        };
+                    };
+                    outputFormat: "json";
+                    status: 404;
+                };
+                $delete: {
+                    input: {
+                        param: {
+                            sessionId: string;
+                        };
+                    };
+                    output: null;
+                    outputFormat: "body";
+                    status: 204;
+                } | {
+                    input: {
+                        param: {
+                            sessionId: string;
+                        };
+                    };
+                    output: {
+                        error: {
+                            type: string;
+                        };
+                    };
+                    outputFormat: "json";
+                    status: 404;
+                };
+            }>;
+        };
+    };
+} & {
+    v1: {
+        sessions: {
+            ":sessionId": {
+                messages: import('hono/client').ClientRequest<string, "/v1/sessions/:sessionId/messages", {
+                    $get: {
+                        input: {
+                            param: {
+                                sessionId: string;
+                            };
+                        };
+                        output: {
+                            messages: {
+                                metadata?: {
+                                    taskId: import('node_modules/@belong/cloud/src/platform/ids').TaskId;
+                                    feedback: {
+                                        readonly sentiment: "up" | "down";
+                                        readonly reason: string | null;
+                                    } | null;
+                                } | undefined;
+                                createdAt?: string | undefined;
+                                id: string;
+                                role: "user" | "assistant";
+                                parts: readonly ({
+                                    [x: string]: import('hono/utils/types').JSONValue;
+                                    type: string;
+                                    id?: string | undefined;
+                                    data?: import('hono/utils/types').JSONValue;
+                                    text?: string | undefined;
+                                } | {
+                                    readonly type: "file";
+                                    readonly url: string;
+                                    readonly mediaType: string;
+                                    readonly filename: string;
+                                    readonly providerMetadata: {
+                                        readonly belong: {
+                                            readonly fileId: string;
+                                        };
+                                    };
+                                })[];
+                            }[];
+                        };
+                        outputFormat: "json";
+                        status: import('hono/utils/http-status').ContentfulStatusCode;
+                    } | {
+                        input: {
+                            param: {
+                                sessionId: string;
+                            };
+                        };
+                        output: {
+                            error: {
+                                type: string;
+                            };
+                        };
+                        outputFormat: "json";
+                        status: 404;
+                    };
+                    $post: {
+                        input: {
+                            json: {
+                                text: string;
+                                fileIds?: string[] | undefined;
+                                clientMessageId?: string | undefined;
+                                skill?: string | undefined;
+                                mode?: "plan" | "approve" | "balanced" | "bypass" | "execute" | undefined;
+                                runtime?: "mastra" | "claude-managed" | "fake" | "claude-agent-sdk" | undefined;
+                                llmProvider?: "anthropic" | "google" | "openai" | "cerebras" | "gateway" | undefined;
+                                llmModel?: string | undefined;
+                            };
+                        } & {
+                            param: {
+                                sessionId: string;
+                            };
+                        };
+                        output: {
+                            messageId: import('node_modules/@belong/cloud/src/platform/ids').MessageId;
+                            taskId: import('node_modules/@belong/cloud/src/platform/ids').TaskId;
+                            runId: import('node_modules/@belong/cloud/src/platform/ids').RunId;
+                            idempotent: boolean;
+                        };
+                        outputFormat: "json";
+                        status: 200 | 202;
+                    } | {
+                        input: {
+                            json: {
+                                text: string;
+                                fileIds?: string[] | undefined;
+                                clientMessageId?: string | undefined;
+                                skill?: string | undefined;
+                                mode?: "plan" | "approve" | "balanced" | "bypass" | "execute" | undefined;
+                                runtime?: "mastra" | "claude-managed" | "fake" | "claude-agent-sdk" | undefined;
+                                llmProvider?: "anthropic" | "google" | "openai" | "cerebras" | "gateway" | undefined;
+                                llmModel?: string | undefined;
+                            };
+                        } & {
+                            param: {
+                                sessionId: string;
+                            };
+                        };
+                        output: {
+                            error: {
+                                type: string;
+                            };
+                        };
+                        outputFormat: "json";
+                        status: 404;
+                    } | {
+                        input: {
+                            json: {
+                                text: string;
+                                fileIds?: string[] | undefined;
+                                clientMessageId?: string | undefined;
+                                skill?: string | undefined;
+                                mode?: "plan" | "approve" | "balanced" | "bypass" | "execute" | undefined;
+                                runtime?: "mastra" | "claude-managed" | "fake" | "claude-agent-sdk" | undefined;
+                                llmProvider?: "anthropic" | "google" | "openai" | "cerebras" | "gateway" | undefined;
+                                llmModel?: string | undefined;
+                            };
+                        } & {
+                            param: {
+                                sessionId: string;
+                            };
+                        };
+                        output: {
+                            error: {
+                                type: string;
+                            };
+                        };
+                        outputFormat: "json";
+                        status: 409;
+                    } | {
+                        input: {
+                            json: {
+                                text: string;
+                                fileIds?: string[] | undefined;
+                                clientMessageId?: string | undefined;
+                                skill?: string | undefined;
+                                mode?: "plan" | "approve" | "balanced" | "bypass" | "execute" | undefined;
+                                runtime?: "mastra" | "claude-managed" | "fake" | "claude-agent-sdk" | undefined;
+                                llmProvider?: "anthropic" | "google" | "openai" | "cerebras" | "gateway" | undefined;
+                                llmModel?: string | undefined;
+                            };
+                        } & {
+                            param: {
+                                sessionId: string;
+                            };
+                        };
+                        output: {
+                            error: {
+                                type: string;
+                            };
+                        };
+                        outputFormat: "json";
+                        status: 403;
+                    };
+                }>;
+            };
+        };
+    };
+} & {
+    v1: {
+        sessions: {
+            ":sessionId": {
+                compact: import('hono/client').ClientRequest<string, "/v1/sessions/:sessionId/compact", {
+                    $post: {
+                        input: {
+                            param: {
+                                sessionId: string;
+                            };
+                        };
+                        output: {
+                            status: "compacted";
+                            messagesCompacted: number;
+                            summaryMessageId: import('node_modules/@belong/cloud/src/platform/ids').MessageId;
+                        };
+                        outputFormat: "json";
+                        status: 200;
+                    } | {
+                        input: {
+                            param: {
+                                sessionId: string;
+                            };
+                        };
+                        output: {
+                            status: "noop";
+                        };
+                        outputFormat: "json";
+                        status: 200;
+                    } | {
+                        input: {
+                            param: {
+                                sessionId: string;
+                            };
+                        };
+                        output: {
+                            error: {
+                                type: "session_not_found" | "session_archived" | "not_session_owner";
+                            };
+                        };
+                        outputFormat: "json";
+                        status: 404 | 403 | 409;
+                    } | {
+                        input: {
+                            param: {
+                                sessionId: string;
+                            };
+                        };
+                        output: {
+                            error: {
+                                type: string;
+                            };
+                        };
+                        outputFormat: "json";
+                        status: 409;
+                    } | {
+                        input: {
+                            param: {
+                                sessionId: string;
+                            };
+                        };
+                        output: {
+                            error: {
+                                type: string;
+                            };
+                        };
+                        outputFormat: "json";
+                        status: 502;
+                    };
+                }>;
+            };
+        };
+    };
+} & {
+    v1: {
+        sessions: {
+            ":sessionId": {
+                clear: import('hono/client').ClientRequest<string, "/v1/sessions/:sessionId/clear", {
+                    $post: {
+                        input: {
+                            param: {
+                                sessionId: string;
+                            };
+                        };
+                        output: {
+                            status: "cleared";
+                        };
+                        outputFormat: "json";
+                        status: 200;
+                    } | {
+                        input: {
+                            param: {
+                                sessionId: string;
+                            };
+                        };
+                        output: {
+                            error: {
+                                type: "session_not_found" | "session_archived" | "not_session_owner";
+                            };
+                        };
+                        outputFormat: "json";
+                        status: 404 | 403 | 409;
+                    };
+                }>;
+            };
+        };
+    };
+} & {
+    v1: {
+        sessions: {
+            ":sessionId": {
+                usage: import('hono/client').ClientRequest<string, "/v1/sessions/:sessionId/usage", {
+                    $get: {
+                        input: {
+                            param: {
+                                sessionId: string;
+                            };
+                        };
+                        output: {
+                            error: {
+                                type: string;
+                            };
+                        };
+                        outputFormat: "json";
+                        status: 404;
+                    } | {
+                        input: {
+                            param: {
+                                sessionId: string;
+                            };
+                        };
+                        output: {
+                            totalInputTokens: number;
+                            totalOutputTokens: number;
+                            totalTokens: number;
+                            turns: number;
+                            historyChars: number;
+                            autoCompactThresholdChars: number;
+                        };
+                        outputFormat: "json";
+                        status: import('hono/utils/http-status').ContentfulStatusCode;
+                    };
+                }>;
+            };
+        };
+    };
+} & {
+    v1: {
+        sessions: {
+            ":sessionId": {
+                feedback: import('hono/client').ClientRequest<string, "/v1/sessions/:sessionId/feedback", {
+                    $post: {
+                        input: {
+                            json: {
+                                taskId: string;
+                                sentiment: "up" | "down";
+                                reason?: string | undefined;
+                            };
+                        } & {
+                            param: {
+                                sessionId: string;
+                            };
+                        };
+                        output: {
+                            status: "accepted";
+                        };
+                        outputFormat: "json";
+                        status: 200;
+                    } | {
+                        input: {
+                            json: {
+                                taskId: string;
+                                sentiment: "up" | "down";
+                                reason?: string | undefined;
+                            };
+                        } & {
+                            param: {
+                                sessionId: string;
+                            };
+                        };
+                        output: {
+                            error: {
+                                type: string;
+                            };
+                        };
+                        outputFormat: "json";
+                        status: 404;
+                    };
+                }>;
+            };
+        };
+    };
+} & {
+    v1: {
+        sessions: {
+            ":sessionId": {
+                feedback: {
+                    ":taskId": import('hono/client').ClientRequest<string, "/v1/sessions/:sessionId/feedback/:taskId", {
+                        $delete: {
+                            input: {
+                                param: {
+                                    sessionId: string;
+                                } & {
+                                    taskId: string;
+                                };
+                            };
+                            output: {
+                                status: "cleared";
+                            };
+                            outputFormat: "json";
+                            status: 200;
+                        } | {
+                            input: {
+                                param: {
+                                    sessionId: string;
+                                } & {
+                                    taskId: string;
+                                };
+                            };
+                            output: {
+                                error: {
+                                    type: string;
+                                };
+                            };
+                            outputFormat: "json";
+                            status: 404;
+                        };
+                    }>;
+                };
+            };
+        };
+    };
+} & {
+    v1: {
+        runs: {
+            ":runId": {
+                stream: import('hono/client').ClientRequest<string, "/v1/runs/:runId/stream", {
+                    $get: {
+                        input: {
+                            param: {
+                                runId: string;
+                            };
+                        };
+                        output: {};
+                        outputFormat: string;
+                        status: import('hono/utils/http-status').StatusCode;
+                    };
+                }>;
+            };
+        };
+    };
+} & {
+    v1: {
+        runs: {
+            ":runId": {
+                cancel: import('hono/client').ClientRequest<string, "/v1/runs/:runId/cancel", {
+                    $post: {
+                        input: {
+                            param: {
+                                runId: string;
+                            };
+                        };
+                        output: {
+                            error: {
+                                type: string;
+                            };
+                        };
+                        outputFormat: "json";
+                        status: 404;
+                    } | {
+                        input: {
+                            param: {
+                                runId: string;
+                            };
+                        };
+                        output: {
+                            status: string;
+                        };
+                        outputFormat: "json";
+                        status: 202;
+                    };
+                }>;
+            };
+        };
+    };
+} & {
+    v1: {
+        approvals: {
+            ":approvalId": {
+                resolve: import('hono/client').ClientRequest<string, "/v1/approvals/:approvalId/resolve", {
+                    $post: {
+                        input: {
+                            json: {
+                                decision: "approved" | "rejected" | "amend_requested";
+                                comment?: string | undefined;
+                                alwaysAllow?: boolean | undefined;
+                            };
+                        } & {
+                            param: {
+                                approvalId: string;
+                            };
+                        };
+                        output: {
+                            status: "accepted";
+                            approvalStatus: "pending" | "approved" | "rejected" | "amend_requested" | "expired";
+                        };
+                        outputFormat: "json";
+                        status: 200;
+                    } | {
+                        input: {
+                            json: {
+                                decision: "approved" | "rejected" | "amend_requested";
+                                comment?: string | undefined;
+                                alwaysAllow?: boolean | undefined;
+                            };
+                        } & {
+                            param: {
+                                approvalId: string;
+                            };
+                        };
+                        output: {
+                            error: {
+                                type: string;
+                            };
+                        };
+                        outputFormat: "json";
+                        status: 404;
+                    } | {
+                        input: {
+                            json: {
+                                decision: "approved" | "rejected" | "amend_requested";
+                                comment?: string | undefined;
+                                alwaysAllow?: boolean | undefined;
+                            };
+                        } & {
+                            param: {
+                                approvalId: string;
+                            };
+                        };
+                        output: {
+                            error: {
+                                type: string;
+                            };
+                        };
+                        outputFormat: "json";
+                        status: 409;
+                    } | {
+                        input: {
+                            json: {
+                                decision: "approved" | "rejected" | "amend_requested";
+                                comment?: string | undefined;
+                                alwaysAllow?: boolean | undefined;
+                            };
+                        } & {
+                            param: {
+                                approvalId: string;
+                            };
+                        };
+                        output: {
+                            error: {
+                                type: string;
+                            };
+                        };
+                        outputFormat: "json";
+                        status: 403;
+                    };
+                }>;
+            };
+        };
+    };
+} & {
+    v1: {
+        files: import('hono/client').ClientRequest<string, "/v1/files", {
+            $post: {
+                input: {};
+                output: {
+                    error: {
+                        type: string;
+                    };
+                };
+                outputFormat: "json";
+                status: 400;
+            } | {
+                input: {};
+                output: {
+                    fileId: import('node_modules/@belong/cloud/src/platform/ids').FileId;
+                };
+                outputFormat: "json";
+                status: 201;
+            } | {
+                input: {};
+                output: {
+                    error: {
+                        type: string;
+                    };
+                };
+                outputFormat: "json";
+                status: 404;
+            };
+            $get: {
+                input: {};
+                output: {
+                    error: {
+                        type: string;
+                    };
+                };
+                outputFormat: "json";
+                status: 400;
+            } | {
+                input: {};
+                output: {
+                    files: {
+                        fileId: import('node_modules/@belong/cloud/src/platform/ids').FileId;
+                        filename: string;
+                        mimeType: string;
+                        sizeBytes: number;
+                        createdAt: string;
+                    }[];
+                };
+                outputFormat: "json";
+                status: import('hono/utils/http-status').ContentfulStatusCode;
+            };
+        }>;
+    };
+} & {
+    v1: {
+        files: {
+            ":fileId": import('hono/client').ClientRequest<string, "/v1/files/:fileId", {
+                $get: {
+                    input: {
+                        param: {
+                            fileId: string;
+                        };
+                    };
+                    output: {
+                        fileId: import('node_modules/@belong/cloud/src/platform/ids').FileId;
+                        originalFilename: string;
+                        mimeType: string;
+                        sizeBytes: number;
+                        createdAt: string;
+                    };
+                    outputFormat: "json";
+                    status: import('hono/utils/http-status').ContentfulStatusCode;
+                } | {
+                    input: {
+                        param: {
+                            fileId: string;
+                        };
+                    };
+                    output: {
+                        error: {
+                            type: string;
+                        };
+                    };
+                    outputFormat: "json";
+                    status: 404;
+                };
+            }>;
+        };
+    };
+} & {
+    v1: {
+        files: {
+            ":fileId": {
+                content: import('hono/client').ClientRequest<string, "/v1/files/:fileId/content", {
+                    $get: {
+                        input: {
+                            param: {
+                                fileId: string;
+                            };
+                        };
+                        output: {};
+                        outputFormat: string;
+                        status: import('hono/utils/http-status').StatusCode;
+                    };
+                }>;
+            };
+        };
+    };
+} & {
+    v1: {
+        files: {
+            ":fileId": {
+                preview: import('hono/client').ClientRequest<string, "/v1/files/:fileId/preview", {
+                    $get: {
+                        input: {
+                            param: {
+                                fileId: string;
+                            };
+                        };
+                        output: {
+                            readonly status: "pending";
+                        } | {
+                            readonly status: "ready";
+                            readonly kind: import('node_modules/@belong/cloud/src/features/files/preview.types').PreviewKind;
+                            readonly pageCount?: number | undefined;
+                        } | {
+                            readonly status: "too_large";
+                        } | {
+                            readonly status: "unsupported";
+                        } | {
+                            readonly status: "failed";
+                        };
+                        outputFormat: "json";
+                        status: import('hono/utils/http-status').ContentfulStatusCode;
+                    } | {
+                        input: {
+                            param: {
+                                fileId: string;
+                            };
+                        };
+                        output: {
+                            error: {
+                                type: string;
+                            };
+                        };
+                        outputFormat: "json";
+                        status: 404;
+                    };
+                }>;
+            };
+        };
+    };
+} & {
+    v1: {
+        files: {
+            ":fileId": {
+                preview: {
+                    html: import('hono/client').ClientRequest<string, "/v1/files/:fileId/preview/html", {
+                        $get: {
+                            input: {
+                                param: {
+                                    fileId: string;
+                                };
+                            };
+                            output: {};
+                            outputFormat: string;
+                            status: import('hono/utils/http-status').StatusCode;
+                        };
+                    }>;
+                };
+            };
+        };
+    };
+} & {
+    v1: {
+        files: {
+            ":fileId": {
+                preview: {
+                    page: {
+                        ":n": import('hono/client').ClientRequest<string, "/v1/files/:fileId/preview/page/:n", {
+                            $get: {
+                                input: {
+                                    param: {
+                                        fileId: string;
+                                    } & {
+                                        n: string;
+                                    };
+                                };
+                                output: {};
+                                outputFormat: string;
+                                status: import('hono/utils/http-status').StatusCode;
+                            };
+                        }>;
+                    };
+                };
+            };
+        };
+    };
+} & {
+    v1: {
+        artifacts: {
+            ":artifactId": import('hono/client').ClientRequest<string, "/v1/artifacts/:artifactId", {
+                $get: {
+                    input: {
+                        param: {
+                            artifactId: string;
+                        };
+                    };
+                    output: {};
+                    outputFormat: string;
+                    status: import('hono/utils/http-status').StatusCode;
+                };
+            }>;
+        };
+    };
+} & {
+    v1: {
+        artifacts: {
+            ":artifactId": {
+                share: import('hono/client').ClientRequest<string, "/v1/artifacts/:artifactId/share", {
+                    $post: {
+                        input: {
+                            param: {
+                                artifactId: string;
+                            };
+                        } & {
+                            query: {
+                                ttlSeconds?: string | string[];
+                            };
+                        };
+                        output: {
+                            url: string;
+                            expiresAt: string;
+                        };
+                        outputFormat: "json";
+                        status: 201;
+                    } | {
+                        input: {
+                            param: {
+                                artifactId: string;
+                            };
+                        } & {
+                            query: {
+                                ttlSeconds?: string | string[];
+                            };
+                        };
+                        output: {
+                            error: {
+                                type: string;
+                            };
+                        };
+                        outputFormat: "json";
+                        status: 404;
+                    };
+                }>;
+            };
+        };
+    };
+} & {
+    share: {
+        ":token": import('hono/client').ClientRequest<string, "/share/:token", {
+            $get: {
+                input: {
+                    param: {
+                        token: string;
+                    };
+                };
+                output: {};
+                outputFormat: string;
+                status: import('hono/utils/http-status').StatusCode;
+            };
+        }>;
+    };
+} & {
+    v1: {
+        voice: {
+            token: import('hono/client').ClientRequest<string, "/v1/voice/token", {
+                $post: {
+                    input: {
+                        json: {
+                            sessionId?: string | undefined;
+                            capabilities?: ("stt" | "tts")[] | undefined;
+                        };
+                    };
+                    output: {
+                        deepgramToken: string;
+                        deepgramWssUrl: string;
+                        elevenlabsToken: string;
+                        voiceId: string;
+                    };
+                    outputFormat: "json";
+                    status: 200;
+                } | {
+                    input: {
+                        json: {
+                            sessionId?: string | undefined;
+                            capabilities?: ("stt" | "tts")[] | undefined;
+                        };
+                    };
+                    output: {
+                        error: {
+                            type: string;
+                        };
+                    };
+                    outputFormat: "json";
+                    status: 404;
+                } | {
+                    input: {
+                        json: {
+                            sessionId?: string | undefined;
+                            capabilities?: ("stt" | "tts")[] | undefined;
+                        };
+                    };
+                    output: {
+                        error: {
+                            type: string;
+                        };
+                    };
+                    outputFormat: "json";
+                    status: 403;
+                } | {
+                    input: {
+                        json: {
+                            sessionId?: string | undefined;
+                            capabilities?: ("stt" | "tts")[] | undefined;
+                        };
+                    };
+                    output: {
+                        error: {
+                            type: string;
+                        };
+                    };
+                    outputFormat: "json";
+                    status: 503;
+                } | {
+                    input: {
+                        json: {
+                            sessionId?: string | undefined;
+                            capabilities?: ("stt" | "tts")[] | undefined;
+                        };
+                    };
+                    output: {
+                        error: {
+                            type: string;
+                        };
+                    };
+                    outputFormat: "json";
+                    status: 502;
+                };
+            }>;
+        };
+    };
+} & {
+    v1: {
+        voice: {
+            transcribe: import('hono/client').ClientRequest<string, "/v1/voice/transcribe", {
+                $post: {
+                    input: {};
+                    output: {
+                        error: string;
+                    };
+                    outputFormat: "json";
+                    status: 400;
+                } | {
+                    input: {};
+                    output: {
+                        text: string;
+                    };
+                    outputFormat: "json";
+                    status: 200;
+                } | {
+                    input: {};
+                    output: {
+                        error: string;
+                    };
+                    outputFormat: "json";
+                    status: 503;
+                } | {
+                    input: {};
+                    output: {
+                        error: string;
+                    };
+                    outputFormat: "json";
+                    status: 502;
+                };
+            }>;
+        };
+    };
+} & {
+    v1: {
+        voice: {
+            tts: import('hono/client').ClientRequest<string, "/v1/voice/tts", {
+                $post: {
+                    input: {
+                        json: {
+                            text: string;
+                            voiceId?: string | undefined;
+                        };
+                    };
+                    output: ReadableStream<Uint8Array<ArrayBufferLike>>;
+                    outputFormat: "body";
+                    status: 200;
+                } | {
+                    input: {
+                        json: {
+                            text: string;
+                            voiceId?: string | undefined;
+                        };
+                    };
+                    output: {
+                        error: string;
+                    };
+                    outputFormat: "json";
+                    status: 503;
+                } | {
+                    input: {
+                        json: {
+                            text: string;
+                            voiceId?: string | undefined;
+                        };
+                    };
+                    output: {
+                        error: string;
+                    };
+                    outputFormat: "json";
+                    status: 502;
+                };
+            }>;
+        };
+    };
+} & {
+    v1: {
+        voice: {
+            "spoken-summary": import('hono/client').ClientRequest<string, "/v1/voice/spoken-summary", {
+                $post: {
+                    input: {
+                        json: {
+                            text: string;
+                        };
+                    };
+                    output: {
+                        spokenText: string;
+                    };
+                    outputFormat: "json";
+                    status: 200;
+                };
+            }>;
+        };
+    };
+} & {
+    v1: {
+        "ui-actions": {
+            ":uiActionRequestId": {
+                result: import('hono/client').ClientRequest<string, "/v1/ui-actions/:uiActionRequestId/result", {
+                    $post: {
+                        input: {
+                            json: {
+                                ok: true;
+                                output: Record<string, unknown>;
+                            } | {
+                                ok: false;
+                                error: {
+                                    code: string;
+                                    message: string;
+                                };
+                            };
+                        } & {
+                            param: {
+                                uiActionRequestId: string;
+                            };
+                        };
+                        output: {
+                            status: string;
+                        };
+                        outputFormat: "json";
+                        status: 200;
+                    } | {
+                        input: {
+                            json: {
+                                ok: true;
+                                output: Record<string, unknown>;
+                            } | {
+                                ok: false;
+                                error: {
+                                    code: string;
+                                    message: string;
+                                };
+                            };
+                        } & {
+                            param: {
+                                uiActionRequestId: string;
+                            };
+                        };
+                        output: {
+                            error: {
+                                type: string;
+                            };
+                        };
+                        outputFormat: "json";
+                        status: 404;
+                    } | {
+                        input: {
+                            json: {
+                                ok: true;
+                                output: Record<string, unknown>;
+                            } | {
+                                ok: false;
+                                error: {
+                                    code: string;
+                                    message: string;
+                                };
+                            };
+                        } & {
+                            param: {
+                                uiActionRequestId: string;
+                            };
+                        };
+                        output: {
+                            error: {
+                                type: string;
+                            };
+                        };
+                        outputFormat: "json";
+                        status: 409;
+                    };
+                }>;
+            };
+        };
+    };
+} & {
+    v1: {
+        terminal: {
+            link: import('hono/client').ClientRequest<string, "/v1/terminal/link", {
+                $post: {
+                    input: {
+                        json: {
+                            ttlSeconds?: number | undefined;
+                        };
+                    };
+                    output: {
+                        url: string;
+                        expiresAt: string;
+                    };
+                    outputFormat: "json";
+                    status: 201;
+                } | {
+                    input: {
+                        json: {
+                            ttlSeconds?: number | undefined;
+                        };
+                    };
+                    output: {
+                        error: {
+                            type: string;
+                        };
+                    };
+                    outputFormat: "json";
+                    status: 503;
+                } | {
+                    input: {
+                        json: {
+                            ttlSeconds?: number | undefined;
+                        };
+                    };
+                    output: {
+                        error: {
+                            type: string;
+                        };
+                    };
+                    outputFormat: "json";
+                    status: 502;
+                };
+            }>;
+        };
+    };
+} & {
+    v1: {
+        terminal: {
+            uploads: import('hono/client').ClientRequest<string, "/v1/terminal/uploads", {
+                $get: {
+                    input: {};
+                    output: {
+                        files: readonly {
+                            readonly name: string;
+                            readonly sizeBytes: number;
+                            readonly modifiedAt: string;
+                        }[];
+                    };
+                    outputFormat: "json";
+                    status: import('hono/utils/http-status').ContentfulStatusCode;
+                };
+                $post: {
+                    input: {};
+                    output: {
+                        error: {
+                            type: string;
+                        };
+                    };
+                    outputFormat: "json";
+                    status: 400;
+                } | {
+                    input: {};
+                    output: {
+                        error: {
+                            type: string;
+                        };
+                    };
+                    outputFormat: "json";
+                    status: 413;
+                } | {
+                    input: {};
+                    output: {
+                        name: string;
+                    };
+                    outputFormat: "json";
+                    status: 201;
+                } | {
+                    input: {};
+                    output: {
+                        error: {
+                            type: string;
+                        };
+                    };
+                    outputFormat: "json";
+                    status: 503;
+                } | {
+                    input: {};
+                    output: {
+                        error: {
+                            type: string;
+                        };
+                    };
+                    outputFormat: "json";
+                    status: 409;
+                } | {
+                    input: {};
+                    output: {
+                        error: {
+                            type: string;
+                        };
+                    };
+                    outputFormat: "json";
+                    status: 502;
+                };
+            }>;
+        };
+    };
+} & {
+    v1: {
+        terminal: {
+            workspace: import('hono/client').ClientRequest<string, "/v1/terminal/workspace", {
+                $get: {
+                    input: {};
+                    output: {
+                        files: readonly {
+                            readonly path: string;
+                            readonly sizeBytes: number;
+                            readonly modifiedAt: string;
+                        }[];
+                    };
+                    outputFormat: "json";
+                    status: import('hono/utils/http-status').ContentfulStatusCode;
+                };
+            }>;
+        };
+    };
+} & {
+    v1: {
+        terminal: {
+            workspace: {
+                file: import('hono/client').ClientRequest<string, "/v1/terminal/workspace/file", {
+                    $get: {
+                        input: {};
+                        output: {};
+                        outputFormat: string;
+                        status: import('hono/utils/http-status').StatusCode;
+                    };
+                }>;
+            };
+        };
+    };
+} & {
+    v1: {
+        browser: {
+            stream: import('hono/client').ClientRequest<string, "/v1/browser/stream", {
+                $get: {
+                    input: {};
+                    output: {};
+                    outputFormat: string;
+                    status: import('hono/utils/http-status').StatusCode;
+                };
+            }>;
+        };
+    };
+} & {
+    v1: {
+        browser: {
+            result: import('hono/client').ClientRequest<string, "/v1/browser/result", {
+                $post: {
+                    input: {
+                        json: {
+                            commandId: string;
+                            result: {
+                                ok: true;
+                                value: {
+                                    snapshot?: string | undefined;
+                                    text?: string | undefined;
+                                    url?: string | undefined;
+                                };
+                            } | {
+                                ok: false;
+                                error: {
+                                    code: "timeout" | "stale_ref" | "not_typable" | "navigation_blocked" | "dom_error" | "eval_error" | "unsupported_op";
+                                    message: string;
+                                };
+                            };
+                        };
+                    };
+                    output: {
+                        status: "accepted";
+                    };
+                    outputFormat: "json";
+                    status: 200;
+                } | {
+                    input: {
+                        json: {
+                            commandId: string;
+                            result: {
+                                ok: true;
+                                value: {
+                                    snapshot?: string | undefined;
+                                    text?: string | undefined;
+                                    url?: string | undefined;
+                                };
+                            } | {
+                                ok: false;
+                                error: {
+                                    code: "timeout" | "stale_ref" | "not_typable" | "navigation_blocked" | "dom_error" | "eval_error" | "unsupported_op";
+                                    message: string;
+                                };
+                            };
+                        };
+                    };
+                    output: {
+                        error: {
+                            type: "unknown_command";
+                        };
+                    };
+                    outputFormat: "json";
+                    status: 404;
+                };
+            }>;
+        };
+    };
+} & {
+    v1: {
+        browser: {
+            command: import('hono/client').ClientRequest<string, "/v1/browser/command", {
+                $post: {
+                    input: {
+                        json: {
+                            op: "snapshot";
+                        } | {
+                            op: "click";
+                            ref: string;
+                        } | {
+                            op: "type";
+                            ref: string;
+                            text: string;
+                            submit?: boolean | undefined;
+                        } | {
+                            op: "select";
+                            ref: string;
+                            value: string;
+                        } | {
+                            op: "press";
+                            key: string;
+                        } | {
+                            op: "navigate";
+                            url: string;
+                        } | {
+                            op: "read";
+                            ref?: string | undefined;
+                        } | {
+                            op: "eval";
+                            code: string;
+                        };
+                    };
+                    output: {
+                        result: {
+                            ok: true;
+                            value: {
+                                snapshot?: string | undefined;
+                                text?: string | undefined;
+                                url?: string | undefined;
+                            };
+                        } | {
+                            ok: false;
+                            error: {
+                                code: "timeout" | "stale_ref" | "not_typable" | "navigation_blocked" | "dom_error" | "eval_error" | "unsupported_op";
+                                message: string;
+                            };
+                        };
+                    };
+                    outputFormat: "json";
+                    status: 200;
+                } | {
+                    input: {
+                        json: {
+                            op: "snapshot";
+                        } | {
+                            op: "click";
+                            ref: string;
+                        } | {
+                            op: "type";
+                            ref: string;
+                            text: string;
+                            submit?: boolean | undefined;
+                        } | {
+                            op: "select";
+                            ref: string;
+                            value: string;
+                        } | {
+                            op: "press";
+                            key: string;
+                        } | {
+                            op: "navigate";
+                            url: string;
+                        } | {
+                            op: "read";
+                            ref?: string | undefined;
+                        } | {
+                            op: "eval";
+                            code: string;
+                        };
+                    };
+                    output: {
+                        error: {
+                            type: "browser_not_connected";
+                        };
+                    };
+                    outputFormat: "json";
+                    status: 409;
+                } | {
+                    input: {
+                        json: {
+                            op: "snapshot";
+                        } | {
+                            op: "click";
+                            ref: string;
+                        } | {
+                            op: "type";
+                            ref: string;
+                            text: string;
+                            submit?: boolean | undefined;
+                        } | {
+                            op: "select";
+                            ref: string;
+                            value: string;
+                        } | {
+                            op: "press";
+                            key: string;
+                        } | {
+                            op: "navigate";
+                            url: string;
+                        } | {
+                            op: "read";
+                            ref?: string | undefined;
+                        } | {
+                            op: "eval";
+                            code: string;
+                        };
+                    };
+                    output: {
+                        error: {
+                            type: "browser_busy";
+                        };
+                    };
+                    outputFormat: "json";
+                    status: 409;
+                } | {
+                    input: {
+                        json: {
+                            op: "snapshot";
+                        } | {
+                            op: "click";
+                            ref: string;
+                        } | {
+                            op: "type";
+                            ref: string;
+                            text: string;
+                            submit?: boolean | undefined;
+                        } | {
+                            op: "select";
+                            ref: string;
+                            value: string;
+                        } | {
+                            op: "press";
+                            key: string;
+                        } | {
+                            op: "navigate";
+                            url: string;
+                        } | {
+                            op: "read";
+                            ref?: string | undefined;
+                        } | {
+                            op: "eval";
+                            code: string;
+                        };
+                    };
+                    output: {
+                        error: {
+                            type: "command_timeout";
+                        };
+                    };
+                    outputFormat: "json";
+                    status: 504;
+                };
+            }>;
+        };
+    };
+} & {
+    v1: {
+        config: {
+            theme: import('hono/client').ClientRequest<string, "/v1/config/theme", {
+                $get: {
+                    input: {};
+                    output: null;
+                    outputFormat: "body";
+                    status: 204;
+                } | {
+                    input: {};
+                    output: {
+                        theme: {
+                            readonly mode?: "light" | "dark" | undefined;
+                            readonly side?: "right" | "left" | undefined;
+                            readonly density?: "comfortable" | "compact" | undefined;
+                            readonly panelWidth?: number | undefined;
+                            readonly fontFamily?: string | undefined;
+                            readonly radius?: string | undefined;
+                            readonly palettes?: {
+                                readonly light?: {
+                                    readonly primary?: string | undefined;
+                                    readonly primaryForeground?: string | undefined;
+                                    readonly background?: string | undefined;
+                                    readonly foreground?: string | undefined;
+                                    readonly border?: string | undefined;
+                                    readonly muted?: string | undefined;
+                                    readonly mutedForeground?: string | undefined;
+                                    readonly accent?: string | undefined;
+                                    readonly accentForeground?: string | undefined;
+                                    readonly destructive?: string | undefined;
+                                    readonly destructiveForeground?: string | undefined;
+                                    readonly userBubble?: string | undefined;
+                                    readonly userBubbleForeground?: string | undefined;
+                                    readonly assistantBubble?: string | undefined;
+                                    readonly assistantBubbleForeground?: string | undefined;
+                                } | undefined;
+                                readonly dark?: {
+                                    readonly primary?: string | undefined;
+                                    readonly primaryForeground?: string | undefined;
+                                    readonly background?: string | undefined;
+                                    readonly foreground?: string | undefined;
+                                    readonly border?: string | undefined;
+                                    readonly muted?: string | undefined;
+                                    readonly mutedForeground?: string | undefined;
+                                    readonly accent?: string | undefined;
+                                    readonly accentForeground?: string | undefined;
+                                    readonly destructive?: string | undefined;
+                                    readonly destructiveForeground?: string | undefined;
+                                    readonly userBubble?: string | undefined;
+                                    readonly userBubbleForeground?: string | undefined;
+                                    readonly assistantBubble?: string | undefined;
+                                    readonly assistantBubbleForeground?: string | undefined;
+                                } | undefined;
+                            } | undefined;
+                            readonly brand?: {
+                                readonly name?: string | undefined;
+                                readonly initials?: string | undefined;
+                            } | undefined;
+                        };
+                    };
+                    outputFormat: "json";
+                    status: 200;
+                };
+            }>;
+        };
+    };
+} & {
+    v1: {
+        telemetry: {
+            client: import('hono/client').ClientRequest<string, "/v1/telemetry/client", {
+                $post: {
+                    input: {};
+                    output: null;
+                    outputFormat: "body";
+                    status: 204;
+                };
+            }>;
+        };
+    };
+} & {
+    v1: {
+        telemetry: {
+            otlp: {
+                v1: {
+                    traces: import('hono/client').ClientRequest<string, "/v1/telemetry/otlp/v1/traces", {
+                        $post: {
+                            input: {};
+                            output: null;
+                            outputFormat: "body";
+                            status: 204;
+                        } | {
+                            input: {};
+                            output: null;
+                            outputFormat: "body";
+                            status: 429;
+                        } | {
+                            input: {};
+                            output: null;
+                            outputFormat: "body";
+                            status: 413;
+                        } | {
+                            input: {};
+                            output: null;
+                            outputFormat: "body";
+                            status: 502 | 202;
+                        };
+                    }>;
+                };
+            };
+        };
+    };
+} & {
+    v1: {
+        skills: import('hono/client').ClientRequest<string, "/v1/skills", {
+            $get: {
+                input: {};
+                output: {
+                    skills: readonly {
+                        readonly name: string;
+                        readonly description: string;
+                        readonly group: string;
+                        readonly source: import('node_modules/@belong/cloud/src/features/skills/skill.service').SkillSource;
+                    }[];
+                    commands: readonly {
+                        readonly name: string;
+                        readonly description: string;
+                    }[];
+                };
+                outputFormat: "json";
+                status: import('hono/utils/http-status').ContentfulStatusCode;
+            };
+        }>;
+    };
+} & {
+    v1: {
+        "agent-grants": import('hono/client').ClientRequest<string, "/v1/agent-grants", {
+            $post: {
+                input: {
+                    json: {
+                        provider: string;
+                        scopeExternalId: string;
+                    };
+                };
+                output: {
+                    grantId: import('node_modules/@belong/cloud/src/platform/ids').AgentGrantId;
+                    expiresAt: string;
+                };
+                outputFormat: "json";
+                status: 201;
+            } | {
+                input: {
+                    json: {
+                        provider: string;
+                        scopeExternalId: string;
+                    };
+                };
+                output: {
+                    error: {
+                        type: string;
+                    };
+                };
+                outputFormat: "json";
+                status: 400;
+            } | {
+                input: {
+                    json: {
+                        provider: string;
+                        scopeExternalId: string;
+                    };
+                };
+                output: {
+                    error: {
+                        type: string;
+                    };
+                };
+                outputFormat: "json";
+                status: 503;
+            } | {
+                input: {
+                    json: {
+                        provider: string;
+                        scopeExternalId: string;
+                    };
+                };
+                output: {
+                    error: {
+                        type: string;
+                    };
+                };
+                outputFormat: "json";
+                status: 403;
+            } | {
+                input: {
+                    json: {
+                        provider: string;
+                        scopeExternalId: string;
+                    };
+                };
+                output: {
+                    error: {
+                        type: string;
+                    };
+                };
+                outputFormat: "json";
+                status: 409;
+            } | {
+                input: {
+                    json: {
+                        provider: string;
+                        scopeExternalId: string;
+                    };
+                };
+                output: {
+                    error: {
+                        type: string;
+                    };
+                };
+                outputFormat: "json";
+                status: 429;
+            } | {
+                input: {
+                    json: {
+                        provider: string;
+                        scopeExternalId: string;
+                    };
+                };
+                output: {
+                    error: {
+                        type: string;
+                    };
+                };
+                outputFormat: "json";
+                status: 502;
+            };
+        }>;
+    };
+} & {
+    v1: {
+        "agent-grants": {
+            current: import('hono/client').ClientRequest<string, "/v1/agent-grants/current", {
+                $get: {
+                    input: {
+                        query: {
+                            provider: string | string[];
+                            scopeExternalId?: string | string[];
+                        };
+                    };
+                    output: {
+                        status: "none";
+                    };
+                    outputFormat: "json";
+                    status: 200;
+                } | {
+                    input: {
+                        query: {
+                            provider: string | string[];
+                            scopeExternalId?: string | string[];
+                        };
+                    };
+                    output: {
+                        status: "active" | "expired" | "revoked";
+                        grantId: import('node_modules/@belong/cloud/src/platform/ids').AgentGrantId;
+                        provider: string;
+                        scopeExternalId: string;
+                        grantedAt: string | null;
+                        expiresAt: string | null;
+                    };
+                    outputFormat: "json";
+                    status: 200;
+                };
+            }>;
+        };
+    };
+} & {
+    v1: {
+        "agent-grants": {
+            "reconnect-failed": import('hono/client').ClientRequest<string, "/v1/agent-grants/reconnect-failed", {
+                $post: {
+                    input: {
+                        json: {
+                            provider: string;
+                            scopeExternalId: string;
+                            reconnectId: string;
+                        };
+                    };
+                    output: {
+                        status: "recorded";
+                    };
+                    outputFormat: "json";
+                    status: 202;
+                };
+            }>;
+        };
+    };
+} & {
+    v1: {
+        "agent-grants": {
+            ":grantId": {
+                revoke: import('hono/client').ClientRequest<string, "/v1/agent-grants/:grantId/revoke", {
+                    $post: {
+                        input: {
+                            param: {
+                                grantId: string;
+                            };
+                        };
+                        output: {
+                            status: "revoked";
+                        };
+                        outputFormat: "json";
+                        status: 200;
+                    } | {
+                        input: {
+                            param: {
+                                grantId: string;
+                            };
+                        };
+                        output: {
+                            error: {
+                                type: string;
+                            };
+                        };
+                        outputFormat: "json";
+                        status: 404;
+                    };
+                }>;
+            };
+        };
+    };
+};