@h-ai/api-client 0.1.0-alpha8 → 1.0.0-beta.1

package/dist/index.d.ts

@@ -1,7 +1,34 @@
+import * as _orpc_client from '@orpc/client';
+import * as _h_ai_api_contract from '@h-ai/api-contract';
+import { apiContract, IamLoginInput, IamRegisterInput } from '@h-ai/api-contract';
 import * as _h_ai_core from '@h-ai/core';
 import { HaiResult } from '@h-ai/core';
-import { z } from 'zod';
+import { CryptoFunctions } from '@h-ai/crypto';
+import * as _orpc_contract from '@orpc/contract';
+import { AnyContractRouter, ContractRouterClient } from '@orpc/contract';
+import { JsonifiedClient } from '@orpc/openapi-client';
+import * as zod_v4_core from 'zod/v4/core';
+import * as zod from 'zod';
 
+/**
+ * 客户端标准错误集合；包含稳定 code/httpStatus 与构造错误的方法，业务调用先检查 success。
+ * 传输失败在 procedure 代理中映射；服务端 HaiResult 的业务错误保持原契约。
+ *
+ * @example
+ * ```ts
+ * import { apiClient, HaiApiClientError } from '@h-ai/api-client'
+ * const initialized = await apiClient.init({ baseUrl: 'https://api.example.com/api/v1' })
+ * if (!initialized.success) throw new Error(initialized.error.message)
+ * try {
+ *   const result = await apiClient.iam.auth.currentUser()
+ *   if (!result.success && result.error.code === HaiApiClientError.UNAUTHORIZED.code) {
+ *     // 由应用切换到登录页面；不输出 Token。
+ *     const message = result.error.message
+ *   }
+ * }
+ * finally { await apiClient.close() }
+ * ```
+ */
 declare const HaiApiClientError: {
     readonly NETWORK_ERROR: _h_ai_core.HaiErrorDef;
     readonly TIMEOUT: _h_ai_core.HaiErrorDef;
@@ -11,338 +38,2819 @@ declare const HaiApiClientError: {
     readonly NOT_FOUND: _h_ai_core.HaiErrorDef;
     readonly VALIDATION_FAILED: _h_ai_core.HaiErrorDef;
     readonly TOKEN_REFRESH_FAILED: _h_ai_core.HaiErrorDef;
+    readonly PAYLOAD_TOO_LARGE: _h_ai_core.HaiErrorDef;
     readonly NOT_INITIALIZED: _h_ai_core.HaiErrorDef;
     readonly CONFIG_ERROR: _h_ai_core.HaiErrorDef;
     readonly UNKNOWN: _h_ai_core.HaiErrorDef;
 };
 /**
- * API 端点契约定义
- *
- * 描述单个 API 端点的 HTTP 方法、路径、入参/出参 Schema 与元数据。
- * 客户端通过 `api.call(endpoint, input)` 调用，服务端通过
- * `kit.fromContract(endpoint, handler)` 响应，两端共享同一份契约。
- *
- * @typeParam TInput - 入参类型（由 Zod Schema 推导）
- * @typeParam TOutput - 出参类型（由 Zod Schema 推导）
+ * 短期 access token、可选 refresh token 与有效期；HTTP 头使用 Bearer。
+ * Cookie 模式的 refresh token 由服务端管理，不能要求浏览器读取或持久化它。
  *
  * @example
  * ```ts
- * const loginEndpoint: EndpointDef<LoginInput, LoginOutput> = {
- *   method: 'POST',
- *   path: '/auth/login',
- *   input: LoginInputSchema,
- *   output: LoginOutputSchema,
- *   requireAuth: false,
- * }
+ * import type { TokenPair } from '@h-ai/api-client'
+ * const tokens: TokenPair = { accessToken: 'test-access', expiresIn: 3600, tokenType: 'Bearer' }
+ * // 示例为测试凭据；生产 Token 只能来自可信服务端认证响应。
  * ```
  */
-interface EndpointDef<TInput = unknown, TOutput = unknown> {
-    /** HTTP 方法 */
-    method: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
-    /** 相对路径（相对于 API 前缀，如 '/auth/login'） */
-    path: string;
-    /** 入参 Zod Schema（GET 请求为 query params，其他为 body） */
-    input: z.ZodType<TInput>;
-    /** 出参 Zod Schema */
-    output: z.ZodType<TOutput>;
-    /** 是否需要认证（默认 true） */
-    requireAuth?: boolean;
-    /** OpenAPI 描述元数据 */
-    meta?: {
-        summary?: string;
-        tags?: string[];
-    };
-}
-/**
- * Token 对（与 @h-ai/iam 的 TokenPair 对齐）
- */
 interface TokenPair {
-    /** Access Token */
-    accessToken: string;
-    /** Refresh Token */
-    refreshToken: string;
-    /** 过期时间（秒） */
-    expiresIn: number;
-    /** Token 类型 */
-    tokenType: 'Bearer';
+    /** 短期访问凭证，请求时作为 `Authorization: Bearer ...`。 */
+    readonly accessToken: string;
+    /** 长期刷新凭证；httpOnly cookie 模式下由服务端管理，响应体中可能不存在。 */
+    readonly refreshToken?: string;
+    /** accessToken 有效期秒数。 */
+    readonly expiresIn: number;
+    /** 固定为 `'Bearer'`。 */
+    readonly tokenType: 'Bearer';
 }
 /**
- * Token 存储适配器
+ * 异步安全凭据存储契约；null 仅表示无可用凭据，读写故障须拒绝 Promise。
+ * 浏览器使用内存 access token/httpOnly refresh Cookie，原生端注入平台安全存储，禁止敏感 Token 放入 localStorage。
+ * 已绑定客户端的身份切换通过 client.auth，避免绕过刷新代际与串行写入；部分写入失败须执行清理并报告清理失败。
+ *
+ * 内置实现：
+ * - `apiClient.tokenStorage.httpOnlyCookie()` — **默认**；浏览器端推荐，refresh token 由服务端管理，防 XSS。
+ * - `apiClient.tokenStorage.memory()` — Node.js 测试 / SSR（需显式传入）。
+ *
+ * Capacitor / 小程序场景请由对应模块提供（例如 `@h-ai/capacitor`）。
  *
- * 可插拔存储后端（localStorage / memory / Capacitor Preferences / 自定义）。
+ * @example
+ * ```ts
+ * import { apiClient, type TokenStorage } from '@h-ai/api-client'
+ * const storage: TokenStorage = apiClient.tokenStorage.memory()
+ * await storage.setAccessToken('test-access')
+ * const accessToken = await storage.getAccessToken()
+ * await storage.clear()
+ * ```
  */
 interface TokenStorage {
-    /** 获取 Access Token */
-    getAccessToken: () => Promise<string | null>;
-    /** 设置 Access Token */
-    setAccessToken: (token: string) => Promise<void>;
-    /** 获取 Refresh Token */
-    getRefreshToken: () => Promise<string | null>;
-    /** 设置 Refresh Token */
-    setRefreshToken: (token: string) => Promise<void>;
-    /** 清空所有 Token */
-    clear: () => Promise<void>;
-}
-/**
- * 请求配置（传递给拦截器）
- */
-interface RequestConfig {
-    /** 完整 URL */
-    url: string;
-    /** HTTP 方法 */
-    method: string;
-    /** 请求头 */
-    headers: Record<string, string>;
-    /** 请求体（已序列化） */
-    body?: string | FormData;
-    /** 信号（abort） */
-    signal?: AbortSignal;
+    /**
+     * 读取本适配器可用 access token；无凭据返回 null，存储故障拒绝。
+     * @returns Token 或 null；不能把读取失败当成不存在。
+     *
+     * @example
+     * ```ts
+     * import { apiClient } from '@h-ai/api-client'
+     * const storage = apiClient.tokenStorage.memory()
+     * const accessToken = await storage.getAccessToken()
+     * ```
+     */
+    readonly getAccessToken: () => Promise<string | null>;
+    /**
+     * 保存 access token；已绑定客户端应通过 auth.setTokens 维护代际。
+     * @param token - 可信服务端认证返回的 access token。
+     * @returns 写入完成；底层故障须拒绝。
+     *
+     * @example
+     * ```ts
+     * import { apiClient } from '@h-ai/api-client'
+     * const storage = apiClient.tokenStorage.memory()
+     * await storage.setAccessToken('test-access')
+     * await storage.clear()
+     * ```
+     */
+    readonly setAccessToken: (token: string) => Promise<void>;
+    /**
+     * 读取 refresh token 或 Cookie 模式内部哨兵；null 仅表示没有凭据。
+     * @returns Token、模式哨兵或 null，不是对 httpOnly Cookie 内容的脚本读取。
+     *
+     * @example
+     * ```ts
+     * import { apiClient } from '@h-ai/api-client'
+     * const storage = apiClient.tokenStorage.memory()
+     * const refreshToken = await storage.getRefreshToken()
+     * // 内存适配器初始为空；Cookie 适配器由管理器识别模式哨兵。
+     * ```
+     */
+    readonly getRefreshToken: () => Promise<string | null>;
+    /**
+     * 保存 refresh token；Cookie 实现不通过脚本修改服务端 Cookie。
+     * @param token - 服务端返回的刷新凭据；禁止写入 Web Storage。
+     * @returns 写入完成；原生安全存储故障须拒绝。
+     *
+     * @example
+     * ```ts
+     * import { apiClient } from '@h-ai/api-client'
+     * const storage = apiClient.tokenStorage.memory()
+     * await storage.setRefreshToken('test-refresh')
+     * await storage.clear()
+     * ```
+     */
+    readonly setRefreshToken: (token: string) => Promise<void>;
+    /**
+     * 清空适配器可管理的凭据；Cookie 实现只能清内存 access token。
+     * @returns 清理完成；失败须拒绝，服务端 Cookie/会话另由退出接口撤销。
+     *
+     * @example
+     * ```ts
+     * import { apiClient } from '@h-ai/api-client'
+     * const storage = apiClient.tokenStorage.memory()
+     * await storage.clear()
+     * const remaining = await storage.getAccessToken()
+     * ```
+     */
+    readonly clear: () => Promise<void>;
 }
-/** 请求拦截器 */
-type RequestInterceptor = (config: RequestConfig) => RequestConfig | Promise<RequestConfig>;
-/** 响应拦截器 */
-type ResponseInterceptor = (response: Response) => Response | Promise<Response>;
 /**
- * Token 刷新配置
+ * 启用 Token 注入与自动刷新；默认 Cookie 适配器，refreshPath 相对 baseUrl。
+ * 网络/超时/5xx 为暂时失败，保留凭据；明确失效才清理并通知。回调不应抛出或记录 Token。
+ *
+ * @example
+ * ```ts
+ * import { apiClient, type AuthConfig } from '@h-ai/api-client'
+ * const auth: AuthConfig = { storage: apiClient.tokenStorage.memory(), refreshPath: '/auth/refresh', refreshTimeoutMs: 5000, onTokenRefreshed: tokens => { const lifetime = tokens.expiresIn } }
+ * // Node/SSR 选择独立内存存储；浏览器通常直接配置 auth: {}。
+ * ```
  */
 interface AuthConfig {
-    /** Token 存储适配器（默认 createLocalStorageTokenStorage） */
-    storage?: TokenStorage;
-    /** Refresh Token 接口路径（相对于 baseUrl） */
-    refreshUrl: string;
-    /** Token 刷新回调 */
-    onTokenRefreshed?: (tokens: TokenPair) => void;
-    /** Token 刷新失败回调（通常用于跳转登录页） */
-    onRefreshFailed?: () => void;
+    /** refresh明确失效后原地恢复同一用户会话，成功时只重试原请求一次；取消/结果不明不得返回true。 */
+    readonly recoverSession?: () => Promise<boolean>;
+    /** 登录会话终端分组；默认web，可选app/desktop/api。服务端必须允许该类；不代表物理设备证明。 */
+    readonly terminalType?: 'web' | 'app' | 'desktop' | 'api';
+    /**
+     * Token 存储适配器；默认 `apiClient.tokenStorage.httpOnlyCookie()`（refresh token 由服务端管理，防 XSS）。
+     *
+     * - SSR / Node.js 测试场景请显式传入 `apiClient.tokenStorage.memory()`。
+     * - 浏览器刷新后通过 httpOnly Cookie 恢复会话，不将 Token 持久化到 Web Storage。
+     * - Capacitor / 小程序请使用对应平台的安全存储适配器（如 `@h-ai/capacitor`）。
+     */
+    readonly storage?: TokenStorage;
+    /** 刷新接口路径，相对于 `baseUrl`，默认 `/auth/refresh`。 */
+    readonly refreshPath?: string;
+    /**
+     * 刷新请求超时（ms），默认 10_000。
+     * 避免 refresh 接口上游挂死时所有 dedup 调用方一起 hang。
+     * 超时后按现有 transient 失败处理（不清 token，下次请求可重试）。
+     */
+    readonly refreshTimeoutMs?: number;
+    /** 刷新成功回调，用于同步状态（例如多 Tab 广播）。 */
+    readonly onTokenRefreshed?: (tokens: TokenPair) => void;
+    /** 刷新失败回调（如 refresh token 已失效），通常用于跳转登录页。 */
+    readonly onRefreshFailed?: () => void;
 }
 /**
- * ApiClient 配置
+ * 客户端初始化配置；baseUrl 包含 API 前缀，headers/fetch 用于平台适配。
+ * auth 缺省时不创建 TokenManager；timeout 是底层请求中断期限，不代表服务端已取消副作用。
+ * transport 需要已初始化 crypto，首次业务请求前协商会话；客户端不接收服务端私钥。
+ *
+ * @example
+ * ```ts
+ * import { apiClient, type ApiClientConfig } from '@h-ai/api-client'
+ * const config: ApiClientConfig = { baseUrl: 'https://api.example.com/api/v1', auth: { storage: apiClient.tokenStorage.memory() }, timeout: 15000, clientName: 'orders-web', headers: () => ({ 'x-app-channel': 'web' }) }
+ * const initialized = await apiClient.init(config)
+ * if (!initialized.success) throw new Error(initialized.error.message)
+ * await apiClient.close()
+ * ```
  */
 interface ApiClientConfig {
-    /** API 基础 URL（如 https://api.example.com/api/v1） */
-    baseUrl: string;
-    /** Token 认证配置（省略则不启用自动 Token 管理） */
-    auth?: AuthConfig;
-    /** 请求超时（毫秒，默认 30000） */
-    timeout?: number;
-    /** 拦截器 */
-    interceptors?: {
-        request?: RequestInterceptor[];
-        response?: ResponseInterceptor[];
-    };
-    /** 自定义 fetch 实现（用于测试或特殊环境） */
-    fetch?: typeof globalThis.fetch;
-}
-/**
- * 文件上传选项
- */
-interface UploadOptions {
-    /** 文件字段名（默认 'file'） */
-    fieldName?: string;
-    /** 附加表单字段 */
-    extraFields?: Record<string, string>;
-}
-/**
- * 流式请求选项
- */
-interface StreamOptions {
-    /** 外部取消信号（例如 AbortController.signal） */
-    signal?: AbortSignal;
+    /** API service 完整 baseUrl，通常含 `apiPrefix`，例如 `https://api.example.com/api/v1`。 */
+    readonly baseUrl: string;
+    /** 认证配置；不传则不启用 Token 注入与自动刷新。 */
+    readonly auth?: AuthConfig;
+    /** 请求超时（ms），默认 30000。 */
+    readonly timeout?: number;
+    /** 客户端标识，写入 `x-request-client` 请求头，默认 `hai-api-client`。 */
+    readonly clientName?: string;
+    /** 额外请求头，可为静态对象或异步函数。 */
+    readonly headers?: Record<string, string> | (() => Record<string, string> | Promise<Record<string, string>>);
+    /** 自定义 fetch（测试 mock / Capacitor / 小程序桥接）。 */
+    readonly fetch?: typeof globalThis.fetch;
+    /**
+     * 启用端到端传输加密（opt-in）。
+     *
+     * 配置后所有出站请求会在底层 fetch 之上做一次混合加密，并自动解密
+     * 标记为 `X-Encrypted: true` 的响应。服务端需启用对应的 `serv.createApp({ transport })`。
+     *
+     * `crypto` 字段结构与 `@h-ai/crypto` 的 `crypto` 实例兼容；通常直接传入：
+     *
+     * @example
+     * ```ts
+     * import { apiClient } from '@h-ai/api-client'
+     * import { crypto } from '@h-ai/crypto'
+     *
+     * const cryptography = await crypto.init()
+     * if (!cryptography.success) throw new Error(cryptography.error.message)
+     * try {
+     *   const initialized = await apiClient.init({ baseUrl: 'https://api.example.com/api/v1', transport: { crypto } })
+     *   if (!initialized.success) throw new Error(initialized.error.message)
+     *   await apiClient.close()
+     * }
+     * finally { await crypto.close() }
+     * ```
+     */
+    readonly transport?: ApiClientTransportConfig;
 }
 /**
- * Api Client 实例接口
+ * 可选加密会话配置；密钥协商路径相对 baseUrl，并与服务端配置匹配。
+ * crypto 必须先初始化；服务器版本公钥通过受保护的 TLS 握手取得，不配置服务端私钥。
+ * 传输防重放不能代替业务幂等性，失败后不要自动重放非幂等操作。
  *
- * 提供通用 HTTP 方法和契约调用能力。
+ * @example
+ * ```ts
+ * import { apiClient, type ApiClientTransportConfig } from '@h-ai/api-client'
+ * import { crypto } from '@h-ai/crypto'
+ * const cryptography = await crypto.init()
+ * if (!cryptography.success) throw new Error(cryptography.error.message)
+ * try {
+ *   const transport: ApiClientTransportConfig = { crypto, keyExchangePath: '/_hai/key-exchange' }
+ *   const initialized = await apiClient.init({ baseUrl: 'https://api.example.com/api/v1', transport })
+ *   if (!initialized.success) throw new Error(initialized.error.message)
+ *   await apiClient.close()
+ * }
+ * finally { await crypto.close() }
+ * ```
  */
-interface ApiClient {
-    /** GET 请求 */
-    get: <T>(path: string, params?: Record<string, unknown>) => Promise<HaiResult<T>>;
-    /** POST 请求 */
-    post: <T>(path: string, body?: unknown) => Promise<HaiResult<T>>;
-    /** PUT 请求 */
-    put: <T>(path: string, body?: unknown) => Promise<HaiResult<T>>;
-    /** PATCH 请求 */
-    patch: <T>(path: string, body?: unknown) => Promise<HaiResult<T>>;
-    /** DELETE 请求 */
-    delete: <T>(path: string, params?: Record<string, unknown>) => Promise<HaiResult<T>>;
-    /** 文件上传 */
-    upload: (path: string, file: File | Blob, options?: UploadOptions) => Promise<HaiResult<unknown>>;
-    /** 流式请求（返回 AsyncIterable） */
-    stream: (path: string, body?: unknown, options?: StreamOptions) => AsyncIterable<string>;
+interface ApiClientTransportConfig {
+    /** 可选本地明文 UTF-8 字节上限；缺省自动跟随服务端，指定时取较小值。 */
+    readonly maxPlaintextBytes?: number;
+    /**
+     * crypto 服务实例（通常直接传入 `@h-ai/crypto` 的 `crypto`）。
+     * api-client 通过 `crypto.transport.createClient(...)` 创建会话。
+     */
+    readonly crypto: CryptoFunctions;
     /**
-     * 契约调用（推荐）
+     * 密钥协商端点路径，相对于 `baseUrl`，默认 `/_hai/key-exchange`。
      *
-     * 基于 EndpointDef 发起请求，路径、方法、入参、出参类型全由契约保证。
+     * 必须与服务端 `serv.createApp({ transport: { keyExchangePath } })` 一致。
      */
-    call: <TInput, TOutput>(endpoint: EndpointDef<TInput, TOutput>, input: TInput) => Promise<HaiResult<TOutput>>;
-    /** Token 管理 */
-    auth: {
-        /** 设置 Token */
-        setTokens: (tokens: TokenPair) => Promise<void>;
-        /** 清空 Token */
-        clear: () => Promise<void>;
-        /** Token 刷新回调，返回取消订阅函数 */
-        onTokenRefreshed: (callback: (tokens: TokenPair) => void) => () => void;
-    };
+    readonly keyExchangePath?: string;
 }
 /**
- * 辅助函数：创建端点定义（获得类型推导）
+ * 当前客户端的凭据辅助操作；仅 init 启用 auth 时建立实际管理器。
+ * setTokens/clear 撤销旧刷新代际并等待串行存储变更；故障拒绝 Promise，调用方处理失败。
+ * clear 不能撤销服务端会话或删除 httpOnly Cookie，退出仍需服务端接口成功。
  *
  * @example
  * ```ts
- * const login = defineEndpoint({
- *   method: 'POST',
- *   path: '/auth/login',
- *   input: LoginInputSchema,
- *   output: LoginOutputSchema,
- *   requireAuth: false,
- * })
+ * import { apiClient, type ApiClientAuth } from '@h-ai/api-client'
+ * const initialized = await apiClient.init({ baseUrl: 'https://api.example.com/api/v1', auth: {} })
+ * if (!initialized.success) throw new Error(initialized.error.message)
+ * try {
+ *   const auth: ApiClientAuth = apiClient.auth
+ *   const off = auth.onTokenRefreshed(tokens => { const lifetime = tokens.expiresIn })
+ *   off()
+ *   await auth.clear()
+ * }
+ * finally { await apiClient.close() }
  * ```
  */
-declare function defineEndpoint<TInput, TOutput>(def: EndpointDef<TInput, TOutput>): EndpointDef<TInput, TOutput>;
+interface ApiClientAuth {
+    /**
+     * 替换整对凭据并同步废弃旧刷新代际；缺省 refreshToken 时清除旧值。
+     * @param tokens - 服务端成功认证返回的真实 TokenPair。
+     * @returns 写入完成；安全存储失败拒绝 Promise，调用方应清理部分凭据并报告清理失败。
+     *
+     * @example
+     * ```ts
+     * import { apiClient } from '@h-ai/api-client'
+     * const initialized = await apiClient.init({ baseUrl: 'https://api.example.com/api/v1', auth: {} })
+     * if (!initialized.success) throw new Error(initialized.error.message)
+     * try {
+     *   const form = { identifier: 'alice', password: 'test-password' }
+     *   const login = await apiClient.iam.auth.login(form)
+     *   if (!login.success) throw new Error(login.error.message)
+     *   try { await apiClient.auth.setTokens(login.data.tokens) }
+     *   catch (writeError) {
+     *     try { await apiClient.auth.clear() }
+     *     catch (cleanupError) { throw new AggregateError([writeError, cleanupError], 'Credential persistence and cleanup failed') }
+     *     throw writeError
+     *   }
+     * }
+     * finally { await apiClient.close() }
+     * ```
+     */
+    readonly setTokens: (tokens: TokenPair) => Promise<void>;
+    /**
+     * 同步废弃旧刷新代际并等待存储清理；失败拒绝 Promise，不声称已持久删除。
+     * 服务端会话与 httpOnly Cookie 仍需服务端退出撤销；本操作不能替代退出接口。
+     * @returns 本地清理完成，不返回 HaiResult。
+     *
+     * @example
+     * ```ts
+     * import { apiClient } from '@h-ai/api-client'
+     * const initialized = await apiClient.init({ baseUrl: 'https://api.example.com/api/v1', auth: {} })
+     * if (!initialized.success) throw new Error(initialized.error.message)
+     * try {
+     *   const logout = await apiClient.iam.auth.logout({})
+     *   await apiClient.auth.clear()
+     *   if (!logout.success) throw new Error(logout.error.message)
+     *   // 只有服务端退出和本地清理都成功，才能确认两侧均已处理。
+     * }
+     * finally { await apiClient.close() }
+     * ```
+     */
+    readonly clear: () => Promise<void>;
+    /**
+     * 订阅当前管理器刷新成功事件；回调在写入后同步调用，避免抛错或输出 Token。
+     * @param callback - 接收 TokenPair 的同步回调。
+     * @returns 取消订阅函数；未启用 auth 时返回空操作。
+     *
+     * @example
+     * ```ts
+     * import { apiClient } from '@h-ai/api-client'
+     * const initialized = await apiClient.init({ baseUrl: 'https://api.example.com/api/v1', auth: {} })
+     * if (!initialized.success) throw new Error(initialized.error.message)
+     * try {
+     *   const off = apiClient.auth.onTokenRefreshed(tokens => { const expiresIn = tokens.expiresIn })
+     *   off()
+     * }
+     * finally { await apiClient.close() }
+     * ```
+     */
+    readonly onTokenRefreshed: (callback: (tokens: TokenPair) => void) => () => void;
+}
 /**
- * API 客户端函数接口（单例模式）
+ * 客户端生命周期与认证辅助能力；init 的 HaiResult 必须先检查 success。
+ * 同一实例并发 init 共享在途初始化，已初始化后再 init 返回 CONFIG_ERROR；切换配置先 close。
+ * config 为脱敏快照；close 清理运行状态/加密会话，不等于服务端退出或凭据存储清理。
  *
- * 统一的 API 客户端访问入口：
- * - `api.init(config)` — 初始化客户端
- * - `api.close()` — 关闭客户端并释放资源
- * - `api.get / post / put / patch / delete` — 通用 HTTP 方法
- * - `api.call(endpoint, input)` — 契约调用
- * - `api.upload(path, file)` — 文件上传
- * - `api.stream(path, body)` — 流式请求
- * - `api.auth` — Token 管理
- * - `api.config` — 当前配置（未初始化时为 null）
- * - `api.isInitialized` — 初始化状态
+ * @example
+ * ```ts
+ * import { apiClient, type ApiClientLifecycle } from '@h-ai/api-client'
+ * const client: ApiClientLifecycle = apiClient
+ * const initialized = await client.init({ baseUrl: 'https://api.example.com/api/v1' })
+ * if (!initialized.success) throw new Error(initialized.error.message)
+ * const active = client.isInitialized
+ * const snapshot = client.config
+ * await client.close()
+ * ```
  */
-interface ApiClientFunctions {
+interface ApiClientLifecycle {
     /**
-     * 初始化 API 客户端
-     *
-     * 已有实例时会先 close 再重新初始化。
-     *
-     * @param config - 客户端配置
-     * @returns 成功 ok(undefined)；失败返回 err（含 ApiClientError）
+     * 观察一次逻辑调用的最终结果；刷新重试保留关联 ID，不包含请求正文或凭据。
+     * close 清理订阅；回调异常不影响请求，返回函数可提前取消。
+     * @example
+     * ```ts
+     * import { apiClient } from '@h-ai/api-client'
+     * const unsubscribe = apiClient.observeRequests(record => { const requestId = record.requestId })
+     * unsubscribe()
+     * ```
      */
-    init: (config: ApiClientConfig) => Promise<HaiResult<void>>;
+    readonly observeRequests: (observer: ApiRequestObserver) => () => void;
     /**
-     * 关闭 API 客户端并释放资源
+     * 构造并提交客户端运行状态；初始化失败返回 CONFIG_ERROR，未提交半初始化对象。
+     * 并发 init 共享同一初始化；已初始化再调用会失败，切换配置先 close。
+     * @param config - baseUrl、认证、fetch 与可选加密配置。
+     * @returns HaiResult；必须先判断 success，再发起 procedure。
      *
-     * 重复调用不会报错。
+     * @example
+     * ```ts
+     * import { apiClient } from '@h-ai/api-client'
+     * const initialized = await apiClient.init({ baseUrl: 'https://api.example.com/api/v1', auth: {} })
+     * if (!initialized.success) throw new Error(initialized.error.message)
+     * try {
+     *   const result = await apiClient.iam.auth.publicConfig()
+     *   if (!result.success) throw new Error(result.error.message)
+     * }
+     * finally { await apiClient.close() }
+     * ```
      */
-    close: () => Promise<void>;
-    /** 当前客户端配置；未初始化或已关闭时为 null */
-    readonly config: ApiClientConfig | null;
-    /** 是否已完成初始化 */
-    readonly isInitialized: boolean;
-    /** GET 请求 */
-    readonly get: ApiClient['get'];
-    /** POST 请求 */
-    readonly post: ApiClient['post'];
-    /** PUT 请求 */
-    readonly put: ApiClient['put'];
-    /** PATCH 请求 */
-    readonly patch: ApiClient['patch'];
-    /** DELETE 请求 */
-    readonly delete: ApiClient['delete'];
-    /** 文件上传 */
-    readonly upload: ApiClient['upload'];
+    readonly init: (config: ApiClientConfig) => Promise<HaiResult<void>>;
     /**
-     * 流式请求（返回 AsyncIterable）
+     * 销毁当前加密会话并清除运行状态，允许重新 init；不发送服务端退出、不清空外置存储。
+     * @returns 资源清理完成；不是 HaiResult，不应读取 success。
      *
-     * @throws 未初始化时抛出异常（async generator 无法返回 HaiResult）
+     * @example
+     * ```ts
+     * import { apiClient } from '@h-ai/api-client'
+     * const initialized = await apiClient.init({ baseUrl: 'https://api.example.com/api/v1', auth: {} })
+     * if (!initialized.success) throw new Error(initialized.error.message)
+     * await apiClient.close()
+     * const reinitialized = await apiClient.init({ baseUrl: 'https://api.example.com/api/v1', auth: {} })
+     * if (!reinitialized.success) throw new Error(reinitialized.error.message)
+     * await apiClient.close()
+     * ```
      */
-    readonly stream: ApiClient['stream'];
-    /** 契约调用（推荐） */
-    readonly call: ApiClient['call'];
-    /** Token 管理 */
-    readonly auth: ApiClient['auth'];
+    readonly close: () => Promise<void>;
+    /** 当前脱敏后的运行配置快照；未初始化时为 `null`。 */
+    readonly config: ApiClientConfig | null;
+    /** 是否已完成初始化。 */
+    readonly isInitialized: boolean;
+    /** Token 辅助操作。 */
+    readonly auth: ApiClientAuth;
 }
-
 /**
- * @h-ai/api-client — Token 存储适配器
+ * 逻辑请求诊断摘要。HTTP 200 的失败 HaiResult 同样 success=false。
+ * @example
+ * ```ts
+ * import type { ApiRequestRecord } from '@h-ai/api-client'
+ * const record: ApiRequestRecord = { requestId: 'request-1', procedure: 'orders.get', timestamp: 1, duration: 10, success: false, attempts: 1, errorCode: 'orders:missing' }
+ * ```
+ */
+interface ApiRequestRecord {
+    readonly requestId: string;
+    readonly procedure: string;
+    readonly timestamp: number;
+    readonly duration: number;
+    readonly success: boolean;
+    readonly attempts: number;
+    readonly errorCode?: string;
+    readonly method?: string;
+    readonly url?: string;
+    readonly status?: number;
+}
+/**
+ * 同步观察者，只做有界收集。
+ * @example
+ * ```ts
+ * import { apiClient, type ApiRequestObserver } from '@h-ai/api-client'
+ * const observer: ApiRequestObserver = record => { const failed = !record.success }
+ * const unsubscribe = apiClient.observeRequests(observer)
+ * unsubscribe()
+ * ```
+ */
+type ApiRequestObserver = (record: ApiRequestRecord) => void;
+/**
+ * 由 oRPC 契约推导的 JSON typed client，与生命周期组合；procedure 的输入/输出由契约决定。
+ * 调用先检查初始化和业务 HaiResult；自定义契约不能覆盖 init/close/config/isInitialized/auth 顶层成员。
  *
- * 提供 localStorage 和内存两种内置 Token 存储实现。
- * @module api-client-auth
+ * @example
+ * ```ts
+ * import { apiClient, type ApiClient } from '@h-ai/api-client'
+ * import { apiContract } from '@h-ai/api-contract'
+ * const contract = apiContract.create({ iam: apiContract.iam })
+ * const client: ApiClient<typeof contract> = apiClient.create(contract)
+ * const initialized = await client.init({ baseUrl: 'https://api.example.com/api/v1', auth: {} })
+ * if (!initialized.success) throw new Error(initialized.error.message)
+ * try {
+ *   const result = await client.iam.auth.currentUser()
+ *   if (!result.success) throw new Error(result.error.message)
+ *   const userId = result.data.id
+ * }
+ * finally { await client.close() }
+ * ```
  */
+type ApiClient<TContract extends AnyContractRouter> = ApiClientLifecycle & JsonifiedClient<ContractRouterClient<TContract>>;
 
 /**
- * 创建基于 localStorage 的 Token 存储
- *
- * 适用于浏览器端 SPA / PWA。Capacitor 环境建议使用
- * `@h-ai/capacitor` 提供的 `CapacitorTokenStorage`。
- *
- * @returns TokenStorage 实例
+ * 认证表单登录输入；默认 password，ldap 使用 identifier/password，email/sms 使用 identifier/code。
+ * method/code 为客户端表单辅助字段，按所选方式映射到标准 IAM procedure。
  *
  * @example
  * ```ts
- * import { api, createLocalStorageTokenStorage } from '@h-ai/api-client'
- *
- * await api.init({
- *   baseUrl: 'https://api.example.com',
- *   auth: {
- *     storage: createLocalStorageTokenStorage(),
- *     refreshUrl: '/auth/refresh',
- *   },
- * })
+ * import type { IamAuthLoginInput } from '@h-ai/api-client'
+ * const input: IamAuthLoginInput = { identifier: 'alice@example.com', password: '', method: 'email', code: '123456' }
  * ```
  */
-declare function createLocalStorageTokenStorage(): TokenStorage;
+type IamAuthLoginInput = IamLoginInput & {
+    method?: 'password' | 'ldap' | 'email' | 'sms';
+    code?: string;
+};
 /**
- * 创建内存 Token 存储
+ * 将含标准 IAM 契约的客户端绑定为认证表单动作；包用户通过 apiClient.createAuthActions 调用。
+ * 登录/注册成功后等待 client.auth.setTokens，失败 HaiResult 原样返回；存储失败拒绝 Promise，不能据服务端成功就显示已登录。
+ * 调用方必须先 init 并启用 auth；未启用 auth 时客户端 setTokens 不会建立 Token 管理器。
+ * @param client - 具有标准 IAM procedure 与 setTokens 能力的已初始化客户端。
+ * @param client.iam - 标准 IAM 契约的领域分组。
+ * @param client.iam.auth - 公开配置、登录、注册、验证码和密码重置 procedure。
+ * @param client.auth - 认证成功后的凭据写入能力（setTokens）。
+ * @returns publicConfig、按方式登录、注册、验证码和密码重置动作。
  *
- * 适用于 Node.js 测试、SSR 或短生命周期场景。
- * 页面刷新后 Token 丢失。
+ * @example
+ * ```ts
+ * import { apiClient } from '@h-ai/api-client'
+ * const initialized = await apiClient.init({ baseUrl: 'https://api.example.com/api/v1', auth: {} })
+ * if (!initialized.success) throw new Error(initialized.error.message)
+ * try {
+ *   const actions = apiClient.createAuthActions(apiClient)
+ *   // 运行时凭据来自已验证的表单；此处只请求公开配置，不提交示例密码。
+ *   const config = await actions.publicConfig()
+ *   if (!config.success) throw new Error(config.error.message)
+ * }
+ * finally { await apiClient.close() }
+ * ```
+ */
+declare function createIamAuthActions(client: {
+    iam: {
+        auth: Pick<ApiClient<{
+            iam: typeof apiContract.iam;
+        }>['iam']['auth'], 'publicConfig' | 'createCaptcha' | 'closeSession' | 'login' | 'loginWithLdap' | 'loginWithOtp' | 'register' | 'sendOtp' | 'requestPasswordReset' | 'confirmPasswordReset' | 'renewPassword' | 'reauthenticate'>;
+    };
+    auth: Pick<ApiClient<{
+        iam: typeof apiContract.iam;
+    }>['auth'], 'setTokens'>;
+}): {
+    bindPageExit(options?: {
+        enabled?: boolean;
+    }): () => void;
+    publicConfig: () => _orpc_client.ClientPromiseResult<{
+        success: true;
+        data: {
+            captcha: {
+                enabled: boolean;
+            };
+            password: {
+                minLength: number;
+                maxLength: number;
+                requireUppercase: boolean;
+                requireLowercase: boolean;
+                requireNumber: boolean;
+                requireSpecialChar: boolean;
+                expirationDays: number;
+                minCharacterClasses?: number | undefined;
+                preventSamePassword?: boolean | undefined;
+                requireInitialChange?: boolean | undefined;
+            };
+            register: {
+                enabled: boolean;
+            };
+            login: {
+                password: boolean;
+                otp: boolean;
+                ldap: boolean;
+                email: boolean;
+                sms: boolean;
+            };
+            passwordReset: {
+                enabled: boolean;
+                mode: "email" | "phone";
+            };
+            otp: {
+                length: number;
+                resendInterval: number;
+            };
+            agreements: {
+                showOnRegister: boolean;
+                showOnLogin: boolean;
+                userAgreementMarkdown?: string | undefined;
+                privacyPolicyMarkdown?: string | undefined;
+                userAgreementUrl?: string | undefined;
+                privacyPolicyUrl?: string | undefined;
+            };
+            ui: {
+                variant: "split" | "card";
+                title?: string | undefined;
+                subtitle?: string | undefined;
+                brandTitle?: string | undefined;
+                brandText?: string | undefined;
+                logoUrl?: string | undefined;
+                illustrationUrl?: string | undefined;
+            };
+            session: {
+                maxAge: number;
+                endOnPageHide: boolean;
+            };
+            reauthentication?: {
+                enabled: boolean;
+                operations: string[];
+            } | undefined;
+            initialCredentials?: {
+                enabled: boolean;
+            } | undefined;
+        } | null;
+    } | {
+        success: false;
+        error: {
+            code: string | number;
+            message: string;
+            traceId?: string | undefined;
+            httpStatus?: number | undefined;
+            system?: string | undefined;
+            module?: string | undefined;
+            cause?: unknown;
+            suggestion?: string | undefined;
+            ext?: {
+                [x: string]: unknown;
+            } | undefined;
+        };
+    }, Error>;
+    createCaptcha: (input: Parameters<typeof client.iam.auth.createCaptcha>[0]) => _orpc_client.ClientPromiseResult<{
+        success: true;
+        data: {
+            id: string;
+            challenge: {
+                parameters: {
+                    algorithm: "PBKDF2/SHA-256";
+                    nonce: string;
+                    salt: string;
+                    cost: number;
+                    keyLength: number;
+                    keyPrefix: string;
+                    keySignature?: string | undefined;
+                    data?: {
+                        [x: string]: string | number | boolean | null;
+                    } | undefined;
+                };
+                signature?: string | undefined;
+            };
+        };
+    } | {
+        success: false;
+        error: {
+            code: string | number;
+            message: string;
+            traceId?: string | undefined;
+            httpStatus?: number | undefined;
+            system?: string | undefined;
+            module?: string | undefined;
+            cause?: unknown;
+            suggestion?: string | undefined;
+            ext?: {
+                [x: string]: unknown;
+            } | undefined;
+        };
+    }, Error>;
+    login: (input: IamAuthLoginInput) => Promise<HaiResult<{
+        user: {
+            id: string;
+            username: string;
+            accountStatus: "active" | "dormant" | "closed";
+            createdAt: string;
+            updatedAt: string;
+            email?: string | undefined;
+            phone?: string | undefined;
+            displayName?: string | undefined;
+            avatarUrl?: string | undefined;
+            accountType?: "permanent" | "temporary" | undefined;
+            accountExpiresAt?: string | null | undefined;
+            lastLoginAt?: string | null | undefined;
+            mustChangePassword?: boolean | undefined;
+            emailVerified?: boolean | undefined;
+            phoneVerified?: boolean | undefined;
+            metadata?: {
+                [x: string]: unknown;
+            } | undefined;
+        };
+        tokens: {
+            accessToken: string;
+            expiresIn: number;
+            tokenType: "Bearer";
+            refreshToken?: string | undefined;
+        };
+        roles: string[];
+        permissions: string[];
+        agreements?: {
+            showOnRegister: boolean;
+            showOnLogin: boolean;
+            userAgreementMarkdown?: string | undefined;
+            privacyPolicyMarkdown?: string | undefined;
+            userAgreementUrl?: string | undefined;
+            privacyPolicyUrl?: string | undefined;
+        } | undefined;
+    }>>;
+    register: (input: IamRegisterInput) => Promise<HaiResult<{
+        user: {
+            id: string;
+            username: string;
+            accountStatus: "active" | "dormant" | "closed";
+            createdAt: string;
+            updatedAt: string;
+            email?: string | undefined;
+            phone?: string | undefined;
+            displayName?: string | undefined;
+            avatarUrl?: string | undefined;
+            accountType?: "permanent" | "temporary" | undefined;
+            accountExpiresAt?: string | null | undefined;
+            lastLoginAt?: string | null | undefined;
+            mustChangePassword?: boolean | undefined;
+            emailVerified?: boolean | undefined;
+            phoneVerified?: boolean | undefined;
+            metadata?: {
+                [x: string]: unknown;
+            } | undefined;
+        };
+        tokens: {
+            accessToken: string;
+            expiresIn: number;
+            tokenType: "Bearer";
+            refreshToken?: string | undefined;
+        };
+        roles: string[];
+        permissions: string[];
+        agreements?: {
+            showOnRegister: boolean;
+            showOnLogin: boolean;
+            userAgreementMarkdown?: string | undefined;
+            privacyPolicyMarkdown?: string | undefined;
+            userAgreementUrl?: string | undefined;
+            privacyPolicyUrl?: string | undefined;
+        } | undefined;
+    }>>;
+    sendOtp: (identifier: string, options?: {
+        captcha?: string;
+    }) => _orpc_client.ClientPromiseResult<{
+        success: true;
+        data: {
+            expiresAt: string;
+        };
+    } | {
+        success: false;
+        error: {
+            code: string | number;
+            message: string;
+            traceId?: string | undefined;
+            httpStatus?: number | undefined;
+            system?: string | undefined;
+            module?: string | undefined;
+            cause?: unknown;
+            suggestion?: string | undefined;
+            ext?: {
+                [x: string]: unknown;
+            } | undefined;
+        };
+    }, Error>;
+    requestPasswordReset: (identifier: string, options?: {
+        captcha?: string;
+    }) => _orpc_client.ClientPromiseResult<{
+        success: true;
+        data: unknown;
+    } | {
+        success: false;
+        error: {
+            code: string | number;
+            message: string;
+            traceId?: string | undefined;
+            httpStatus?: number | undefined;
+            system?: string | undefined;
+            module?: string | undefined;
+            cause?: unknown;
+            suggestion?: string | undefined;
+            ext?: {
+                [x: string]: unknown;
+            } | undefined;
+        };
+    }, Error>;
+    confirmPasswordReset: (token: string, newPassword: string) => _orpc_client.ClientPromiseResult<{
+        success: true;
+        data: unknown;
+    } | {
+        success: false;
+        error: {
+            code: string | number;
+            message: string;
+            traceId?: string | undefined;
+            httpStatus?: number | undefined;
+            system?: string | undefined;
+            module?: string | undefined;
+            cause?: unknown;
+            suggestion?: string | undefined;
+            ext?: {
+                [x: string]: unknown;
+            } | undefined;
+        };
+    }, Error>;
+    renewPassword: (input: {
+        identifier: string;
+        password: string;
+        newPassword: string;
+        captcha?: string;
+    }) => _orpc_client.ClientPromiseResult<{
+        success: true;
+        data: unknown;
+    } | {
+        success: false;
+        error: {
+            code: string | number;
+            message: string;
+            traceId?: string | undefined;
+            httpStatus?: number | undefined;
+            system?: string | undefined;
+            module?: string | undefined;
+            cause?: unknown;
+            suggestion?: string | undefined;
+            ext?: {
+                [x: string]: unknown;
+            } | undefined;
+        };
+    }, Error>;
+    reauthenticate: (password: string, operation: string) => _orpc_client.ClientPromiseResult<{
+        success: true;
+        data: {
+            ticket: string;
+            expiresAt: number;
+        };
+    } | {
+        success: false;
+        error: {
+            code: string | number;
+            message: string;
+            traceId?: string | undefined;
+            httpStatus?: number | undefined;
+            system?: string | undefined;
+            module?: string | undefined;
+            cause?: unknown;
+            suggestion?: string | undefined;
+            ext?: {
+                [x: string]: unknown;
+            } | undefined;
+        };
+    }, Error>;
+};
+
+/**
+ * @h-ai/api-client — Token 存储与刷新管理
  *
- * @returns TokenStorage 实例
+ * 提供两个内置 Token 存储适配器（httpOnly Cookie / 内存）和一个 Token 管理器
+ * （封装存储读写、自动刷新、并发去重、回调通知）。
  *
- * @example
+ * @example 浏览器 SPA
  * ```ts
- * import { api, createMemoryTokenStorage } from '@h-ai/api-client'
+ * import { apiClient } from '@h-ai/api-client'
  *
- * await api.init({
- *   baseUrl: 'https://api.example.com',
- *   auth: {
- *     storage: createMemoryTokenStorage(),
- *     refreshUrl: '/auth/refresh',
- *   },
+ * const initialized = await apiClient.init({
+ *   baseUrl: 'https://api.example.com/api/v1',
+ *   auth: { storage: apiClient.tokenStorage.httpOnlyCookie() },
  * })
+ * if (!initialized.success) throw new Error(initialized.error.message)
+ * await apiClient.close()
+ * ```
+ *
+ * @example Node.js 测试
+ * ```ts
+ * import { apiClient } from '@h-ai/api-client'
+ *
+ * const storage = apiClient.tokenStorage.memory()
+ * await storage.setAccessToken('test-access')
+ * await storage.clear()
  * ```
+ *
+ * @module api-client-auth
  */
-declare function createMemoryTokenStorage(): TokenStorage;
 
 /**
- * @h-ai/api-client — 模块入口
+ * 创建仅属于本适配器实例的内存凭据存储，页面刷新或进程结束后丢失。
+ * SSR 应为每个请求创建客户端和存储实例，避免不同用户共享默认单例。
+ * 通过 client.auth 更新已绑定的存储，才能撤销旧代际刷新；直接存储写入不提供这种保证。
+ * @returns 两个初始为空的 Token 槽位及清理操作。
  *
- * 提供统一的 `api` 对象，管理 HTTP 客户端运行时状态与生命周期。
- * @module api-client-main
+ * @example
+ * ```ts
+ * import { apiClient } from '@h-ai/api-client'
+ * const storage = apiClient.tokenStorage.memory()
+ * await storage.setAccessToken('test-access')
+ * const saved = await storage.getAccessToken()
+ * await storage.clear()
+ * // saved 为本实例的测试值；不把 Token 写入 Web Storage。
+ * ```
  */
+declare function createMemoryTokenStorage(): TokenStorage;
+/**
+ * 创建浏览器使用的内存 access token 与服务端 httpOnly refresh Cookie 适配器。
+ * refresh getter 返回内部哨兵，setter 不修改 Cookie；clear 只清除内存 access token。
+ * 刷新请求使用 credentials: include；服务端须实际设置/撤销 Cookie，配置适当的 Secure、SameSite、Path 与跨域凭据策略。
+ * HttpOnly 限制脚本直接读取 Cookie，不能阻止已执行的恶意脚本代用户发请求；服务端仍须授权和防护 CSRF。
+ * @returns 独立内存 access token 与 Cookie 模式标记；不接触 localStorage。
+ *
+ * @example
+ * ```ts
+ * import { apiClient } from '@h-ai/api-client'
+ * const initialized = await apiClient.init({ baseUrl: 'https://api.example.com/api/v1', auth: { storage: apiClient.tokenStorage.httpOnlyCookie() } })
+ * if (!initialized.success) throw new Error(initialized.error.message)
+ * try {
+ *   const me = await apiClient.iam.auth.currentUser()
+ *   if (!me.success) throw new Error(me.error.message)
+ *   const userId = me.data.id
+ * }
+ * finally { await apiClient.close() }
+ * ```
+ */
+declare function createHttpOnlyCookieTokenStorage(): TokenStorage;
 
+/** Token 存储方案集合：内存 / httpOnly Cookie。 */
+declare const tokenStorage: {
+    /** 内存存储——SSR / Node 测试或一次性会话使用。 */
+    readonly memory: typeof createMemoryTokenStorage;
+    /** httpOnly Cookie 存储——浏览器场景推荐方案。 */
+    readonly httpOnlyCookie: typeof createHttpOnlyCookieTokenStorage;
+};
+/**
+ * 按真实 oRPC 契约创建独立 typed client；公开调用入口为 apiClient.create(contract)。
+ * init 返回 HaiResult，成功后才调用 procedure；已初始化实例必须先 close 再换配置。
+ * procedure 将传输异常转换为 HaiResult；auth.setTokens/clear 的安全存储失败仍会拒绝 Promise。
+ * SSR 应为每个请求创建客户端和内存存储；不共享默认单例中的用户凭据。
+ * @param contract - 已定义的嵌套 oRPC contract；顶层命名不能与生命周期成员冲突。
+ * @returns 生命周期、认证辅助操作与契约推导出的 procedure 代理。
+ *
+ * @example
+ * ```ts
+ * import { apiClient } from '@h-ai/api-client'
+ * import { apiContract } from '@h-ai/api-contract'
+ * const client = apiClient.create(apiContract.create({ iam: apiContract.iam }))
+ * const initialized = await client.init({ baseUrl: 'https://api.example.com/api/v1', auth: { storage: apiClient.tokenStorage.memory() }, timeout: 10000 })
+ * if (!initialized.success) throw new Error(initialized.error.message)
+ * try {
+ *   const result = await client.iam.auth.currentUser()
+ *   if (!result.success) throw new Error(result.error.message)
+ *   const userId = result.data.id
+ * }
+ * finally { await client.close() }
+ * ```
+ */
+declare function createApiClient<const TContract extends AnyContractRouter>(contract: TContract): ApiClient<TContract>;
 /**
- * API 客户端单例
+ * 默认 API typed client：绑定 `iam` / `storage` / `ai` 三个领域。
  *
- * 使用前必须先调用 `api.init()` 初始化，传入 baseUrl 等配置信息。
- * 初始化后通过 `api.get`、`api.post`、`api.call` 等方法发起请求。
+ * 大多数应用只需 `import { apiClient }` 并调用 `apiClient.init()` 即可。
  *
  * @example
  * ```ts
- * import { api } from '@h-ai/api-client'
+ * import { apiClient } from '@h-ai/api-client'
  *
- * // 初始化
- * await api.init({
- *   baseUrl: 'https://api.example.com/api/v1',
- *   auth: { refreshUrl: '/auth/refresh' },
+ * const initialized = await apiClient.init({
+ *   baseUrl: 'http://localhost:3000/api/v1',
+ *   auth: { refreshPath: '/auth/refresh' },
  * })
+ * if (!initialized.success) throw new Error(initialized.error.message)
+ * try {
+ *   const result = await apiClient.iam.auth.currentUser()
+ *   if (!result.success) throw new Error(result.error.message)
+ * }
+ * finally { await apiClient.close() }
+ * ```
+ */
+declare const defaultApiContract: _h_ai_api_contract.CreatedApiContract<{
+    readonly iam: {
+        auth: {
+            createCaptcha: _orpc_contract.ContractProcedureBuilderWithInputOutput<zod.ZodObject<{
+                operation: zod.ZodEnum<{
+                    login: "login";
+                    register: "register";
+                    sendOtp: "sendOtp";
+                    passwordReset: "passwordReset";
+                    renewPassword: "renewPassword";
+                }>;
+            }, zod_v4_core.$strip>, zod.ZodDiscriminatedUnion<[zod.ZodObject<{
+                success: zod.ZodLiteral<true>;
+                data: zod.ZodObject<{
+                    id: zod.ZodString;
+                    challenge: zod.ZodObject<{
+                        signature: zod.ZodOptional<zod.ZodString>;
+                        parameters: zod.ZodObject<{
+                            algorithm: zod.ZodString & zod.ZodType<"PBKDF2/SHA-256", string, zod_v4_core.$ZodTypeInternals<"PBKDF2/SHA-256", string>>;
+                            nonce: zod.ZodString;
+                            salt: zod.ZodString;
+                            cost: zod.ZodNumber;
+                            keyLength: zod.ZodNumber;
+                            keyPrefix: zod.ZodString;
+                            keySignature: zod.ZodOptional<zod.ZodString>;
+                            data: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnion<readonly [zod.ZodString, zod.ZodNumber, zod.ZodBoolean, zod.ZodNull]>>>;
+                        }, zod_v4_core.$strip>;
+                    }, zod_v4_core.$strip>;
+                }, zod_v4_core.$strip>;
+            }, zod_v4_core.$strip>, zod.ZodObject<{
+                success: zod.ZodLiteral<false>;
+                error: zod.ZodObject<{
+                    code: zod.ZodUnion<readonly [zod.ZodString, zod.ZodNumber]>;
+                    message: zod.ZodString;
+                    traceId: zod.ZodOptional<zod.ZodString>;
+                    httpStatus: zod.ZodOptional<zod.ZodNumber>;
+                    system: zod.ZodOptional<zod.ZodString>;
+                    module: zod.ZodOptional<zod.ZodString>;
+                    cause: zod.ZodOptional<zod.ZodUnknown>;
+                    suggestion: zod.ZodOptional<zod.ZodString>;
+                    ext: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
+                }, zod_v4_core.$strip>;
+            }, zod_v4_core.$strip>], "success">, Record<never, never>, Record<never, never>>;
+            reauthenticate: _orpc_contract.ContractProcedureBuilderWithInputOutput<zod.ZodObject<{
+                password: zod.ZodString;
+                operation: zod.ZodString;
+            }, zod_v4_core.$strip>, zod.ZodDiscriminatedUnion<[zod.ZodObject<{
+                success: zod.ZodLiteral<true>;
+                data: zod.ZodObject<{
+                    ticket: zod.ZodString;
+                    expiresAt: zod.ZodNumber;
+                }, zod_v4_core.$strip>;
+            }, zod_v4_core.$strip>, zod.ZodObject<{
+                success: zod.ZodLiteral<false>;
+                error: zod.ZodObject<{
+                    code: zod.ZodUnion<readonly [zod.ZodString, zod.ZodNumber]>;
+                    message: zod.ZodString;
+                    traceId: zod.ZodOptional<zod.ZodString>;
+                    httpStatus: zod.ZodOptional<zod.ZodNumber>;
+                    system: zod.ZodOptional<zod.ZodString>;
+                    module: zod.ZodOptional<zod.ZodString>;
+                    cause: zod.ZodOptional<zod.ZodUnknown>;
+                    suggestion: zod.ZodOptional<zod.ZodString>;
+                    ext: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
+                }, zod_v4_core.$strip>;
+            }, zod_v4_core.$strip>], "success">, Record<never, never>, Record<never, never>>;
+            publicConfig: _orpc_contract.ContractProcedureBuilderWithOutput<_orpc_contract.Schema<unknown, unknown>, zod.ZodDiscriminatedUnion<[zod.ZodObject<{
+                success: zod.ZodLiteral<true>;
+                data: zod.ZodNullable<zod.ZodObject<{
+                    captcha: zod.ZodDefault<zod.ZodObject<{
+                        enabled: zod.ZodBoolean;
+                    }, zod_v4_core.$strip>>;
+                    reauthentication: zod.ZodOptional<zod.ZodObject<{
+                        enabled: zod.ZodBoolean;
+                        operations: zod.ZodArray<zod.ZodString>;
+                    }, zod_v4_core.$strip>>;
+                    initialCredentials: zod.ZodOptional<zod.ZodObject<{
+                        enabled: zod.ZodBoolean;
+                    }, zod_v4_core.$strip>>;
+                    password: zod.ZodObject<{
+                        minLength: zod.ZodNumber;
+                        maxLength: zod.ZodNumber;
+                        requireUppercase: zod.ZodBoolean;
+                        requireLowercase: zod.ZodBoolean;
+                        requireNumber: zod.ZodBoolean;
+                        requireSpecialChar: zod.ZodBoolean;
+                        expirationDays: zod.ZodNumber;
+                        minCharacterClasses: zod.ZodOptional<zod.ZodNumber>;
+                        preventSamePassword: zod.ZodOptional<zod.ZodBoolean>;
+                        requireInitialChange: zod.ZodOptional<zod.ZodBoolean>;
+                    }, zod_v4_core.$strip>;
+                    register: zod.ZodObject<{
+                        enabled: zod.ZodBoolean;
+                    }, zod_v4_core.$strip>;
+                    login: zod.ZodObject<{
+                        password: zod.ZodBoolean;
+                        otp: zod.ZodBoolean;
+                        ldap: zod.ZodBoolean;
+                        email: zod.ZodBoolean;
+                        sms: zod.ZodBoolean;
+                    }, zod_v4_core.$strip>;
+                    passwordReset: zod.ZodObject<{
+                        enabled: zod.ZodBoolean;
+                        mode: zod.ZodEnum<{
+                            email: "email";
+                            phone: "phone";
+                        }>;
+                    }, zod_v4_core.$strip>;
+                    otp: zod.ZodObject<{
+                        length: zod.ZodNumber;
+                        resendInterval: zod.ZodNumber;
+                    }, zod_v4_core.$strip>;
+                    agreements: zod.ZodObject<{
+                        userAgreementMarkdown: zod.ZodOptional<zod.ZodString>;
+                        privacyPolicyMarkdown: zod.ZodOptional<zod.ZodString>;
+                        userAgreementUrl: zod.ZodOptional<zod.ZodString>;
+                        privacyPolicyUrl: zod.ZodOptional<zod.ZodString>;
+                        showOnRegister: zod.ZodBoolean;
+                        showOnLogin: zod.ZodBoolean;
+                    }, zod_v4_core.$strip>;
+                    ui: zod.ZodObject<{
+                        variant: zod.ZodEnum<{
+                            split: "split";
+                            card: "card";
+                        }>;
+                        title: zod.ZodOptional<zod.ZodString>;
+                        subtitle: zod.ZodOptional<zod.ZodString>;
+                        brandTitle: zod.ZodOptional<zod.ZodString>;
+                        brandText: zod.ZodOptional<zod.ZodString>;
+                        logoUrl: zod.ZodOptional<zod.ZodString>;
+                        illustrationUrl: zod.ZodOptional<zod.ZodString>;
+                    }, zod_v4_core.$strip>;
+                    session: zod.ZodObject<{
+                        maxAge: zod.ZodNumber;
+                        endOnPageHide: zod.ZodDefault<zod.ZodBoolean>;
+                    }, zod_v4_core.$strip>;
+                }, zod_v4_core.$strip>>;
+            }, zod_v4_core.$strip>, zod.ZodObject<{
+                success: zod.ZodLiteral<false>;
+                error: zod.ZodObject<{
+                    code: zod.ZodUnion<readonly [zod.ZodString, zod.ZodNumber]>;
+                    message: zod.ZodString;
+                    traceId: zod.ZodOptional<zod.ZodString>;
+                    httpStatus: zod.ZodOptional<zod.ZodNumber>;
+                    system: zod.ZodOptional<zod.ZodString>;
+                    module: zod.ZodOptional<zod.ZodString>;
+                    cause: zod.ZodOptional<zod.ZodUnknown>;
+                    suggestion: zod.ZodOptional<zod.ZodString>;
+                    ext: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
+                }, zod_v4_core.$strip>;
+            }, zod_v4_core.$strip>], "success">, Record<never, never>, Record<never, never>>;
+            renewPassword: _orpc_contract.ContractProcedureBuilderWithInputOutput<zod.ZodObject<{
+                identifier: zod.ZodString;
+                password: zod.ZodString;
+                newPassword: zod.ZodString;
+                captcha: zod.ZodOptional<zod.ZodString>;
+            }, zod_v4_core.$strip>, zod.ZodDiscriminatedUnion<[zod.ZodObject<{
+                success: zod.ZodLiteral<true>;
+                data: zod.ZodVoid;
+            }, zod_v4_core.$strip>, zod.ZodObject<{
+                success: zod.ZodLiteral<false>;
+                error: zod.ZodObject<{
+                    code: zod.ZodUnion<readonly [zod.ZodString, zod.ZodNumber]>;
+                    message: zod.ZodString;
+                    traceId: zod.ZodOptional<zod.ZodString>;
+                    httpStatus: zod.ZodOptional<zod.ZodNumber>;
+                    system: zod.ZodOptional<zod.ZodString>;
+                    module: zod.ZodOptional<zod.ZodString>;
+                    cause: zod.ZodOptional<zod.ZodUnknown>;
+                    suggestion: zod.ZodOptional<zod.ZodString>;
+                    ext: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
+                }, zod_v4_core.$strip>;
+            }, zod_v4_core.$strip>], "success">, Record<never, never>, Record<never, never>>;
+            loginWithLdap: _orpc_contract.ContractProcedureBuilderWithInputOutput<zod.ZodObject<{
+                username: zod.ZodString;
+                password: zod.ZodString;
+                captcha: zod.ZodOptional<zod.ZodString>;
+                expectedUserId: zod.ZodOptional<zod.ZodString>;
+            }, zod_v4_core.$strip>, zod.ZodDiscriminatedUnion<[zod.ZodObject<{
+                success: zod.ZodLiteral<true>;
+                data: zod.ZodObject<{
+                    user: zod.ZodObject<{
+                        id: zod.ZodString;
+                        username: zod.ZodString;
+                        email: zod.ZodOptional<zod.ZodString>;
+                        phone: zod.ZodOptional<zod.ZodString>;
+                        displayName: zod.ZodOptional<zod.ZodString>;
+                        avatarUrl: zod.ZodOptional<zod.ZodString>;
+                        accountType: zod.ZodOptional<zod.ZodEnum<{
+                            permanent: "permanent";
+                            temporary: "temporary";
+                        }>>;
+                        accountStatus: zod.ZodEnum<{
+                            active: "active";
+                            dormant: "dormant";
+                            closed: "closed";
+                        }>;
+                        accountExpiresAt: zod.ZodOptional<zod.ZodNullable<zod.ZodCoercedDate<unknown>>>;
+                        lastLoginAt: zod.ZodOptional<zod.ZodNullable<zod.ZodCoercedDate<unknown>>>;
+                        mustChangePassword: zod.ZodOptional<zod.ZodBoolean>;
+                        emailVerified: zod.ZodOptional<zod.ZodBoolean>;
+                        phoneVerified: zod.ZodOptional<zod.ZodBoolean>;
+                        createdAt: zod.ZodCoercedDate<unknown>;
+                        updatedAt: zod.ZodCoercedDate<unknown>;
+                        metadata: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
+                    }, zod_v4_core.$strip>;
+                    tokens: zod.ZodObject<{
+                        accessToken: zod.ZodString;
+                        refreshToken: zod.ZodOptional<zod.ZodString>;
+                        expiresIn: zod.ZodNumber;
+                        tokenType: zod.ZodLiteral<"Bearer">;
+                    }, zod_v4_core.$strip>;
+                    roles: zod.ZodDefault<zod.ZodArray<zod.ZodString>>;
+                    permissions: zod.ZodDefault<zod.ZodArray<zod.ZodString>>;
+                    agreements: zod.ZodOptional<zod.ZodObject<{
+                        userAgreementMarkdown: zod.ZodOptional<zod.ZodString>;
+                        privacyPolicyMarkdown: zod.ZodOptional<zod.ZodString>;
+                        userAgreementUrl: zod.ZodOptional<zod.ZodString>;
+                        privacyPolicyUrl: zod.ZodOptional<zod.ZodString>;
+                        showOnRegister: zod.ZodBoolean;
+                        showOnLogin: zod.ZodBoolean;
+                    }, zod_v4_core.$strip>>;
+                }, zod_v4_core.$strip>;
+            }, zod_v4_core.$strip>, zod.ZodObject<{
+                success: zod.ZodLiteral<false>;
+                error: zod.ZodObject<{
+                    code: zod.ZodUnion<readonly [zod.ZodString, zod.ZodNumber]>;
+                    message: zod.ZodString;
+                    traceId: zod.ZodOptional<zod.ZodString>;
+                    httpStatus: zod.ZodOptional<zod.ZodNumber>;
+                    system: zod.ZodOptional<zod.ZodString>;
+                    module: zod.ZodOptional<zod.ZodString>;
+                    cause: zod.ZodOptional<zod.ZodUnknown>;
+                    suggestion: zod.ZodOptional<zod.ZodString>;
+                    ext: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
+                }, zod_v4_core.$strip>;
+            }, zod_v4_core.$strip>], "success">, Record<never, never>, Record<never, never>>;
+            requestPasswordReset: _orpc_contract.ContractProcedureBuilderWithInputOutput<zod.ZodObject<{
+                identifier: zod.ZodString;
+                captcha: zod.ZodOptional<zod.ZodString>;
+            }, zod_v4_core.$strip>, zod.ZodDiscriminatedUnion<[zod.ZodObject<{
+                success: zod.ZodLiteral<true>;
+                data: zod.ZodVoid;
+            }, zod_v4_core.$strip>, zod.ZodObject<{
+                success: zod.ZodLiteral<false>;
+                error: zod.ZodObject<{
+                    code: zod.ZodUnion<readonly [zod.ZodString, zod.ZodNumber]>;
+                    message: zod.ZodString;
+                    traceId: zod.ZodOptional<zod.ZodString>;
+                    httpStatus: zod.ZodOptional<zod.ZodNumber>;
+                    system: zod.ZodOptional<zod.ZodString>;
+                    module: zod.ZodOptional<zod.ZodString>;
+                    cause: zod.ZodOptional<zod.ZodUnknown>;
+                    suggestion: zod.ZodOptional<zod.ZodString>;
+                    ext: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
+                }, zod_v4_core.$strip>;
+            }, zod_v4_core.$strip>], "success">, Record<never, never>, Record<never, never>>;
+            confirmPasswordReset: _orpc_contract.ContractProcedureBuilderWithInputOutput<zod.ZodObject<{
+                token: zod.ZodString;
+                newPassword: zod.ZodString;
+            }, zod_v4_core.$strip>, zod.ZodDiscriminatedUnion<[zod.ZodObject<{
+                success: zod.ZodLiteral<true>;
+                data: zod.ZodVoid;
+            }, zod_v4_core.$strip>, zod.ZodObject<{
+                success: zod.ZodLiteral<false>;
+                error: zod.ZodObject<{
+                    code: zod.ZodUnion<readonly [zod.ZodString, zod.ZodNumber]>;
+                    message: zod.ZodString;
+                    traceId: zod.ZodOptional<zod.ZodString>;
+                    httpStatus: zod.ZodOptional<zod.ZodNumber>;
+                    system: zod.ZodOptional<zod.ZodString>;
+                    module: zod.ZodOptional<zod.ZodString>;
+                    cause: zod.ZodOptional<zod.ZodUnknown>;
+                    suggestion: zod.ZodOptional<zod.ZodString>;
+                    ext: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
+                }, zod_v4_core.$strip>;
+            }, zod_v4_core.$strip>], "success">, Record<never, never>, Record<never, never>>;
+            login: _orpc_contract.ContractProcedureBuilderWithInputOutput<zod.ZodObject<{
+                expectedUserId: zod.ZodOptional<zod.ZodString>;
+                captcha: zod.ZodOptional<zod.ZodString>;
+                identifier: zod.ZodString;
+                password: zod.ZodString;
+            }, zod_v4_core.$strip>, zod.ZodDiscriminatedUnion<[zod.ZodObject<{
+                success: zod.ZodLiteral<true>;
+                data: zod.ZodObject<{
+                    user: zod.ZodObject<{
+                        id: zod.ZodString;
+                        username: zod.ZodString;
+                        email: zod.ZodOptional<zod.ZodString>;
+                        phone: zod.ZodOptional<zod.ZodString>;
+                        displayName: zod.ZodOptional<zod.ZodString>;
+                        avatarUrl: zod.ZodOptional<zod.ZodString>;
+                        accountType: zod.ZodOptional<zod.ZodEnum<{
+                            permanent: "permanent";
+                            temporary: "temporary";
+                        }>>;
+                        accountStatus: zod.ZodEnum<{
+                            active: "active";
+                            dormant: "dormant";
+                            closed: "closed";
+                        }>;
+                        accountExpiresAt: zod.ZodOptional<zod.ZodNullable<zod.ZodCoercedDate<unknown>>>;
+                        lastLoginAt: zod.ZodOptional<zod.ZodNullable<zod.ZodCoercedDate<unknown>>>;
+                        mustChangePassword: zod.ZodOptional<zod.ZodBoolean>;
+                        emailVerified: zod.ZodOptional<zod.ZodBoolean>;
+                        phoneVerified: zod.ZodOptional<zod.ZodBoolean>;
+                        createdAt: zod.ZodCoercedDate<unknown>;
+                        updatedAt: zod.ZodCoercedDate<unknown>;
+                        metadata: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
+                    }, zod_v4_core.$strip>;
+                    tokens: zod.ZodObject<{
+                        accessToken: zod.ZodString;
+                        refreshToken: zod.ZodOptional<zod.ZodString>;
+                        expiresIn: zod.ZodNumber;
+                        tokenType: zod.ZodLiteral<"Bearer">;
+                    }, zod_v4_core.$strip>;
+                    roles: zod.ZodDefault<zod.ZodArray<zod.ZodString>>;
+                    permissions: zod.ZodDefault<zod.ZodArray<zod.ZodString>>;
+                    agreements: zod.ZodOptional<zod.ZodObject<{
+                        userAgreementMarkdown: zod.ZodOptional<zod.ZodString>;
+                        privacyPolicyMarkdown: zod.ZodOptional<zod.ZodString>;
+                        userAgreementUrl: zod.ZodOptional<zod.ZodString>;
+                        privacyPolicyUrl: zod.ZodOptional<zod.ZodString>;
+                        showOnRegister: zod.ZodBoolean;
+                        showOnLogin: zod.ZodBoolean;
+                    }, zod_v4_core.$strip>>;
+                }, zod_v4_core.$strip>;
+            }, zod_v4_core.$strip>, zod.ZodObject<{
+                success: zod.ZodLiteral<false>;
+                error: zod.ZodObject<{
+                    code: zod.ZodUnion<readonly [zod.ZodString, zod.ZodNumber]>;
+                    message: zod.ZodString;
+                    traceId: zod.ZodOptional<zod.ZodString>;
+                    httpStatus: zod.ZodOptional<zod.ZodNumber>;
+                    system: zod.ZodOptional<zod.ZodString>;
+                    module: zod.ZodOptional<zod.ZodString>;
+                    cause: zod.ZodOptional<zod.ZodUnknown>;
+                    suggestion: zod.ZodOptional<zod.ZodString>;
+                    ext: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
+                }, zod_v4_core.$strip>;
+            }, zod_v4_core.$strip>], "success">, Record<never, never>, Record<never, never>>;
+            loginWithOtp: _orpc_contract.ContractProcedureBuilderWithInputOutput<zod.ZodObject<{
+                expectedUserId: zod.ZodOptional<zod.ZodString>;
+                captcha: zod.ZodOptional<zod.ZodString>;
+                identifier: zod.ZodString;
+                code: zod.ZodString;
+            }, zod_v4_core.$strip>, zod.ZodDiscriminatedUnion<[zod.ZodObject<{
+                success: zod.ZodLiteral<true>;
+                data: zod.ZodObject<{
+                    user: zod.ZodObject<{
+                        id: zod.ZodString;
+                        username: zod.ZodString;
+                        email: zod.ZodOptional<zod.ZodString>;
+                        phone: zod.ZodOptional<zod.ZodString>;
+                        displayName: zod.ZodOptional<zod.ZodString>;
+                        avatarUrl: zod.ZodOptional<zod.ZodString>;
+                        accountType: zod.ZodOptional<zod.ZodEnum<{
+                            permanent: "permanent";
+                            temporary: "temporary";
+                        }>>;
+                        accountStatus: zod.ZodEnum<{
+                            active: "active";
+                            dormant: "dormant";
+                            closed: "closed";
+                        }>;
+                        accountExpiresAt: zod.ZodOptional<zod.ZodNullable<zod.ZodCoercedDate<unknown>>>;
+                        lastLoginAt: zod.ZodOptional<zod.ZodNullable<zod.ZodCoercedDate<unknown>>>;
+                        mustChangePassword: zod.ZodOptional<zod.ZodBoolean>;
+                        emailVerified: zod.ZodOptional<zod.ZodBoolean>;
+                        phoneVerified: zod.ZodOptional<zod.ZodBoolean>;
+                        createdAt: zod.ZodCoercedDate<unknown>;
+                        updatedAt: zod.ZodCoercedDate<unknown>;
+                        metadata: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
+                    }, zod_v4_core.$strip>;
+                    tokens: zod.ZodObject<{
+                        accessToken: zod.ZodString;
+                        refreshToken: zod.ZodOptional<zod.ZodString>;
+                        expiresIn: zod.ZodNumber;
+                        tokenType: zod.ZodLiteral<"Bearer">;
+                    }, zod_v4_core.$strip>;
+                    roles: zod.ZodDefault<zod.ZodArray<zod.ZodString>>;
+                    permissions: zod.ZodDefault<zod.ZodArray<zod.ZodString>>;
+                    agreements: zod.ZodOptional<zod.ZodObject<{
+                        userAgreementMarkdown: zod.ZodOptional<zod.ZodString>;
+                        privacyPolicyMarkdown: zod.ZodOptional<zod.ZodString>;
+                        userAgreementUrl: zod.ZodOptional<zod.ZodString>;
+                        privacyPolicyUrl: zod.ZodOptional<zod.ZodString>;
+                        showOnRegister: zod.ZodBoolean;
+                        showOnLogin: zod.ZodBoolean;
+                    }, zod_v4_core.$strip>>;
+                }, zod_v4_core.$strip>;
+            }, zod_v4_core.$strip>, zod.ZodObject<{
+                success: zod.ZodLiteral<false>;
+                error: zod.ZodObject<{
+                    code: zod.ZodUnion<readonly [zod.ZodString, zod.ZodNumber]>;
+                    message: zod.ZodString;
+                    traceId: zod.ZodOptional<zod.ZodString>;
+                    httpStatus: zod.ZodOptional<zod.ZodNumber>;
+                    system: zod.ZodOptional<zod.ZodString>;
+                    module: zod.ZodOptional<zod.ZodString>;
+                    cause: zod.ZodOptional<zod.ZodUnknown>;
+                    suggestion: zod.ZodOptional<zod.ZodString>;
+                    ext: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
+                }, zod_v4_core.$strip>;
+            }, zod_v4_core.$strip>], "success">, Record<never, never>, Record<never, never>>;
+            logout: _orpc_contract.ContractProcedureBuilderWithInputOutput<zod.ZodObject<{
+                accessToken: zod.ZodOptional<zod.ZodString>;
+            }, zod_v4_core.$strip>, zod.ZodDiscriminatedUnion<[zod.ZodObject<{
+                success: zod.ZodLiteral<true>;
+                data: zod.ZodVoid;
+            }, zod_v4_core.$strip>, zod.ZodObject<{
+                success: zod.ZodLiteral<false>;
+                error: zod.ZodObject<{
+                    code: zod.ZodUnion<readonly [zod.ZodString, zod.ZodNumber]>;
+                    message: zod.ZodString;
+                    traceId: zod.ZodOptional<zod.ZodString>;
+                    httpStatus: zod.ZodOptional<zod.ZodNumber>;
+                    system: zod.ZodOptional<zod.ZodString>;
+                    module: zod.ZodOptional<zod.ZodString>;
+                    cause: zod.ZodOptional<zod.ZodUnknown>;
+                    suggestion: zod.ZodOptional<zod.ZodString>;
+                    ext: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
+                }, zod_v4_core.$strip>;
+            }, zod_v4_core.$strip>], "success">, Record<never, never>, Record<never, never>>;
+            closeSession: _orpc_contract.ContractProcedureBuilderWithInputOutput<zod.ZodObject<{
+                accessToken: zod.ZodOptional<zod.ZodString>;
+            }, zod_v4_core.$strip>, zod.ZodDiscriminatedUnion<[zod.ZodObject<{
+                success: zod.ZodLiteral<true>;
+                data: zod.ZodVoid;
+            }, zod_v4_core.$strip>, zod.ZodObject<{
+                success: zod.ZodLiteral<false>;
+                error: zod.ZodObject<{
+                    code: zod.ZodUnion<readonly [zod.ZodString, zod.ZodNumber]>;
+                    message: zod.ZodString;
+                    traceId: zod.ZodOptional<zod.ZodString>;
+                    httpStatus: zod.ZodOptional<zod.ZodNumber>;
+                    system: zod.ZodOptional<zod.ZodString>;
+                    module: zod.ZodOptional<zod.ZodString>;
+                    cause: zod.ZodOptional<zod.ZodUnknown>;
+                    suggestion: zod.ZodOptional<zod.ZodString>;
+                    ext: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
+                }, zod_v4_core.$strip>;
+            }, zod_v4_core.$strip>], "success">, Record<never, never>, Record<never, never>>;
+            currentUser: _orpc_contract.ContractProcedureBuilderWithOutput<_orpc_contract.Schema<unknown, unknown>, zod.ZodDiscriminatedUnion<[zod.ZodObject<{
+                success: zod.ZodLiteral<true>;
+                data: zod.ZodObject<{
+                    id: zod.ZodString;
+                    username: zod.ZodString;
+                    email: zod.ZodOptional<zod.ZodString>;
+                    phone: zod.ZodOptional<zod.ZodString>;
+                    displayName: zod.ZodOptional<zod.ZodString>;
+                    avatarUrl: zod.ZodOptional<zod.ZodString>;
+                    accountType: zod.ZodOptional<zod.ZodEnum<{
+                        permanent: "permanent";
+                        temporary: "temporary";
+                    }>>;
+                    accountStatus: zod.ZodEnum<{
+                        active: "active";
+                        dormant: "dormant";
+                        closed: "closed";
+                    }>;
+                    accountExpiresAt: zod.ZodOptional<zod.ZodNullable<zod.ZodCoercedDate<unknown>>>;
+                    lastLoginAt: zod.ZodOptional<zod.ZodNullable<zod.ZodCoercedDate<unknown>>>;
+                    mustChangePassword: zod.ZodOptional<zod.ZodBoolean>;
+                    emailVerified: zod.ZodOptional<zod.ZodBoolean>;
+                    phoneVerified: zod.ZodOptional<zod.ZodBoolean>;
+                    createdAt: zod.ZodCoercedDate<unknown>;
+                    updatedAt: zod.ZodCoercedDate<unknown>;
+                    metadata: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
+                    roles: zod.ZodArray<zod.ZodString>;
+                    permissions: zod.ZodArray<zod.ZodString>;
+                }, zod_v4_core.$strip>;
+            }, zod_v4_core.$strip>, zod.ZodObject<{
+                success: zod.ZodLiteral<false>;
+                error: zod.ZodObject<{
+                    code: zod.ZodUnion<readonly [zod.ZodString, zod.ZodNumber]>;
+                    message: zod.ZodString;
+                    traceId: zod.ZodOptional<zod.ZodString>;
+                    httpStatus: zod.ZodOptional<zod.ZodNumber>;
+                    system: zod.ZodOptional<zod.ZodString>;
+                    module: zod.ZodOptional<zod.ZodString>;
+                    cause: zod.ZodOptional<zod.ZodUnknown>;
+                    suggestion: zod.ZodOptional<zod.ZodString>;
+                    ext: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
+                }, zod_v4_core.$strip>;
+            }, zod_v4_core.$strip>], "success">, Record<never, never>, Record<never, never>>;
+            refresh: _orpc_contract.ContractProcedureBuilderWithInputOutput<zod.ZodObject<{
+                refreshToken: zod.ZodString;
+            }, zod_v4_core.$strip>, zod.ZodDiscriminatedUnion<[zod.ZodObject<{
+                success: zod.ZodLiteral<true>;
+                data: zod.ZodObject<{
+                    tokens: zod.ZodObject<{
+                        accessToken: zod.ZodString;
+                        refreshToken: zod.ZodOptional<zod.ZodString>;
+                        expiresIn: zod.ZodNumber;
+                        tokenType: zod.ZodLiteral<"Bearer">;
+                    }, zod_v4_core.$strip>;
+                }, zod_v4_core.$strip>;
+            }, zod_v4_core.$strip>, zod.ZodObject<{
+                success: zod.ZodLiteral<false>;
+                error: zod.ZodObject<{
+                    code: zod.ZodUnion<readonly [zod.ZodString, zod.ZodNumber]>;
+                    message: zod.ZodString;
+                    traceId: zod.ZodOptional<zod.ZodString>;
+                    httpStatus: zod.ZodOptional<zod.ZodNumber>;
+                    system: zod.ZodOptional<zod.ZodString>;
+                    module: zod.ZodOptional<zod.ZodString>;
+                    cause: zod.ZodOptional<zod.ZodUnknown>;
+                    suggestion: zod.ZodOptional<zod.ZodString>;
+                    ext: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
+                }, zod_v4_core.$strip>;
+            }, zod_v4_core.$strip>], "success">, Record<never, never>, Record<never, never>>;
+            sendOtp: _orpc_contract.ContractProcedureBuilderWithInputOutput<zod.ZodObject<{
+                captcha: zod.ZodOptional<zod.ZodString>;
+                identifier: zod.ZodString;
+            }, zod_v4_core.$strip>, zod.ZodDiscriminatedUnion<[zod.ZodObject<{
+                success: zod.ZodLiteral<true>;
+                data: zod.ZodObject<{
+                    expiresAt: zod.ZodCoercedDate<unknown>;
+                }, zod_v4_core.$strip>;
+            }, zod_v4_core.$strip>, zod.ZodObject<{
+                success: zod.ZodLiteral<false>;
+                error: zod.ZodObject<{
+                    code: zod.ZodUnion<readonly [zod.ZodString, zod.ZodNumber]>;
+                    message: zod.ZodString;
+                    traceId: zod.ZodOptional<zod.ZodString>;
+                    httpStatus: zod.ZodOptional<zod.ZodNumber>;
+                    system: zod.ZodOptional<zod.ZodString>;
+                    module: zod.ZodOptional<zod.ZodString>;
+                    cause: zod.ZodOptional<zod.ZodUnknown>;
+                    suggestion: zod.ZodOptional<zod.ZodString>;
+                    ext: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
+                }, zod_v4_core.$strip>;
+            }, zod_v4_core.$strip>], "success">, Record<never, never>, Record<never, never>>;
+            register: _orpc_contract.ContractProcedureBuilderWithInputOutput<zod.ZodObject<{
+                captcha: zod.ZodOptional<zod.ZodString>;
+                username: zod.ZodString;
+                password: zod.ZodString;
+                email: zod.ZodOptional<zod.ZodString>;
+                phone: zod.ZodOptional<zod.ZodString>;
+                displayName: zod.ZodOptional<zod.ZodString>;
+                metadata: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
+            }, zod_v4_core.$strip>, zod.ZodDiscriminatedUnion<[zod.ZodObject<{
+                success: zod.ZodLiteral<true>;
+                data: zod.ZodObject<{
+                    user: zod.ZodObject<{
+                        id: zod.ZodString;
+                        username: zod.ZodString;
+                        email: zod.ZodOptional<zod.ZodString>;
+                        phone: zod.ZodOptional<zod.ZodString>;
+                        displayName: zod.ZodOptional<zod.ZodString>;
+                        avatarUrl: zod.ZodOptional<zod.ZodString>;
+                        accountType: zod.ZodOptional<zod.ZodEnum<{
+                            permanent: "permanent";
+                            temporary: "temporary";
+                        }>>;
+                        accountStatus: zod.ZodEnum<{
+                            active: "active";
+                            dormant: "dormant";
+                            closed: "closed";
+                        }>;
+                        accountExpiresAt: zod.ZodOptional<zod.ZodNullable<zod.ZodCoercedDate<unknown>>>;
+                        lastLoginAt: zod.ZodOptional<zod.ZodNullable<zod.ZodCoercedDate<unknown>>>;
+                        mustChangePassword: zod.ZodOptional<zod.ZodBoolean>;
+                        emailVerified: zod.ZodOptional<zod.ZodBoolean>;
+                        phoneVerified: zod.ZodOptional<zod.ZodBoolean>;
+                        createdAt: zod.ZodCoercedDate<unknown>;
+                        updatedAt: zod.ZodCoercedDate<unknown>;
+                        metadata: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
+                    }, zod_v4_core.$strip>;
+                    tokens: zod.ZodObject<{
+                        accessToken: zod.ZodString;
+                        refreshToken: zod.ZodOptional<zod.ZodString>;
+                        expiresIn: zod.ZodNumber;
+                        tokenType: zod.ZodLiteral<"Bearer">;
+                    }, zod_v4_core.$strip>;
+                    roles: zod.ZodDefault<zod.ZodArray<zod.ZodString>>;
+                    permissions: zod.ZodDefault<zod.ZodArray<zod.ZodString>>;
+                    agreements: zod.ZodOptional<zod.ZodObject<{
+                        userAgreementMarkdown: zod.ZodOptional<zod.ZodString>;
+                        privacyPolicyMarkdown: zod.ZodOptional<zod.ZodString>;
+                        userAgreementUrl: zod.ZodOptional<zod.ZodString>;
+                        privacyPolicyUrl: zod.ZodOptional<zod.ZodString>;
+                        showOnRegister: zod.ZodBoolean;
+                        showOnLogin: zod.ZodBoolean;
+                    }, zod_v4_core.$strip>>;
+                }, zod_v4_core.$strip>;
+            }, zod_v4_core.$strip>, zod.ZodObject<{
+                success: zod.ZodLiteral<false>;
+                error: zod.ZodObject<{
+                    code: zod.ZodUnion<readonly [zod.ZodString, zod.ZodNumber]>;
+                    message: zod.ZodString;
+                    traceId: zod.ZodOptional<zod.ZodString>;
+                    httpStatus: zod.ZodOptional<zod.ZodNumber>;
+                    system: zod.ZodOptional<zod.ZodString>;
+                    module: zod.ZodOptional<zod.ZodString>;
+                    cause: zod.ZodOptional<zod.ZodUnknown>;
+                    suggestion: zod.ZodOptional<zod.ZodString>;
+                    ext: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
+                }, zod_v4_core.$strip>;
+            }, zod_v4_core.$strip>], "success">, Record<never, never>, Record<never, never>>;
+            changePassword: _orpc_contract.ContractProcedureBuilderWithInputOutput<zod.ZodObject<{
+                oldPassword: zod.ZodString;
+                newPassword: zod.ZodString;
+            }, zod_v4_core.$strip>, zod.ZodDiscriminatedUnion<[zod.ZodObject<{
+                success: zod.ZodLiteral<true>;
+                data: zod.ZodVoid;
+            }, zod_v4_core.$strip>, zod.ZodObject<{
+                success: zod.ZodLiteral<false>;
+                error: zod.ZodObject<{
+                    code: zod.ZodUnion<readonly [zod.ZodString, zod.ZodNumber]>;
+                    message: zod.ZodString;
+                    traceId: zod.ZodOptional<zod.ZodString>;
+                    httpStatus: zod.ZodOptional<zod.ZodNumber>;
+                    system: zod.ZodOptional<zod.ZodString>;
+                    module: zod.ZodOptional<zod.ZodString>;
+                    cause: zod.ZodOptional<zod.ZodUnknown>;
+                    suggestion: zod.ZodOptional<zod.ZodString>;
+                    ext: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
+                }, zod_v4_core.$strip>;
+            }, zod_v4_core.$strip>], "success">, Record<never, never>, Record<never, never>>;
+            updateCurrentUser: _orpc_contract.ContractProcedureBuilderWithInputOutput<zod.ZodObject<{
+                username: zod.ZodOptional<zod.ZodString>;
+                email: zod.ZodOptional<zod.ZodString>;
+                displayName: zod.ZodOptional<zod.ZodString>;
+                avatarUrl: zod.ZodOptional<zod.ZodString>;
+                phone: zod.ZodOptional<zod.ZodString>;
+                metadata: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
+            }, zod_v4_core.$strip>, zod.ZodDiscriminatedUnion<[zod.ZodObject<{
+                success: zod.ZodLiteral<true>;
+                data: zod.ZodObject<{
+                    id: zod.ZodString;
+                    username: zod.ZodString;
+                    email: zod.ZodOptional<zod.ZodString>;
+                    phone: zod.ZodOptional<zod.ZodString>;
+                    displayName: zod.ZodOptional<zod.ZodString>;
+                    avatarUrl: zod.ZodOptional<zod.ZodString>;
+                    accountType: zod.ZodOptional<zod.ZodEnum<{
+                        permanent: "permanent";
+                        temporary: "temporary";
+                    }>>;
+                    accountStatus: zod.ZodEnum<{
+                        active: "active";
+                        dormant: "dormant";
+                        closed: "closed";
+                    }>;
+                    accountExpiresAt: zod.ZodOptional<zod.ZodNullable<zod.ZodCoercedDate<unknown>>>;
+                    lastLoginAt: zod.ZodOptional<zod.ZodNullable<zod.ZodCoercedDate<unknown>>>;
+                    mustChangePassword: zod.ZodOptional<zod.ZodBoolean>;
+                    emailVerified: zod.ZodOptional<zod.ZodBoolean>;
+                    phoneVerified: zod.ZodOptional<zod.ZodBoolean>;
+                    createdAt: zod.ZodCoercedDate<unknown>;
+                    updatedAt: zod.ZodCoercedDate<unknown>;
+                    metadata: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
+                }, zod_v4_core.$strip>;
+            }, zod_v4_core.$strip>, zod.ZodObject<{
+                success: zod.ZodLiteral<false>;
+                error: zod.ZodObject<{
+                    code: zod.ZodUnion<readonly [zod.ZodString, zod.ZodNumber]>;
+                    message: zod.ZodString;
+                    traceId: zod.ZodOptional<zod.ZodString>;
+                    httpStatus: zod.ZodOptional<zod.ZodNumber>;
+                    system: zod.ZodOptional<zod.ZodString>;
+                    module: zod.ZodOptional<zod.ZodString>;
+                    cause: zod.ZodOptional<zod.ZodUnknown>;
+                    suggestion: zod.ZodOptional<zod.ZodString>;
+                    ext: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
+                }, zod_v4_core.$strip>;
+            }, zod_v4_core.$strip>], "success">, Record<never, never>, Record<never, never>>;
+        };
+        users: {
+            invite: _orpc_contract.ContractProcedureBuilderWithInputOutput<zod.ZodObject<{
+                metadata: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
+                email: zod.ZodOptional<zod.ZodString>;
+                username: zod.ZodString;
+                phone: zod.ZodOptional<zod.ZodString>;
+                displayName: zod.ZodOptional<zod.ZodString>;
+                accountType: zod.ZodOptional<zod.ZodEnum<{
+                    permanent: "permanent";
+                    temporary: "temporary";
+                }>>;
+                accountExpiresAt: zod.ZodOptional<zod.ZodCoercedDate<unknown>>;
+                roleIds: zod.ZodOptional<zod.ZodArray<zod.ZodString>>;
+                accountStatus: zod.ZodOptional<zod.ZodLiteral<"active">>;
+            }, zod_v4_core.$strict>, zod.ZodDiscriminatedUnion<[zod.ZodObject<{
+                success: zod.ZodLiteral<true>;
+                data: zod.ZodObject<{
+                    id: zod.ZodString;
+                    username: zod.ZodString;
+                    email: zod.ZodOptional<zod.ZodString>;
+                    phone: zod.ZodOptional<zod.ZodString>;
+                    displayName: zod.ZodOptional<zod.ZodString>;
+                    avatarUrl: zod.ZodOptional<zod.ZodString>;
+                    accountType: zod.ZodOptional<zod.ZodEnum<{
+                        permanent: "permanent";
+                        temporary: "temporary";
+                    }>>;
+                    accountStatus: zod.ZodEnum<{
+                        active: "active";
+                        dormant: "dormant";
+                        closed: "closed";
+                    }>;
+                    accountExpiresAt: zod.ZodOptional<zod.ZodNullable<zod.ZodCoercedDate<unknown>>>;
+                    lastLoginAt: zod.ZodOptional<zod.ZodNullable<zod.ZodCoercedDate<unknown>>>;
+                    mustChangePassword: zod.ZodOptional<zod.ZodBoolean>;
+                    emailVerified: zod.ZodOptional<zod.ZodBoolean>;
+                    phoneVerified: zod.ZodOptional<zod.ZodBoolean>;
+                    createdAt: zod.ZodCoercedDate<unknown>;
+                    updatedAt: zod.ZodCoercedDate<unknown>;
+                    metadata: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
+                }, zod_v4_core.$strip>;
+            }, zod_v4_core.$strip>, zod.ZodObject<{
+                success: zod.ZodLiteral<false>;
+                error: zod.ZodObject<{
+                    code: zod.ZodUnion<readonly [zod.ZodString, zod.ZodNumber]>;
+                    message: zod.ZodString;
+                    traceId: zod.ZodOptional<zod.ZodString>;
+                    httpStatus: zod.ZodOptional<zod.ZodNumber>;
+                    system: zod.ZodOptional<zod.ZodString>;
+                    module: zod.ZodOptional<zod.ZodString>;
+                    cause: zod.ZodOptional<zod.ZodUnknown>;
+                    suggestion: zod.ZodOptional<zod.ZodString>;
+                    ext: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
+                }, zod_v4_core.$strip>;
+            }, zod_v4_core.$strip>], "success">, Record<never, never>, Record<never, never>>;
+            list: _orpc_contract.ContractProcedureBuilderWithInputOutput<zod.ZodObject<{
+                page: zod.ZodOptional<zod.ZodCoercedNumber<unknown>>;
+                pageSize: zod.ZodOptional<zod.ZodCoercedNumber<unknown>>;
+                sortBy: zod.ZodOptional<zod.ZodEnum<{
+                    createdAt: "createdAt";
+                    email: "email";
+                    username: "username";
+                    displayName: "displayName";
+                    accountStatus: "accountStatus";
+                }>>;
+                sortDirection: zod.ZodOptional<zod.ZodEnum<{
+                    asc: "asc";
+                    desc: "desc";
+                }>>;
+                roleCode: zod.ZodOptional<zod.ZodString>;
+                search: zod.ZodOptional<zod.ZodString>;
+                accountStatus: zod.ZodOptional<zod.ZodEnum<{
+                    active: "active";
+                    dormant: "dormant";
+                    closed: "closed";
+                }>>;
+            }, zod_v4_core.$strict>, zod.ZodDiscriminatedUnion<[zod.ZodObject<{
+                success: zod.ZodLiteral<true>;
+                data: zod.ZodObject<{
+                    items: zod.ZodArray<zod.ZodObject<{
+                        id: zod.ZodString;
+                        username: zod.ZodString;
+                        email: zod.ZodOptional<zod.ZodString>;
+                        phone: zod.ZodOptional<zod.ZodString>;
+                        displayName: zod.ZodOptional<zod.ZodString>;
+                        avatarUrl: zod.ZodOptional<zod.ZodString>;
+                        accountType: zod.ZodOptional<zod.ZodEnum<{
+                            permanent: "permanent";
+                            temporary: "temporary";
+                        }>>;
+                        accountStatus: zod.ZodEnum<{
+                            active: "active";
+                            dormant: "dormant";
+                            closed: "closed";
+                        }>;
+                        accountExpiresAt: zod.ZodOptional<zod.ZodNullable<zod.ZodCoercedDate<unknown>>>;
+                        lastLoginAt: zod.ZodOptional<zod.ZodNullable<zod.ZodCoercedDate<unknown>>>;
+                        mustChangePassword: zod.ZodOptional<zod.ZodBoolean>;
+                        emailVerified: zod.ZodOptional<zod.ZodBoolean>;
+                        phoneVerified: zod.ZodOptional<zod.ZodBoolean>;
+                        createdAt: zod.ZodCoercedDate<unknown>;
+                        updatedAt: zod.ZodCoercedDate<unknown>;
+                        metadata: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
+                    }, zod_v4_core.$strip>>;
+                    total: zod.ZodNumber;
+                    page: zod.ZodNumber;
+                    pageSize: zod.ZodNumber;
+                }, zod_v4_core.$strip>;
+            }, zod_v4_core.$strip>, zod.ZodObject<{
+                success: zod.ZodLiteral<false>;
+                error: zod.ZodObject<{
+                    code: zod.ZodUnion<readonly [zod.ZodString, zod.ZodNumber]>;
+                    message: zod.ZodString;
+                    traceId: zod.ZodOptional<zod.ZodString>;
+                    httpStatus: zod.ZodOptional<zod.ZodNumber>;
+                    system: zod.ZodOptional<zod.ZodString>;
+                    module: zod.ZodOptional<zod.ZodString>;
+                    cause: zod.ZodOptional<zod.ZodUnknown>;
+                    suggestion: zod.ZodOptional<zod.ZodString>;
+                    ext: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
+                }, zod_v4_core.$strip>;
+            }, zod_v4_core.$strip>], "success">, Record<never, never>, Record<never, never>>;
+            get: _orpc_contract.ContractProcedureBuilderWithInputOutput<zod.ZodObject<{
+                id: zod.ZodString;
+            }, zod_v4_core.$strip>, zod.ZodDiscriminatedUnion<[zod.ZodObject<{
+                success: zod.ZodLiteral<true>;
+                data: zod.ZodNullable<zod.ZodObject<{
+                    id: zod.ZodString;
+                    username: zod.ZodString;
+                    email: zod.ZodOptional<zod.ZodString>;
+                    phone: zod.ZodOptional<zod.ZodString>;
+                    displayName: zod.ZodOptional<zod.ZodString>;
+                    avatarUrl: zod.ZodOptional<zod.ZodString>;
+                    accountType: zod.ZodOptional<zod.ZodEnum<{
+                        permanent: "permanent";
+                        temporary: "temporary";
+                    }>>;
+                    accountStatus: zod.ZodEnum<{
+                        active: "active";
+                        dormant: "dormant";
+                        closed: "closed";
+                    }>;
+                    accountExpiresAt: zod.ZodOptional<zod.ZodNullable<zod.ZodCoercedDate<unknown>>>;
+                    lastLoginAt: zod.ZodOptional<zod.ZodNullable<zod.ZodCoercedDate<unknown>>>;
+                    mustChangePassword: zod.ZodOptional<zod.ZodBoolean>;
+                    emailVerified: zod.ZodOptional<zod.ZodBoolean>;
+                    phoneVerified: zod.ZodOptional<zod.ZodBoolean>;
+                    createdAt: zod.ZodCoercedDate<unknown>;
+                    updatedAt: zod.ZodCoercedDate<unknown>;
+                    metadata: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
+                }, zod_v4_core.$strip>>;
+            }, zod_v4_core.$strip>, zod.ZodObject<{
+                success: zod.ZodLiteral<false>;
+                error: zod.ZodObject<{
+                    code: zod.ZodUnion<readonly [zod.ZodString, zod.ZodNumber]>;
+                    message: zod.ZodString;
+                    traceId: zod.ZodOptional<zod.ZodString>;
+                    httpStatus: zod.ZodOptional<zod.ZodNumber>;
+                    system: zod.ZodOptional<zod.ZodString>;
+                    module: zod.ZodOptional<zod.ZodString>;
+                    cause: zod.ZodOptional<zod.ZodUnknown>;
+                    suggestion: zod.ZodOptional<zod.ZodString>;
+                    ext: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
+                }, zod_v4_core.$strip>;
+            }, zod_v4_core.$strip>], "success">, Record<never, never>, Record<never, never>>;
+            create: _orpc_contract.ContractProcedureBuilderWithInputOutput<zod.ZodObject<{
+                accountType: zod.ZodOptional<zod.ZodEnum<{
+                    permanent: "permanent";
+                    temporary: "temporary";
+                }>>;
+                accountStatus: zod.ZodOptional<zod.ZodEnum<{
+                    active: "active";
+                    dormant: "dormant";
+                    closed: "closed";
+                }>>;
+                accountExpiresAt: zod.ZodOptional<zod.ZodCoercedDate<unknown>>;
+                username: zod.ZodString;
+                email: zod.ZodOptional<zod.ZodString>;
+                phone: zod.ZodOptional<zod.ZodString>;
+                password: zod.ZodString;
+                displayName: zod.ZodOptional<zod.ZodString>;
+                metadata: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
+                roleIds: zod.ZodOptional<zod.ZodArray<zod.ZodString>>;
+            }, zod_v4_core.$strict>, zod.ZodDiscriminatedUnion<[zod.ZodObject<{
+                success: zod.ZodLiteral<true>;
+                data: zod.ZodObject<{
+                    id: zod.ZodString;
+                    username: zod.ZodString;
+                    email: zod.ZodOptional<zod.ZodString>;
+                    phone: zod.ZodOptional<zod.ZodString>;
+                    displayName: zod.ZodOptional<zod.ZodString>;
+                    avatarUrl: zod.ZodOptional<zod.ZodString>;
+                    accountType: zod.ZodOptional<zod.ZodEnum<{
+                        permanent: "permanent";
+                        temporary: "temporary";
+                    }>>;
+                    accountStatus: zod.ZodEnum<{
+                        active: "active";
+                        dormant: "dormant";
+                        closed: "closed";
+                    }>;
+                    accountExpiresAt: zod.ZodOptional<zod.ZodNullable<zod.ZodCoercedDate<unknown>>>;
+                    lastLoginAt: zod.ZodOptional<zod.ZodNullable<zod.ZodCoercedDate<unknown>>>;
+                    mustChangePassword: zod.ZodOptional<zod.ZodBoolean>;
+                    emailVerified: zod.ZodOptional<zod.ZodBoolean>;
+                    phoneVerified: zod.ZodOptional<zod.ZodBoolean>;
+                    createdAt: zod.ZodCoercedDate<unknown>;
+                    updatedAt: zod.ZodCoercedDate<unknown>;
+                    metadata: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
+                }, zod_v4_core.$strip>;
+            }, zod_v4_core.$strip>, zod.ZodObject<{
+                success: zod.ZodLiteral<false>;
+                error: zod.ZodObject<{
+                    code: zod.ZodUnion<readonly [zod.ZodString, zod.ZodNumber]>;
+                    message: zod.ZodString;
+                    traceId: zod.ZodOptional<zod.ZodString>;
+                    httpStatus: zod.ZodOptional<zod.ZodNumber>;
+                    system: zod.ZodOptional<zod.ZodString>;
+                    module: zod.ZodOptional<zod.ZodString>;
+                    cause: zod.ZodOptional<zod.ZodUnknown>;
+                    suggestion: zod.ZodOptional<zod.ZodString>;
+                    ext: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
+                }, zod_v4_core.$strip>;
+            }, zod_v4_core.$strip>], "success">, Record<never, never>, Record<never, never>>;
+            update: _orpc_contract.ContractProcedureBuilderWithInputOutput<zod.ZodObject<{
+                accountType: zod.ZodOptional<zod.ZodEnum<{
+                    permanent: "permanent";
+                    temporary: "temporary";
+                }>>;
+                accountStatus: zod.ZodOptional<zod.ZodEnum<{
+                    active: "active";
+                    dormant: "dormant";
+                    closed: "closed";
+                }>>;
+                accountExpiresAt: zod.ZodOptional<zod.ZodNullable<zod.ZodCoercedDate<unknown>>>;
+                id: zod.ZodString;
+                username: zod.ZodOptional<zod.ZodString>;
+                email: zod.ZodOptional<zod.ZodString>;
+                phone: zod.ZodOptional<zod.ZodString>;
+                displayName: zod.ZodOptional<zod.ZodString>;
+                avatarUrl: zod.ZodOptional<zod.ZodString>;
+                metadata: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
+                roleIds: zod.ZodOptional<zod.ZodArray<zod.ZodString>>;
+            }, zod_v4_core.$strict>, zod.ZodDiscriminatedUnion<[zod.ZodObject<{
+                success: zod.ZodLiteral<true>;
+                data: zod.ZodObject<{
+                    id: zod.ZodString;
+                    username: zod.ZodString;
+                    email: zod.ZodOptional<zod.ZodString>;
+                    phone: zod.ZodOptional<zod.ZodString>;
+                    displayName: zod.ZodOptional<zod.ZodString>;
+                    avatarUrl: zod.ZodOptional<zod.ZodString>;
+                    accountType: zod.ZodOptional<zod.ZodEnum<{
+                        permanent: "permanent";
+                        temporary: "temporary";
+                    }>>;
+                    accountStatus: zod.ZodEnum<{
+                        active: "active";
+                        dormant: "dormant";
+                        closed: "closed";
+                    }>;
+                    accountExpiresAt: zod.ZodOptional<zod.ZodNullable<zod.ZodCoercedDate<unknown>>>;
+                    lastLoginAt: zod.ZodOptional<zod.ZodNullable<zod.ZodCoercedDate<unknown>>>;
+                    mustChangePassword: zod.ZodOptional<zod.ZodBoolean>;
+                    emailVerified: zod.ZodOptional<zod.ZodBoolean>;
+                    phoneVerified: zod.ZodOptional<zod.ZodBoolean>;
+                    createdAt: zod.ZodCoercedDate<unknown>;
+                    updatedAt: zod.ZodCoercedDate<unknown>;
+                    metadata: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
+                }, zod_v4_core.$strip>;
+            }, zod_v4_core.$strip>, zod.ZodObject<{
+                success: zod.ZodLiteral<false>;
+                error: zod.ZodObject<{
+                    code: zod.ZodUnion<readonly [zod.ZodString, zod.ZodNumber]>;
+                    message: zod.ZodString;
+                    traceId: zod.ZodOptional<zod.ZodString>;
+                    httpStatus: zod.ZodOptional<zod.ZodNumber>;
+                    system: zod.ZodOptional<zod.ZodString>;
+                    module: zod.ZodOptional<zod.ZodString>;
+                    cause: zod.ZodOptional<zod.ZodUnknown>;
+                    suggestion: zod.ZodOptional<zod.ZodString>;
+                    ext: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
+                }, zod_v4_core.$strip>;
+            }, zod_v4_core.$strip>], "success">, Record<never, never>, Record<never, never>>;
+            delete: _orpc_contract.ContractProcedureBuilderWithInputOutput<zod.ZodObject<{
+                id: zod.ZodString;
+            }, zod_v4_core.$strip>, zod.ZodDiscriminatedUnion<[zod.ZodObject<{
+                success: zod.ZodLiteral<true>;
+                data: zod.ZodVoid;
+            }, zod_v4_core.$strip>, zod.ZodObject<{
+                success: zod.ZodLiteral<false>;
+                error: zod.ZodObject<{
+                    code: zod.ZodUnion<readonly [zod.ZodString, zod.ZodNumber]>;
+                    message: zod.ZodString;
+                    traceId: zod.ZodOptional<zod.ZodString>;
+                    httpStatus: zod.ZodOptional<zod.ZodNumber>;
+                    system: zod.ZodOptional<zod.ZodString>;
+                    module: zod.ZodOptional<zod.ZodString>;
+                    cause: zod.ZodOptional<zod.ZodUnknown>;
+                    suggestion: zod.ZodOptional<zod.ZodString>;
+                    ext: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
+                }, zod_v4_core.$strip>;
+            }, zod_v4_core.$strip>], "success">, Record<never, never>, Record<never, never>>;
+            resetPassword: _orpc_contract.ContractProcedureBuilderWithInputOutput<zod.ZodObject<{
+                id: zod.ZodString;
+                newPassword: zod.ZodString;
+            }, zod_v4_core.$strip>, zod.ZodDiscriminatedUnion<[zod.ZodObject<{
+                success: zod.ZodLiteral<true>;
+                data: zod.ZodVoid;
+            }, zod_v4_core.$strip>, zod.ZodObject<{
+                success: zod.ZodLiteral<false>;
+                error: zod.ZodObject<{
+                    code: zod.ZodUnion<readonly [zod.ZodString, zod.ZodNumber]>;
+                    message: zod.ZodString;
+                    traceId: zod.ZodOptional<zod.ZodString>;
+                    httpStatus: zod.ZodOptional<zod.ZodNumber>;
+                    system: zod.ZodOptional<zod.ZodString>;
+                    module: zod.ZodOptional<zod.ZodString>;
+                    cause: zod.ZodOptional<zod.ZodUnknown>;
+                    suggestion: zod.ZodOptional<zod.ZodString>;
+                    ext: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
+                }, zod_v4_core.$strip>;
+            }, zod_v4_core.$strip>], "success">, Record<never, never>, Record<never, never>>;
+        };
+        roles: {
+            list: _orpc_contract.ContractProcedureBuilderWithOutput<_orpc_contract.Schema<unknown, unknown>, zod.ZodDiscriminatedUnion<[zod.ZodObject<{
+                success: zod.ZodLiteral<true>;
+                data: zod.ZodObject<{
+                    items: zod.ZodArray<zod.ZodObject<{
+                        id: zod.ZodString;
+                        code: zod.ZodString;
+                        name: zod.ZodString;
+                        description: zod.ZodOptional<zod.ZodString>;
+                        isSystem: zod.ZodOptional<zod.ZodBoolean>;
+                        createdAt: zod.ZodCoercedDate<unknown>;
+                        updatedAt: zod.ZodCoercedDate<unknown>;
+                    }, zod_v4_core.$strip>>;
+                    total: zod.ZodNumber;
+                    page: zod.ZodNumber;
+                    pageSize: zod.ZodNumber;
+                }, zod_v4_core.$strip>;
+            }, zod_v4_core.$strip>, zod.ZodObject<{
+                success: zod.ZodLiteral<false>;
+                error: zod.ZodObject<{
+                    code: zod.ZodUnion<readonly [zod.ZodString, zod.ZodNumber]>;
+                    message: zod.ZodString;
+                    traceId: zod.ZodOptional<zod.ZodString>;
+                    httpStatus: zod.ZodOptional<zod.ZodNumber>;
+                    system: zod.ZodOptional<zod.ZodString>;
+                    module: zod.ZodOptional<zod.ZodString>;
+                    cause: zod.ZodOptional<zod.ZodUnknown>;
+                    suggestion: zod.ZodOptional<zod.ZodString>;
+                    ext: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
+                }, zod_v4_core.$strip>;
+            }, zod_v4_core.$strip>], "success">, Record<never, never>, Record<never, never>>;
+            get: _orpc_contract.ContractProcedureBuilderWithInputOutput<zod.ZodObject<{
+                id: zod.ZodString;
+            }, zod_v4_core.$strip>, zod.ZodDiscriminatedUnion<[zod.ZodObject<{
+                success: zod.ZodLiteral<true>;
+                data: zod.ZodNullable<zod.ZodObject<{
+                    id: zod.ZodString;
+                    code: zod.ZodString;
+                    name: zod.ZodString;
+                    description: zod.ZodOptional<zod.ZodString>;
+                    isSystem: zod.ZodOptional<zod.ZodBoolean>;
+                    createdAt: zod.ZodCoercedDate<unknown>;
+                    updatedAt: zod.ZodCoercedDate<unknown>;
+                }, zod_v4_core.$strip>>;
+            }, zod_v4_core.$strip>, zod.ZodObject<{
+                success: zod.ZodLiteral<false>;
+                error: zod.ZodObject<{
+                    code: zod.ZodUnion<readonly [zod.ZodString, zod.ZodNumber]>;
+                    message: zod.ZodString;
+                    traceId: zod.ZodOptional<zod.ZodString>;
+                    httpStatus: zod.ZodOptional<zod.ZodNumber>;
+                    system: zod.ZodOptional<zod.ZodString>;
+                    module: zod.ZodOptional<zod.ZodString>;
+                    cause: zod.ZodOptional<zod.ZodUnknown>;
+                    suggestion: zod.ZodOptional<zod.ZodString>;
+                    ext: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
+                }, zod_v4_core.$strip>;
+            }, zod_v4_core.$strip>], "success">, Record<never, never>, Record<never, never>>;
+            create: _orpc_contract.ContractProcedureBuilderWithInputOutput<zod.ZodObject<{
+                code: zod.ZodString;
+                name: zod.ZodString;
+                description: zod.ZodOptional<zod.ZodString>;
+                isSystem: zod.ZodOptional<zod.ZodBoolean>;
+            }, zod_v4_core.$strip>, zod.ZodDiscriminatedUnion<[zod.ZodObject<{
+                success: zod.ZodLiteral<true>;
+                data: zod.ZodObject<{
+                    id: zod.ZodString;
+                    code: zod.ZodString;
+                    name: zod.ZodString;
+                    description: zod.ZodOptional<zod.ZodString>;
+                    isSystem: zod.ZodOptional<zod.ZodBoolean>;
+                    createdAt: zod.ZodCoercedDate<unknown>;
+                    updatedAt: zod.ZodCoercedDate<unknown>;
+                }, zod_v4_core.$strip>;
+            }, zod_v4_core.$strip>, zod.ZodObject<{
+                success: zod.ZodLiteral<false>;
+                error: zod.ZodObject<{
+                    code: zod.ZodUnion<readonly [zod.ZodString, zod.ZodNumber]>;
+                    message: zod.ZodString;
+                    traceId: zod.ZodOptional<zod.ZodString>;
+                    httpStatus: zod.ZodOptional<zod.ZodNumber>;
+                    system: zod.ZodOptional<zod.ZodString>;
+                    module: zod.ZodOptional<zod.ZodString>;
+                    cause: zod.ZodOptional<zod.ZodUnknown>;
+                    suggestion: zod.ZodOptional<zod.ZodString>;
+                    ext: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
+                }, zod_v4_core.$strip>;
+            }, zod_v4_core.$strip>], "success">, Record<never, never>, Record<never, never>>;
+            update: _orpc_contract.ContractProcedureBuilderWithInputOutput<zod.ZodObject<{
+                id: zod.ZodString;
+                name: zod.ZodOptional<zod.ZodString>;
+                description: zod.ZodOptional<zod.ZodString>;
+            }, zod_v4_core.$strip>, zod.ZodDiscriminatedUnion<[zod.ZodObject<{
+                success: zod.ZodLiteral<true>;
+                data: zod.ZodObject<{
+                    id: zod.ZodString;
+                    code: zod.ZodString;
+                    name: zod.ZodString;
+                    description: zod.ZodOptional<zod.ZodString>;
+                    isSystem: zod.ZodOptional<zod.ZodBoolean>;
+                    createdAt: zod.ZodCoercedDate<unknown>;
+                    updatedAt: zod.ZodCoercedDate<unknown>;
+                }, zod_v4_core.$strip>;
+            }, zod_v4_core.$strip>, zod.ZodObject<{
+                success: zod.ZodLiteral<false>;
+                error: zod.ZodObject<{
+                    code: zod.ZodUnion<readonly [zod.ZodString, zod.ZodNumber]>;
+                    message: zod.ZodString;
+                    traceId: zod.ZodOptional<zod.ZodString>;
+                    httpStatus: zod.ZodOptional<zod.ZodNumber>;
+                    system: zod.ZodOptional<zod.ZodString>;
+                    module: zod.ZodOptional<zod.ZodString>;
+                    cause: zod.ZodOptional<zod.ZodUnknown>;
+                    suggestion: zod.ZodOptional<zod.ZodString>;
+                    ext: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
+                }, zod_v4_core.$strip>;
+            }, zod_v4_core.$strip>], "success">, Record<never, never>, Record<never, never>>;
+            delete: _orpc_contract.ContractProcedureBuilderWithInputOutput<zod.ZodObject<{
+                id: zod.ZodString;
+            }, zod_v4_core.$strip>, zod.ZodDiscriminatedUnion<[zod.ZodObject<{
+                success: zod.ZodLiteral<true>;
+                data: zod.ZodVoid;
+            }, zod_v4_core.$strip>, zod.ZodObject<{
+                success: zod.ZodLiteral<false>;
+                error: zod.ZodObject<{
+                    code: zod.ZodUnion<readonly [zod.ZodString, zod.ZodNumber]>;
+                    message: zod.ZodString;
+                    traceId: zod.ZodOptional<zod.ZodString>;
+                    httpStatus: zod.ZodOptional<zod.ZodNumber>;
+                    system: zod.ZodOptional<zod.ZodString>;
+                    module: zod.ZodOptional<zod.ZodString>;
+                    cause: zod.ZodOptional<zod.ZodUnknown>;
+                    suggestion: zod.ZodOptional<zod.ZodString>;
+                    ext: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
+                }, zod_v4_core.$strip>;
+            }, zod_v4_core.$strip>], "success">, Record<never, never>, Record<never, never>>;
+        };
+        permissions: {
+            setSensitiveOperations: _orpc_contract.ContractProcedureBuilderWithInputOutput<zod.ZodObject<{
+                id: zod.ZodString;
+                sensitiveOperations: zod.ZodPipe<zod.ZodOptional<zod.ZodNullable<zod.ZodArray<zod.ZodString>>>, zod.ZodTransform<string[], string[] | null | undefined>>;
+            }, zod_v4_core.$strip>, zod.ZodDiscriminatedUnion<[zod.ZodObject<{
+                success: zod.ZodLiteral<true>;
+                data: zod.ZodVoid;
+            }, zod_v4_core.$strip>, zod.ZodObject<{
+                success: zod.ZodLiteral<false>;
+                error: zod.ZodObject<{
+                    code: zod.ZodUnion<readonly [zod.ZodString, zod.ZodNumber]>;
+                    message: zod.ZodString;
+                    traceId: zod.ZodOptional<zod.ZodString>;
+                    httpStatus: zod.ZodOptional<zod.ZodNumber>;
+                    system: zod.ZodOptional<zod.ZodString>;
+                    module: zod.ZodOptional<zod.ZodString>;
+                    cause: zod.ZodOptional<zod.ZodUnknown>;
+                    suggestion: zod.ZodOptional<zod.ZodString>;
+                    ext: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
+                }, zod_v4_core.$strip>;
+            }, zod_v4_core.$strip>], "success">, Record<never, never>, Record<never, never>>;
+            list: _orpc_contract.ContractProcedureBuilderWithInputOutput<zod.ZodObject<{
+                page: zod.ZodOptional<zod.ZodCoercedNumber<unknown>>;
+                pageSize: zod.ZodOptional<zod.ZodCoercedNumber<unknown>>;
+                search: zod.ZodOptional<zod.ZodString>;
+                type: zod.ZodOptional<zod.ZodEnum<{
+                    menu: "menu";
+                    api: "api";
+                    button: "button";
+                }>>;
+            }, zod_v4_core.$strip>, zod.ZodDiscriminatedUnion<[zod.ZodObject<{
+                success: zod.ZodLiteral<true>;
+                data: zod.ZodObject<{
+                    items: zod.ZodArray<zod.ZodObject<{
+                        sensitiveOperations: zod.ZodPipe<zod.ZodOptional<zod.ZodNullable<zod.ZodArray<zod.ZodString>>>, zod.ZodTransform<string[], string[] | null | undefined>>;
+                        id: zod.ZodString;
+                        code: zod.ZodString;
+                        name: zod.ZodString;
+                        description: zod.ZodOptional<zod.ZodString>;
+                        type: zod.ZodOptional<zod.ZodEnum<{
+                            menu: "menu";
+                            api: "api";
+                            button: "button";
+                        }>>;
+                        resource: zod.ZodOptional<zod.ZodString>;
+                        action: zod.ZodOptional<zod.ZodString>;
+                        createdAt: zod.ZodCoercedDate<unknown>;
+                        updatedAt: zod.ZodCoercedDate<unknown>;
+                    }, zod_v4_core.$strip>>;
+                    total: zod.ZodNumber;
+                    page: zod.ZodNumber;
+                    pageSize: zod.ZodNumber;
+                }, zod_v4_core.$strip>;
+            }, zod_v4_core.$strip>, zod.ZodObject<{
+                success: zod.ZodLiteral<false>;
+                error: zod.ZodObject<{
+                    code: zod.ZodUnion<readonly [zod.ZodString, zod.ZodNumber]>;
+                    message: zod.ZodString;
+                    traceId: zod.ZodOptional<zod.ZodString>;
+                    httpStatus: zod.ZodOptional<zod.ZodNumber>;
+                    system: zod.ZodOptional<zod.ZodString>;
+                    module: zod.ZodOptional<zod.ZodString>;
+                    cause: zod.ZodOptional<zod.ZodUnknown>;
+                    suggestion: zod.ZodOptional<zod.ZodString>;
+                    ext: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
+                }, zod_v4_core.$strip>;
+            }, zod_v4_core.$strip>], "success">, Record<never, never>, Record<never, never>>;
+            get: _orpc_contract.ContractProcedureBuilderWithInputOutput<zod.ZodObject<{
+                id: zod.ZodString;
+            }, zod_v4_core.$strip>, zod.ZodDiscriminatedUnion<[zod.ZodObject<{
+                success: zod.ZodLiteral<true>;
+                data: zod.ZodNullable<zod.ZodObject<{
+                    sensitiveOperations: zod.ZodPipe<zod.ZodOptional<zod.ZodNullable<zod.ZodArray<zod.ZodString>>>, zod.ZodTransform<string[], string[] | null | undefined>>;
+                    id: zod.ZodString;
+                    code: zod.ZodString;
+                    name: zod.ZodString;
+                    description: zod.ZodOptional<zod.ZodString>;
+                    type: zod.ZodOptional<zod.ZodEnum<{
+                        menu: "menu";
+                        api: "api";
+                        button: "button";
+                    }>>;
+                    resource: zod.ZodOptional<zod.ZodString>;
+                    action: zod.ZodOptional<zod.ZodString>;
+                    createdAt: zod.ZodCoercedDate<unknown>;
+                    updatedAt: zod.ZodCoercedDate<unknown>;
+                }, zod_v4_core.$strip>>;
+            }, zod_v4_core.$strip>, zod.ZodObject<{
+                success: zod.ZodLiteral<false>;
+                error: zod.ZodObject<{
+                    code: zod.ZodUnion<readonly [zod.ZodString, zod.ZodNumber]>;
+                    message: zod.ZodString;
+                    traceId: zod.ZodOptional<zod.ZodString>;
+                    httpStatus: zod.ZodOptional<zod.ZodNumber>;
+                    system: zod.ZodOptional<zod.ZodString>;
+                    module: zod.ZodOptional<zod.ZodString>;
+                    cause: zod.ZodOptional<zod.ZodUnknown>;
+                    suggestion: zod.ZodOptional<zod.ZodString>;
+                    ext: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
+                }, zod_v4_core.$strip>;
+            }, zod_v4_core.$strip>], "success">, Record<never, never>, Record<never, never>>;
+            create: _orpc_contract.ContractProcedureBuilderWithInputOutput<zod.ZodObject<{
+                sensitiveOperations: zod.ZodDefault<zod.ZodArray<zod.ZodString>>;
+                code: zod.ZodString;
+                name: zod.ZodString;
+                description: zod.ZodOptional<zod.ZodString>;
+                resource: zod.ZodOptional<zod.ZodString>;
+                action: zod.ZodOptional<zod.ZodString>;
+                type: zod.ZodOptional<zod.ZodEnum<{
+                    menu: "menu";
+                    api: "api";
+                    button: "button";
+                }>>;
+            }, zod_v4_core.$strip>, zod.ZodDiscriminatedUnion<[zod.ZodObject<{
+                success: zod.ZodLiteral<true>;
+                data: zod.ZodObject<{
+                    sensitiveOperations: zod.ZodPipe<zod.ZodOptional<zod.ZodNullable<zod.ZodArray<zod.ZodString>>>, zod.ZodTransform<string[], string[] | null | undefined>>;
+                    id: zod.ZodString;
+                    code: zod.ZodString;
+                    name: zod.ZodString;
+                    description: zod.ZodOptional<zod.ZodString>;
+                    type: zod.ZodOptional<zod.ZodEnum<{
+                        menu: "menu";
+                        api: "api";
+                        button: "button";
+                    }>>;
+                    resource: zod.ZodOptional<zod.ZodString>;
+                    action: zod.ZodOptional<zod.ZodString>;
+                    createdAt: zod.ZodCoercedDate<unknown>;
+                    updatedAt: zod.ZodCoercedDate<unknown>;
+                }, zod_v4_core.$strip>;
+            }, zod_v4_core.$strip>, zod.ZodObject<{
+                success: zod.ZodLiteral<false>;
+                error: zod.ZodObject<{
+                    code: zod.ZodUnion<readonly [zod.ZodString, zod.ZodNumber]>;
+                    message: zod.ZodString;
+                    traceId: zod.ZodOptional<zod.ZodString>;
+                    httpStatus: zod.ZodOptional<zod.ZodNumber>;
+                    system: zod.ZodOptional<zod.ZodString>;
+                    module: zod.ZodOptional<zod.ZodString>;
+                    cause: zod.ZodOptional<zod.ZodUnknown>;
+                    suggestion: zod.ZodOptional<zod.ZodString>;
+                    ext: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
+                }, zod_v4_core.$strip>;
+            }, zod_v4_core.$strip>], "success">, Record<never, never>, Record<never, never>>;
+            delete: _orpc_contract.ContractProcedureBuilderWithInputOutput<zod.ZodObject<{
+                id: zod.ZodString;
+            }, zod_v4_core.$strip>, zod.ZodDiscriminatedUnion<[zod.ZodObject<{
+                success: zod.ZodLiteral<true>;
+                data: zod.ZodVoid;
+            }, zod_v4_core.$strip>, zod.ZodObject<{
+                success: zod.ZodLiteral<false>;
+                error: zod.ZodObject<{
+                    code: zod.ZodUnion<readonly [zod.ZodString, zod.ZodNumber]>;
+                    message: zod.ZodString;
+                    traceId: zod.ZodOptional<zod.ZodString>;
+                    httpStatus: zod.ZodOptional<zod.ZodNumber>;
+                    system: zod.ZodOptional<zod.ZodString>;
+                    module: zod.ZodOptional<zod.ZodString>;
+                    cause: zod.ZodOptional<zod.ZodUnknown>;
+                    suggestion: zod.ZodOptional<zod.ZodString>;
+                    ext: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
+                }, zod_v4_core.$strip>;
+            }, zod_v4_core.$strip>], "success">, Record<never, never>, Record<never, never>>;
+        };
+    };
+    readonly storage: {
+        presignedUrls: {
+            createDownload: _orpc_contract.ContractProcedureBuilderWithInputOutput<zod.ZodObject<{
+                key: zod.ZodString;
+                expiresIn: zod.ZodOptional<zod.ZodNumber>;
+            }, zod_v4_core.$strict>, zod.ZodDiscriminatedUnion<[zod.ZodObject<{
+                success: zod.ZodLiteral<true>;
+                data: zod.ZodObject<{
+                    url: zod.ZodString;
+                    key: zod.ZodString;
+                    expiresAt: zod.ZodOptional<zod.ZodCoercedDate<unknown>>;
+                }, zod_v4_core.$strip>;
+            }, zod_v4_core.$strip>, zod.ZodObject<{
+                success: zod.ZodLiteral<false>;
+                error: zod.ZodObject<{
+                    code: zod.ZodUnion<readonly [zod.ZodString, zod.ZodNumber]>;
+                    message: zod.ZodString;
+                    traceId: zod.ZodOptional<zod.ZodString>;
+                    httpStatus: zod.ZodOptional<zod.ZodNumber>;
+                    system: zod.ZodOptional<zod.ZodString>;
+                    module: zod.ZodOptional<zod.ZodString>;
+                    cause: zod.ZodOptional<zod.ZodUnknown>;
+                    suggestion: zod.ZodOptional<zod.ZodString>;
+                    ext: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
+                }, zod_v4_core.$strip>;
+            }, zod_v4_core.$strip>], "success">, Record<never, never>, Record<never, never>>;
+            createUpload: _orpc_contract.ContractProcedureBuilderWithInputOutput<zod.ZodObject<{
+                key: zod.ZodString;
+                contentType: zod.ZodOptional<zod.ZodString>;
+                expiresIn: zod.ZodOptional<zod.ZodNumber>;
+            }, zod_v4_core.$strict>, zod.ZodDiscriminatedUnion<[zod.ZodObject<{
+                success: zod.ZodLiteral<true>;
+                data: zod.ZodObject<{
+                    url: zod.ZodString;
+                    key: zod.ZodString;
+                    expiresAt: zod.ZodOptional<zod.ZodCoercedDate<unknown>>;
+                }, zod_v4_core.$strip>;
+            }, zod_v4_core.$strip>, zod.ZodObject<{
+                success: zod.ZodLiteral<false>;
+                error: zod.ZodObject<{
+                    code: zod.ZodUnion<readonly [zod.ZodString, zod.ZodNumber]>;
+                    message: zod.ZodString;
+                    traceId: zod.ZodOptional<zod.ZodString>;
+                    httpStatus: zod.ZodOptional<zod.ZodNumber>;
+                    system: zod.ZodOptional<zod.ZodString>;
+                    module: zod.ZodOptional<zod.ZodString>;
+                    cause: zod.ZodOptional<zod.ZodUnknown>;
+                    suggestion: zod.ZodOptional<zod.ZodString>;
+                    ext: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
+                }, zod_v4_core.$strip>;
+            }, zod_v4_core.$strip>], "success">, Record<never, never>, Record<never, never>>;
+        };
+        files: {
+            list: _orpc_contract.ContractProcedureBuilderWithInputOutput<zod.ZodObject<{
+                prefix: zod.ZodOptional<zod.ZodString>;
+                maxKeys: zod.ZodOptional<zod.ZodCoercedNumber<unknown>>;
+                continuationToken: zod.ZodOptional<zod.ZodString>;
+                delimiter: zod.ZodOptional<zod.ZodString>;
+            }, zod_v4_core.$strip>, zod.ZodDiscriminatedUnion<[zod.ZodObject<{
+                success: zod.ZodLiteral<true>;
+                data: zod.ZodObject<{
+                    files: zod.ZodArray<zod.ZodObject<{
+                        key: zod.ZodString;
+                        size: zod.ZodNumber;
+                        contentType: zod.ZodString;
+                        lastModified: zod.ZodCoercedDate<unknown>;
+                        etag: zod.ZodOptional<zod.ZodString>;
+                        metadata: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodString>>;
+                    }, zod_v4_core.$strip>>;
+                    commonPrefixes: zod.ZodArray<zod.ZodString>;
+                    nextContinuationToken: zod.ZodOptional<zod.ZodString>;
+                    isTruncated: zod.ZodBoolean;
+                }, zod_v4_core.$strip>;
+            }, zod_v4_core.$strip>, zod.ZodObject<{
+                success: zod.ZodLiteral<false>;
+                error: zod.ZodObject<{
+                    code: zod.ZodUnion<readonly [zod.ZodString, zod.ZodNumber]>;
+                    message: zod.ZodString;
+                    traceId: zod.ZodOptional<zod.ZodString>;
+                    httpStatus: zod.ZodOptional<zod.ZodNumber>;
+                    system: zod.ZodOptional<zod.ZodString>;
+                    module: zod.ZodOptional<zod.ZodString>;
+                    cause: zod.ZodOptional<zod.ZodUnknown>;
+                    suggestion: zod.ZodOptional<zod.ZodString>;
+                    ext: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
+                }, zod_v4_core.$strip>;
+            }, zod_v4_core.$strip>], "success">, Record<never, never>, Record<never, never>>;
+            getMetadata: _orpc_contract.ContractProcedureBuilderWithInputOutput<zod.ZodObject<{
+                key: zod.ZodString;
+            }, zod_v4_core.$strip>, zod.ZodDiscriminatedUnion<[zod.ZodObject<{
+                success: zod.ZodLiteral<true>;
+                data: zod.ZodObject<{
+                    key: zod.ZodString;
+                    size: zod.ZodNumber;
+                    contentType: zod.ZodString;
+                    lastModified: zod.ZodCoercedDate<unknown>;
+                    etag: zod.ZodOptional<zod.ZodString>;
+                    metadata: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodString>>;
+                }, zod_v4_core.$strip>;
+            }, zod_v4_core.$strip>, zod.ZodObject<{
+                success: zod.ZodLiteral<false>;
+                error: zod.ZodObject<{
+                    code: zod.ZodUnion<readonly [zod.ZodString, zod.ZodNumber]>;
+                    message: zod.ZodString;
+                    traceId: zod.ZodOptional<zod.ZodString>;
+                    httpStatus: zod.ZodOptional<zod.ZodNumber>;
+                    system: zod.ZodOptional<zod.ZodString>;
+                    module: zod.ZodOptional<zod.ZodString>;
+                    cause: zod.ZodOptional<zod.ZodUnknown>;
+                    suggestion: zod.ZodOptional<zod.ZodString>;
+                    ext: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
+                }, zod_v4_core.$strip>;
+            }, zod_v4_core.$strip>], "success">, Record<never, never>, Record<never, never>>;
+            delete: _orpc_contract.ContractProcedureBuilderWithInputOutput<zod.ZodObject<{
+                key: zod.ZodString;
+            }, zod_v4_core.$strip>, zod.ZodDiscriminatedUnion<[zod.ZodObject<{
+                success: zod.ZodLiteral<true>;
+                data: zod.ZodVoid;
+            }, zod_v4_core.$strip>, zod.ZodObject<{
+                success: zod.ZodLiteral<false>;
+                error: zod.ZodObject<{
+                    code: zod.ZodUnion<readonly [zod.ZodString, zod.ZodNumber]>;
+                    message: zod.ZodString;
+                    traceId: zod.ZodOptional<zod.ZodString>;
+                    httpStatus: zod.ZodOptional<zod.ZodNumber>;
+                    system: zod.ZodOptional<zod.ZodString>;
+                    module: zod.ZodOptional<zod.ZodString>;
+                    cause: zod.ZodOptional<zod.ZodUnknown>;
+                    suggestion: zod.ZodOptional<zod.ZodString>;
+                    ext: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
+                }, zod_v4_core.$strip>;
+            }, zod_v4_core.$strip>], "success">, Record<never, never>, Record<never, never>>;
+            deleteMany: _orpc_contract.ContractProcedureBuilderWithInputOutput<zod.ZodObject<{
+                keys: zod.ZodArray<zod.ZodString>;
+            }, zod_v4_core.$strip>, zod.ZodDiscriminatedUnion<[zod.ZodObject<{
+                success: zod.ZodLiteral<true>;
+                data: zod.ZodObject<{
+                    deletedKeys: zod.ZodArray<zod.ZodString>;
+                    failures: zod.ZodArray<zod.ZodObject<{
+                        key: zod.ZodString;
+                        code: zod.ZodString;
+                        retryable: zod.ZodBoolean;
+                        outcome: zod.ZodEnum<{
+                            unknown: "unknown";
+                            failed: "failed";
+                            notAttempted: "notAttempted";
+                        }>;
+                    }, zod_v4_core.$strip>>;
+                }, zod_v4_core.$strip>;
+            }, zod_v4_core.$strip>, zod.ZodObject<{
+                success: zod.ZodLiteral<false>;
+                error: zod.ZodObject<{
+                    code: zod.ZodUnion<readonly [zod.ZodString, zod.ZodNumber]>;
+                    message: zod.ZodString;
+                    traceId: zod.ZodOptional<zod.ZodString>;
+                    httpStatus: zod.ZodOptional<zod.ZodNumber>;
+                    system: zod.ZodOptional<zod.ZodString>;
+                    module: zod.ZodOptional<zod.ZodString>;
+                    cause: zod.ZodOptional<zod.ZodUnknown>;
+                    suggestion: zod.ZodOptional<zod.ZodString>;
+                    ext: zod.ZodOptional<zod.ZodObject<{
+                        deleteMany: zod.ZodOptional<zod.ZodObject<{
+                            deletedKeys: zod.ZodArray<zod.ZodString>;
+                            failures: zod.ZodArray<zod.ZodObject<{
+                                key: zod.ZodString;
+                                code: zod.ZodString;
+                                retryable: zod.ZodBoolean;
+                                outcome: zod.ZodEnum<{
+                                    unknown: "unknown";
+                                    failed: "failed";
+                                    notAttempted: "notAttempted";
+                                }>;
+                            }, zod_v4_core.$strip>>;
+                        }, zod_v4_core.$strip>>;
+                    }, zod_v4_core.$catchall<zod.ZodUnknown>>>;
+                }, zod_v4_core.$strip>;
+            }, zod_v4_core.$strip>], "success">, Record<never, never>, Record<never, never>>;
+        };
+    };
+    readonly ai: {
+        chats: {
+            createCompletion: _orpc_contract.ContractProcedureBuilderWithInputOutput<zod.ZodObject<{
+                objectId: zod.ZodOptional<zod.ZodString>;
+                sessionId: zod.ZodOptional<zod.ZodString>;
+                model: zod.ZodOptional<zod.ZodString>;
+                messages: zod.ZodArray<zod.ZodDiscriminatedUnion<[zod.ZodObject<{
+                    role: zod.ZodLiteral<"system">;
+                    content: zod.ZodUnion<readonly [zod.ZodString, zod.ZodArray<zod.ZodObject<{
+                        type: zod.ZodLiteral<"text">;
+                        text: zod.ZodString;
+                    }, zod_v4_core.$strict>>]>;
+                    name: zod.ZodOptional<zod.ZodString>;
+                }, zod_v4_core.$strict>, zod.ZodObject<{
+                    role: zod.ZodLiteral<"user">;
+                    content: zod.ZodUnion<readonly [zod.ZodString, zod.ZodArray<zod.ZodUnion<readonly [zod.ZodObject<{
+                        type: zod.ZodLiteral<"text">;
+                        text: zod.ZodString;
+                    }, zod_v4_core.$strict>, zod.ZodObject<{
+                        type: zod.ZodLiteral<"image_url">;
+                        image_url: zod.ZodObject<{
+                            url: zod.ZodString;
+                            detail: zod.ZodOptional<zod.ZodEnum<{
+                                auto: "auto";
+                                low: "low";
+                                high: "high";
+                            }>>;
+                        }, zod_v4_core.$strict>;
+                    }, zod_v4_core.$strict>]>>]>;
+                    name: zod.ZodOptional<zod.ZodString>;
+                }, zod_v4_core.$strict>, zod.ZodObject<{
+                    role: zod.ZodLiteral<"assistant">;
+                    content: zod.ZodOptional<zod.ZodNullable<zod.ZodUnion<readonly [zod.ZodString, zod.ZodArray<zod.ZodObject<{
+                        type: zod.ZodLiteral<"text">;
+                        text: zod.ZodString;
+                    }, zod_v4_core.$strict>>]>>>;
+                    name: zod.ZodOptional<zod.ZodString>;
+                    tool_calls: zod.ZodOptional<zod.ZodArray<zod.ZodObject<{
+                        id: zod.ZodString;
+                        type: zod.ZodLiteral<"function">;
+                        function: zod.ZodObject<{
+                            name: zod.ZodString;
+                            arguments: zod.ZodString;
+                        }, zod_v4_core.$strict>;
+                    }, zod_v4_core.$strict>>>;
+                }, zod_v4_core.$strict>, zod.ZodObject<{
+                    role: zod.ZodLiteral<"tool">;
+                    content: zod.ZodUnion<readonly [zod.ZodString, zod.ZodArray<zod.ZodObject<{
+                        type: zod.ZodLiteral<"text">;
+                        text: zod.ZodString;
+                    }, zod_v4_core.$strict>>]>;
+                    tool_call_id: zod.ZodString;
+                }, zod_v4_core.$strict>], "role">>;
+                temperature: zod.ZodOptional<zod.ZodNumber>;
+                top_p: zod.ZodOptional<zod.ZodNumber>;
+                max_tokens: zod.ZodOptional<zod.ZodNumber>;
+                tools: zod.ZodOptional<zod.ZodArray<zod.ZodObject<{
+                    type: zod.ZodLiteral<"function">;
+                    function: zod.ZodObject<{
+                        name: zod.ZodString;
+                        description: zod.ZodOptional<zod.ZodString>;
+                        parameters: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodJSONSchema>>;
+                        strict: zod.ZodOptional<zod.ZodNullable<zod.ZodBoolean>>;
+                    }, zod_v4_core.$strict>;
+                }, zod_v4_core.$strict>>>;
+                tool_choice: zod.ZodOptional<zod.ZodUnion<readonly [zod.ZodLiteral<"auto">, zod.ZodLiteral<"none">, zod.ZodLiteral<"required">, zod.ZodObject<{
+                    type: zod.ZodLiteral<"function">;
+                    function: zod.ZodObject<{
+                        name: zod.ZodString;
+                    }, zod_v4_core.$strict>;
+                }, zod_v4_core.$strict>]>>;
+            }, zod_v4_core.$strict>, zod.ZodDiscriminatedUnion<[zod.ZodObject<{
+                success: zod.ZodLiteral<true>;
+                data: zod.ZodObject<{
+                    id: zod.ZodString;
+                    object: zod.ZodLiteral<"chat.completion">;
+                    created: zod.ZodNumber;
+                    model: zod.ZodString;
+                    choices: zod.ZodArray<zod.ZodObject<{
+                        index: zod.ZodNumber;
+                        message: zod.ZodObject<{
+                            role: zod.ZodLiteral<"assistant">;
+                            content: zod.ZodOptional<zod.ZodNullable<zod.ZodString>>;
+                            tool_calls: zod.ZodOptional<zod.ZodArray<zod.ZodObject<{
+                                id: zod.ZodString;
+                                type: zod.ZodLiteral<"function">;
+                                function: zod.ZodObject<{
+                                    name: zod.ZodString;
+                                    arguments: zod.ZodString;
+                                }, zod_v4_core.$strict>;
+                            }, zod_v4_core.$strict>>>;
+                        }, zod_v4_core.$strip>;
+                        finish_reason: zod.ZodEnum<{
+                            length: "length";
+                            tool_calls: "tool_calls";
+                            stop: "stop";
+                            content_filter: "content_filter";
+                        }>;
+                    }, zod_v4_core.$strip>>;
+                    usage: zod.ZodObject<{
+                        prompt_tokens: zod.ZodNumber;
+                        completion_tokens: zod.ZodNumber;
+                        total_tokens: zod.ZodNumber;
+                    }, zod_v4_core.$strip>;
+                }, zod_v4_core.$strip>;
+            }, zod_v4_core.$strip>, zod.ZodObject<{
+                success: zod.ZodLiteral<false>;
+                error: zod.ZodObject<{
+                    code: zod.ZodUnion<readonly [zod.ZodString, zod.ZodNumber]>;
+                    message: zod.ZodString;
+                    traceId: zod.ZodOptional<zod.ZodString>;
+                    httpStatus: zod.ZodOptional<zod.ZodNumber>;
+                    system: zod.ZodOptional<zod.ZodString>;
+                    module: zod.ZodOptional<zod.ZodString>;
+                    cause: zod.ZodOptional<zod.ZodUnknown>;
+                    suggestion: zod.ZodOptional<zod.ZodString>;
+                    ext: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
+                }, zod_v4_core.$strip>;
+            }, zod_v4_core.$strip>], "success">, Record<never, never>, Record<never, never>>;
+            sendMessage: _orpc_contract.ContractProcedureBuilderWithInputOutput<zod.ZodObject<{
+                objectId: zod.ZodOptional<zod.ZodString>;
+                sessionId: zod.ZodOptional<zod.ZodString>;
+                message: zod.ZodString;
+                systemPrompt: zod.ZodOptional<zod.ZodString>;
+                model: zod.ZodOptional<zod.ZodString>;
+                temperature: zod.ZodOptional<zod.ZodNumber>;
+            }, zod_v4_core.$strip>, zod.ZodDiscriminatedUnion<[zod.ZodObject<{
+                success: zod.ZodLiteral<true>;
+                data: zod.ZodObject<{
+                    content: zod.ZodString;
+                    model: zod.ZodString;
+                    usage: zod.ZodOptional<zod.ZodObject<{
+                        prompt_tokens: zod.ZodNumber;
+                        completion_tokens: zod.ZodNumber;
+                        total_tokens: zod.ZodNumber;
+                    }, zod_v4_core.$strip>>;
+                }, zod_v4_core.$strip>;
+            }, zod_v4_core.$strip>, zod.ZodObject<{
+                success: zod.ZodLiteral<false>;
+                error: zod.ZodObject<{
+                    code: zod.ZodUnion<readonly [zod.ZodString, zod.ZodNumber]>;
+                    message: zod.ZodString;
+                    traceId: zod.ZodOptional<zod.ZodString>;
+                    httpStatus: zod.ZodOptional<zod.ZodNumber>;
+                    system: zod.ZodOptional<zod.ZodString>;
+                    module: zod.ZodOptional<zod.ZodString>;
+                    cause: zod.ZodOptional<zod.ZodUnknown>;
+                    suggestion: zod.ZodOptional<zod.ZodString>;
+                    ext: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
+                }, zod_v4_core.$strip>;
+            }, zod_v4_core.$strip>], "success">, Record<never, never>, Record<never, never>>;
+            listHistory: _orpc_contract.ContractProcedureBuilderWithInputOutput<zod.ZodObject<{
+                objectId: zod.ZodOptional<zod.ZodString>;
+                sessionId: zod.ZodString;
+                limit: zod.ZodOptional<zod.ZodNumber>;
+                order: zod.ZodOptional<zod.ZodEnum<{
+                    asc: "asc";
+                    desc: "desc";
+                }>>;
+            }, zod_v4_core.$strip>, zod.ZodDiscriminatedUnion<[zod.ZodObject<{
+                success: zod.ZodLiteral<true>;
+                data: zod.ZodObject<{
+                    items: zod.ZodArray<zod.ZodObject<{
+                        id: zod.ZodString;
+                        objectId: zod.ZodString;
+                        sessionId: zod.ZodString;
+                        request: zod.ZodObject<{
+                            model: zod.ZodString;
+                            messages: zod.ZodArray<zod.ZodDiscriminatedUnion<[zod.ZodObject<{
+                                role: zod.ZodLiteral<"system">;
+                                content: zod.ZodUnion<readonly [zod.ZodString, zod.ZodArray<zod.ZodObject<{
+                                    type: zod.ZodLiteral<"text">;
+                                    text: zod.ZodString;
+                                }, zod_v4_core.$strict>>]>;
+                                name: zod.ZodOptional<zod.ZodString>;
+                            }, zod_v4_core.$strict>, zod.ZodObject<{
+                                role: zod.ZodLiteral<"user">;
+                                content: zod.ZodUnion<readonly [zod.ZodString, zod.ZodArray<zod.ZodUnion<readonly [zod.ZodObject<{
+                                    type: zod.ZodLiteral<"text">;
+                                    text: zod.ZodString;
+                                }, zod_v4_core.$strict>, zod.ZodObject<{
+                                    type: zod.ZodLiteral<"image_url">;
+                                    image_url: zod.ZodObject<{
+                                        url: zod.ZodString;
+                                        detail: zod.ZodOptional<zod.ZodEnum<{
+                                            auto: "auto";
+                                            low: "low";
+                                            high: "high";
+                                        }>>;
+                                    }, zod_v4_core.$strict>;
+                                }, zod_v4_core.$strict>]>>]>;
+                                name: zod.ZodOptional<zod.ZodString>;
+                            }, zod_v4_core.$strict>, zod.ZodObject<{
+                                role: zod.ZodLiteral<"assistant">;
+                                content: zod.ZodOptional<zod.ZodNullable<zod.ZodUnion<readonly [zod.ZodString, zod.ZodArray<zod.ZodObject<{
+                                    type: zod.ZodLiteral<"text">;
+                                    text: zod.ZodString;
+                                }, zod_v4_core.$strict>>]>>>;
+                                name: zod.ZodOptional<zod.ZodString>;
+                                tool_calls: zod.ZodOptional<zod.ZodArray<zod.ZodObject<{
+                                    id: zod.ZodString;
+                                    type: zod.ZodLiteral<"function">;
+                                    function: zod.ZodObject<{
+                                        name: zod.ZodString;
+                                        arguments: zod.ZodString;
+                                    }, zod_v4_core.$strict>;
+                                }, zod_v4_core.$strict>>>;
+                            }, zod_v4_core.$strict>, zod.ZodObject<{
+                                role: zod.ZodLiteral<"tool">;
+                                content: zod.ZodUnion<readonly [zod.ZodString, zod.ZodArray<zod.ZodObject<{
+                                    type: zod.ZodLiteral<"text">;
+                                    text: zod.ZodString;
+                                }, zod_v4_core.$strict>>]>;
+                                tool_call_id: zod.ZodString;
+                            }, zod_v4_core.$strict>], "role">>;
+                        }, zod_v4_core.$strip>;
+                        response: zod.ZodObject<{
+                            content: zod.ZodString;
+                            toolCalls: zod.ZodOptional<zod.ZodArray<zod.ZodObject<{
+                                id: zod.ZodString;
+                                type: zod.ZodLiteral<"function">;
+                                function: zod.ZodObject<{
+                                    name: zod.ZodString;
+                                    arguments: zod.ZodString;
+                                }, zod_v4_core.$strict>;
+                            }, zod_v4_core.$strict>>>;
+                            finishReason: zod.ZodString;
+                            usage: zod.ZodObject<{
+                                prompt_tokens: zod.ZodNumber;
+                                completion_tokens: zod.ZodNumber;
+                                total_tokens: zod.ZodNumber;
+                            }, zod_v4_core.$strip>;
+                        }, zod_v4_core.$strip>;
+                        createdAt: zod.ZodNumber;
+                        duration: zod.ZodNumber;
+                    }, zod_v4_core.$strip>>;
+                }, zod_v4_core.$strip>;
+            }, zod_v4_core.$strip>, zod.ZodObject<{
+                success: zod.ZodLiteral<false>;
+                error: zod.ZodObject<{
+                    code: zod.ZodUnion<readonly [zod.ZodString, zod.ZodNumber]>;
+                    message: zod.ZodString;
+                    traceId: zod.ZodOptional<zod.ZodString>;
+                    httpStatus: zod.ZodOptional<zod.ZodNumber>;
+                    system: zod.ZodOptional<zod.ZodString>;
+                    module: zod.ZodOptional<zod.ZodString>;
+                    cause: zod.ZodOptional<zod.ZodUnknown>;
+                    suggestion: zod.ZodOptional<zod.ZodString>;
+                    ext: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
+                }, zod_v4_core.$strip>;
+            }, zod_v4_core.$strip>], "success">, Record<never, never>, Record<never, never>>;
+        };
+        memories: {
+            recall: _orpc_contract.ContractProcedureBuilderWithInputOutput<zod.ZodObject<{
+                query: zod.ZodString;
+                topK: zod.ZodOptional<zod.ZodNumber>;
+                types: zod.ZodOptional<zod.ZodArray<zod.ZodEnum<{
+                    instruction: "instruction";
+                    fact: "fact";
+                    preference: "preference";
+                    event: "event";
+                    entity: "entity";
+                }>>>;
+                minImportance: zod.ZodOptional<zod.ZodNumber>;
+                objectId: zod.ZodOptional<zod.ZodString>;
+            }, zod_v4_core.$strip>, zod.ZodDiscriminatedUnion<[zod.ZodObject<{
+                success: zod.ZodLiteral<true>;
+                data: zod.ZodObject<{
+                    items: zod.ZodArray<zod.ZodObject<{
+                        id: zod.ZodString;
+                        content: zod.ZodString;
+                        type: zod.ZodEnum<{
+                            instruction: "instruction";
+                            fact: "fact";
+                            preference: "preference";
+                            event: "event";
+                            entity: "entity";
+                        }>;
+                        importance: zod.ZodNumber;
+                        objectId: zod.ZodOptional<zod.ZodString>;
+                        metadata: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
+                        createdAt: zod.ZodNumber;
+                        lastAccessedAt: zod.ZodNumber;
+                        accessCount: zod.ZodNumber;
+                    }, zod_v4_core.$strip>>;
+                }, zod_v4_core.$strip>;
+            }, zod_v4_core.$strip>, zod.ZodObject<{
+                success: zod.ZodLiteral<false>;
+                error: zod.ZodObject<{
+                    code: zod.ZodUnion<readonly [zod.ZodString, zod.ZodNumber]>;
+                    message: zod.ZodString;
+                    traceId: zod.ZodOptional<zod.ZodString>;
+                    httpStatus: zod.ZodOptional<zod.ZodNumber>;
+                    system: zod.ZodOptional<zod.ZodString>;
+                    module: zod.ZodOptional<zod.ZodString>;
+                    cause: zod.ZodOptional<zod.ZodUnknown>;
+                    suggestion: zod.ZodOptional<zod.ZodString>;
+                    ext: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
+                }, zod_v4_core.$strip>;
+            }, zod_v4_core.$strip>], "success">, Record<never, never>, Record<never, never>>;
+            list: _orpc_contract.ContractProcedureBuilderWithInputOutput<zod.ZodObject<{
+                types: zod.ZodOptional<zod.ZodArray<zod.ZodEnum<{
+                    instruction: "instruction";
+                    fact: "fact";
+                    preference: "preference";
+                    event: "event";
+                    entity: "entity";
+                }>>>;
+                objectId: zod.ZodOptional<zod.ZodString>;
+                offset: zod.ZodOptional<zod.ZodNumber>;
+                limit: zod.ZodOptional<zod.ZodNumber>;
+            }, zod_v4_core.$strip>, zod.ZodDiscriminatedUnion<[zod.ZodObject<{
+                success: zod.ZodLiteral<true>;
+                data: zod.ZodObject<{
+                    items: zod.ZodArray<zod.ZodObject<{
+                        id: zod.ZodString;
+                        content: zod.ZodString;
+                        type: zod.ZodEnum<{
+                            instruction: "instruction";
+                            fact: "fact";
+                            preference: "preference";
+                            event: "event";
+                            entity: "entity";
+                        }>;
+                        importance: zod.ZodNumber;
+                        objectId: zod.ZodOptional<zod.ZodString>;
+                        metadata: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
+                        createdAt: zod.ZodNumber;
+                        lastAccessedAt: zod.ZodNumber;
+                        accessCount: zod.ZodNumber;
+                    }, zod_v4_core.$strip>>;
+                    total: zod.ZodNumber;
+                }, zod_v4_core.$strip>;
+            }, zod_v4_core.$strip>, zod.ZodObject<{
+                success: zod.ZodLiteral<false>;
+                error: zod.ZodObject<{
+                    code: zod.ZodUnion<readonly [zod.ZodString, zod.ZodNumber]>;
+                    message: zod.ZodString;
+                    traceId: zod.ZodOptional<zod.ZodString>;
+                    httpStatus: zod.ZodOptional<zod.ZodNumber>;
+                    system: zod.ZodOptional<zod.ZodString>;
+                    module: zod.ZodOptional<zod.ZodString>;
+                    cause: zod.ZodOptional<zod.ZodUnknown>;
+                    suggestion: zod.ZodOptional<zod.ZodString>;
+                    ext: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
+                }, zod_v4_core.$strip>;
+            }, zod_v4_core.$strip>], "success">, Record<never, never>, Record<never, never>>;
+        };
+        sessions: {
+            list: _orpc_contract.ContractProcedureBuilderWithInputOutput<zod.ZodObject<{
+                objectId: zod.ZodOptional<zod.ZodString>;
+            }, zod_v4_core.$strip>, zod.ZodDiscriminatedUnion<[zod.ZodObject<{
+                success: zod.ZodLiteral<true>;
+                data: zod.ZodObject<{
+                    items: zod.ZodArray<zod.ZodObject<{
+                        objectId: zod.ZodString;
+                        sessionId: zod.ZodString;
+                        createdAt: zod.ZodNumber;
+                        updatedAt: zod.ZodNumber;
+                        metadata: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
+                    }, zod_v4_core.$strip>>;
+                }, zod_v4_core.$strip>;
+            }, zod_v4_core.$strip>, zod.ZodObject<{
+                success: zod.ZodLiteral<false>;
+                error: zod.ZodObject<{
+                    code: zod.ZodUnion<readonly [zod.ZodString, zod.ZodNumber]>;
+                    message: zod.ZodString;
+                    traceId: zod.ZodOptional<zod.ZodString>;
+                    httpStatus: zod.ZodOptional<zod.ZodNumber>;
+                    system: zod.ZodOptional<zod.ZodString>;
+                    module: zod.ZodOptional<zod.ZodString>;
+                    cause: zod.ZodOptional<zod.ZodUnknown>;
+                    suggestion: zod.ZodOptional<zod.ZodString>;
+                    ext: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
+                }, zod_v4_core.$strip>;
+            }, zod_v4_core.$strip>], "success">, Record<never, never>, Record<never, never>>;
+        };
+    };
+}>;
+/**
+ * 默认 iam/storage/ai typed client 与 create、tokenStorage、createAuthActions 命名空间的交叉类型。
+ * 具体项目契约使用 apiClient.create 的返回类型，不给默认单例附加未知 procedure。
  *
- * // 契约调用
- * const result = await api.call(loginEndpoint, { identifier: 'alice', password: 'xxx' })
- *
- * // 通用 HTTP
- * const users = await api.get<User[]>('/users', { page: 1 })
+ * @example
+ * ```ts
+ * import { apiClient, type DefaultApiClient } from '@h-ai/api-client'
+ * const client: DefaultApiClient = apiClient
+ * const initialized = await client.init({ baseUrl: 'https://api.example.com/api/v1', auth: {} })
+ * if (!initialized.success) throw new Error(initialized.error.message)
+ * try { const actions = client.createAuthActions(client); const result = await actions.publicConfig(); if (!result.success) throw new Error(result.error.message) }
+ * finally { await client.close() }
+ * ```
+ */
+type DefaultApiClient = ApiClient<typeof defaultApiContract> & {
+    readonly create: typeof createApiClient;
+    readonly tokenStorage: typeof tokenStorage;
+    readonly createAuthActions: typeof createIamAuthActions;
+};
+/**
+ * API Client 公开入口：默认 iam/storage/ai 单例，以及独立实例、安全存储和认证动作工厂。
+ * 未启用 auth 时不注入或刷新 Token；浏览器 auth: {} 使用 httpOnly Cookie 方案。
+ * close 释放客户端运行状态/加密会话，不能替代服务端退出或 auth.clear。
  *
- * // 关闭
- * await api.close()
+ * @example
+ * ```ts
+ * import { apiClient } from '@h-ai/api-client'
+ * const initialized = await apiClient.init({ baseUrl: 'https://api.example.com/api/v1', auth: {} })
+ * if (!initialized.success) throw new Error(initialized.error.message)
+ * try {
+ *   const result = await apiClient.iam.auth.currentUser()
+ *   if (!result.success) throw new Error(result.error.message)
+ *   const permissions = result.data.permissions
+ * }
+ * finally { await apiClient.close() }
  * ```
  */
-declare const api: ApiClientFunctions;
+declare const apiClient: DefaultApiClient;
 
-export { type ApiClient, type ApiClientConfig, type ApiClientFunctions, type AuthConfig, type EndpointDef, HaiApiClientError, type RequestConfig, type RequestInterceptor, type ResponseInterceptor, type StreamOptions, type TokenPair, type TokenStorage, type UploadOptions, api, createLocalStorageTokenStorage, createMemoryTokenStorage, defineEndpoint };
+export { type ApiClient, type ApiClientAuth, type ApiClientConfig, type ApiClientLifecycle, type ApiClientTransportConfig, type ApiRequestObserver, type ApiRequestRecord, type AuthConfig, type DefaultApiClient, HaiApiClientError, type IamAuthLoginInput, type TokenPair, type TokenStorage, apiClient };