@deepraxis/sdk 0.0.0-stage → 0.1.0-dev.06cf3b8

package/dist/resources.generated.d.ts

@@ -0,0 +1,4217 @@
+import type * as Types from './generated/types.gen.js';
+import type { RenameParameters } from './core/bindings.js';
+import type { Transport } from './core/transport.js';
+export declare function createAgent(transport: Transport): {
+    agents: {
+        archive: (options: import("./core/transport.js").CallOptions<Types.AgentsArchiveData>) => Promise<{
+            id: string;
+            archived_at: null | string;
+            created_at: string;
+            description: null | string;
+            mcp_servers: Array<Types.AgentManaged36>;
+            metadata: Types.AgentManaged37;
+            model: {
+                id: "claude-opus-5-5" | "claude-fable-5-1" | "claude-sonnet-5" | "claude-fable-5" | "claude-opus-5" | "claude-opus-4-8" | "claude-opus-4-7" | "claude-opus-4-6" | "claude-sonnet-4-6" | "claude-haiku-4-5" | "claude-haiku-4-5-20251001" | "claude-opus-4-5" | "claude-opus-4-5-20251101" | "claude-sonnet-4-5" | "claude-sonnet-4-5-20250929" | string;
+                effort?: Types.AgentManaged2 | Types.AgentManaged3 | Types.AgentManaged4 | Types.AgentManaged5 | Types.AgentManaged6;
+                inference_geo?: string;
+                speed?: "standard" | "fast";
+                settings?: {
+                    reasoning?: "low" | "medium" | "high" | "xhigh" | "max" | "none";
+                };
+            };
+            multiagent: null | Types.AgentManaged39;
+            name: string;
+            skills: Array<Types.AgentManaged42 | Types.AgentManaged43>;
+            system: null | string;
+            tools: Array<Types.AgentManaged44 | Types.AgentManaged54 | Types.AgentManaged57>;
+            type: "agent";
+            updated_at: string;
+            version: number;
+            kind: "personal" | "service";
+            computer_id?: string;
+            subagent_model?: string | null;
+            subagents?: Array<{
+                name: string;
+                description: string;
+                prompt: string;
+                tools?: Array<string>;
+                disallowed_tools?: Array<string>;
+                model?: string;
+            }> | null;
+            commands?: Array<{
+                name: string;
+                description?: string;
+                argument_hint?: string;
+                prompt: string;
+            }> | null;
+            settings?: {
+                hooks?: {
+                    SessionStart?: Array<{
+                        matcher?: string;
+                        hooks: Array<{
+                            type: "command";
+                            command: string;
+                            timeout?: number;
+                            async?: boolean;
+                            enabled?: boolean;
+                        }>;
+                    }>;
+                    UserPromptSubmit?: Array<{
+                        matcher?: string;
+                        hooks: Array<{
+                            type: "command";
+                            command: string;
+                            timeout?: number;
+                            async?: boolean;
+                            enabled?: boolean;
+                        }>;
+                    }>;
+                    PreToolUse?: Array<{
+                        matcher?: string;
+                        hooks: Array<{
+                            type: "command";
+                            command: string;
+                            timeout?: number;
+                            async?: boolean;
+                            enabled?: boolean;
+                        }>;
+                    }>;
+                    PermissionRequest?: Array<{
+                        matcher?: string;
+                        hooks: Array<{
+                            type: "command";
+                            command: string;
+                            timeout?: number;
+                            async?: boolean;
+                            enabled?: boolean;
+                        }>;
+                    }>;
+                    PostToolUse?: Array<{
+                        matcher?: string;
+                        hooks: Array<{
+                            type: "command";
+                            command: string;
+                            timeout?: number;
+                            async?: boolean;
+                            enabled?: boolean;
+                        }>;
+                    }>;
+                    PostToolUseFailure?: Array<{
+                        matcher?: string;
+                        hooks: Array<{
+                            type: "command";
+                            command: string;
+                            timeout?: number;
+                            async?: boolean;
+                            enabled?: boolean;
+                        }>;
+                    }>;
+                    Stop?: Array<{
+                        matcher?: string;
+                        hooks: Array<{
+                            type: "command";
+                            command: string;
+                            timeout?: number;
+                            async?: boolean;
+                            enabled?: boolean;
+                        }>;
+                    }>;
+                };
+                allowManagedHooksOnly?: boolean;
+                allowManagedMcpServersOnly?: boolean;
+                allowManagedPermissionRulesOnly?: boolean;
+                autoMemoryEnabled?: boolean;
+                disabled?: {
+                    subagents?: Array<string>;
+                    commands?: Array<string>;
+                    skills?: Array<string>;
+                    mcpServers?: Array<string>;
+                    hooks?: Array<string>;
+                };
+            } | null;
+            models?: {
+                allowed: Array<string>;
+            };
+        }>;
+        create: (options: import("./core/transport.js").CallOptions<Types.AgentsCreateData>) => Promise<{
+            id: string;
+            archived_at: null | string;
+            created_at: string;
+            description: null | string;
+            mcp_servers: Array<Types.AgentManaged36>;
+            metadata: Types.AgentManaged37;
+            model: {
+                id: "claude-opus-5-5" | "claude-fable-5-1" | "claude-sonnet-5" | "claude-fable-5" | "claude-opus-5" | "claude-opus-4-8" | "claude-opus-4-7" | "claude-opus-4-6" | "claude-sonnet-4-6" | "claude-haiku-4-5" | "claude-haiku-4-5-20251001" | "claude-opus-4-5" | "claude-opus-4-5-20251101" | "claude-sonnet-4-5" | "claude-sonnet-4-5-20250929" | string;
+                effort?: Types.AgentManaged2 | Types.AgentManaged3 | Types.AgentManaged4 | Types.AgentManaged5 | Types.AgentManaged6;
+                inference_geo?: string;
+                speed?: "standard" | "fast";
+                settings?: {
+                    reasoning?: "low" | "medium" | "high" | "xhigh" | "max" | "none";
+                };
+            };
+            multiagent: null | Types.AgentManaged39;
+            name: string;
+            skills: Array<Types.AgentManaged42 | Types.AgentManaged43>;
+            system: null | string;
+            tools: Array<Types.AgentManaged44 | Types.AgentManaged54 | Types.AgentManaged57>;
+            type: "agent";
+            updated_at: string;
+            version: number;
+            kind: "personal" | "service";
+            computer_id?: string;
+            subagent_model?: string | null;
+            subagents?: Array<{
+                name: string;
+                description: string;
+                prompt: string;
+                tools?: Array<string>;
+                disallowed_tools?: Array<string>;
+                model?: string;
+            }> | null;
+            commands?: Array<{
+                name: string;
+                description?: string;
+                argument_hint?: string;
+                prompt: string;
+            }> | null;
+            settings?: {
+                hooks?: {
+                    SessionStart?: Array<{
+                        matcher?: string;
+                        hooks: Array<{
+                            type: "command";
+                            command: string;
+                            timeout?: number;
+                            async?: boolean;
+                            enabled?: boolean;
+                        }>;
+                    }>;
+                    UserPromptSubmit?: Array<{
+                        matcher?: string;
+                        hooks: Array<{
+                            type: "command";
+                            command: string;
+                            timeout?: number;
+                            async?: boolean;
+                            enabled?: boolean;
+                        }>;
+                    }>;
+                    PreToolUse?: Array<{
+                        matcher?: string;
+                        hooks: Array<{
+                            type: "command";
+                            command: string;
+                            timeout?: number;
+                            async?: boolean;
+                            enabled?: boolean;
+                        }>;
+                    }>;
+                    PermissionRequest?: Array<{
+                        matcher?: string;
+                        hooks: Array<{
+                            type: "command";
+                            command: string;
+                            timeout?: number;
+                            async?: boolean;
+                            enabled?: boolean;
+                        }>;
+                    }>;
+                    PostToolUse?: Array<{
+                        matcher?: string;
+                        hooks: Array<{
+                            type: "command";
+                            command: string;
+                            timeout?: number;
+                            async?: boolean;
+                            enabled?: boolean;
+                        }>;
+                    }>;
+                    PostToolUseFailure?: Array<{
+                        matcher?: string;
+                        hooks: Array<{
+                            type: "command";
+                            command: string;
+                            timeout?: number;
+                            async?: boolean;
+                            enabled?: boolean;
+                        }>;
+                    }>;
+                    Stop?: Array<{
+                        matcher?: string;
+                        hooks: Array<{
+                            type: "command";
+                            command: string;
+                            timeout?: number;
+                            async?: boolean;
+                            enabled?: boolean;
+                        }>;
+                    }>;
+                };
+                allowManagedHooksOnly?: boolean;
+                allowManagedMcpServersOnly?: boolean;
+                allowManagedPermissionRulesOnly?: boolean;
+                autoMemoryEnabled?: boolean;
+                disabled?: {
+                    subagents?: Array<string>;
+                    commands?: Array<string>;
+                    skills?: Array<string>;
+                    mcpServers?: Array<string>;
+                    hooks?: Array<string>;
+                };
+            } | null;
+            models?: {
+                allowed: Array<string>;
+            };
+        }>;
+        endUsers: {
+            block: {
+                create: (options: import("./core/transport.js").CallOptions<Types.BlockEndUserData>) => Promise<{
+                    external_user_id: string;
+                    first_seen_at: string | null;
+                    last_active_at: string | null;
+                    session_count: number;
+                    cost_micro_usd: number;
+                    blocked: boolean;
+                }>;
+            };
+            delete: (options: import("./core/transport.js").CallOptions<Types.DeleteEndUserData>) => Promise<{
+                id: string;
+                status: "pending";
+            }>;
+            list: (options: import("./core/transport.js").CallOptions<Types.ListEndUsersData>) => Promise<{
+                data: Array<{
+                    external_user_id: string;
+                    first_seen_at: string | null;
+                    last_active_at: string | null;
+                    session_count: number;
+                    cost_micro_usd: number;
+                    blocked: boolean;
+                }>;
+                next_page: string | null;
+            }>;
+            retrieve: (options: import("./core/transport.js").CallOptions<Types.GetEndUserData>) => Promise<{
+                external_user_id: string;
+                first_seen_at: string | null;
+                last_active_at: string | null;
+                session_count: number;
+                cost_micro_usd: number;
+                blocked: boolean;
+                recent_sessions: Array<{
+                    id: string;
+                    title: string | null;
+                    source: string | null;
+                    created_at: string;
+                    updated_at: string;
+                }>;
+            }>;
+            retrieveDeletion: (options: import("./core/transport.js").CallOptions<Types.GetEndUserDeletionData>) => Promise<{
+                id: string;
+                status: "pending" | "snapshotting" | "deleting" | "done" | "failed";
+                counts: {
+                    sessions?: number;
+                    events?: number;
+                    messages?: number;
+                    d1_rows?: number;
+                    attachments?: number;
+                };
+                snapshot_key?: string;
+                error?: string;
+                created_at: string;
+                updated_at: string;
+            }>;
+            revokeTokens: {
+                create: (options: import("./core/transport.js").CallOptions<Types.RevokeEndUserTokensData>) => Promise<{
+                    revoked: number;
+                }>;
+            };
+            unblock: {
+                create: (options: import("./core/transport.js").CallOptions<Types.UnblockEndUserData>) => Promise<{
+                    external_user_id: string;
+                    first_seen_at: string | null;
+                    last_active_at: string | null;
+                    session_count: number;
+                    cost_micro_usd: number;
+                    blocked: boolean;
+                }>;
+            };
+        };
+        list: (options?: import("./core/transport.js").CallOptions<Types.AgentsListData> | undefined) => Promise<{
+            data: Array<{
+                id: string;
+                archived_at: null | string;
+                created_at: string;
+                description: null | string;
+                mcp_servers: Array<Types.AgentManaged36>;
+                metadata: Types.AgentManaged37;
+                model: {
+                    id: "claude-opus-5-5" | "claude-fable-5-1" | "claude-sonnet-5" | "claude-fable-5" | "claude-opus-5" | "claude-opus-4-8" | "claude-opus-4-7" | "claude-opus-4-6" | "claude-sonnet-4-6" | "claude-haiku-4-5" | "claude-haiku-4-5-20251001" | "claude-opus-4-5" | "claude-opus-4-5-20251101" | "claude-sonnet-4-5" | "claude-sonnet-4-5-20250929" | string;
+                    effort?: Types.AgentManaged2 | Types.AgentManaged3 | Types.AgentManaged4 | Types.AgentManaged5 | Types.AgentManaged6;
+                    inference_geo?: string;
+                    speed?: "standard" | "fast";
+                    settings?: {
+                        reasoning?: "low" | "medium" | "high" | "xhigh" | "max" | "none";
+                    };
+                };
+                multiagent: null | Types.AgentManaged39;
+                name: string;
+                skills: Array<Types.AgentManaged42 | Types.AgentManaged43>;
+                system: null | string;
+                tools: Array<Types.AgentManaged44 | Types.AgentManaged54 | Types.AgentManaged57>;
+                type: "agent";
+                updated_at: string;
+                version: number;
+                kind: "personal" | "service";
+                computer_id?: string;
+                subagent_model?: string | null;
+                subagents?: Array<{
+                    name: string;
+                    description: string;
+                    prompt: string;
+                    tools?: Array<string>;
+                    disallowed_tools?: Array<string>;
+                    model?: string;
+                }> | null;
+                commands?: Array<{
+                    name: string;
+                    description?: string;
+                    argument_hint?: string;
+                    prompt: string;
+                }> | null;
+                settings?: {
+                    hooks?: {
+                        SessionStart?: Array<{
+                            matcher?: string;
+                            hooks: Array<{
+                                type: "command";
+                                command: string;
+                                timeout?: number;
+                                async?: boolean;
+                                enabled?: boolean;
+                            }>;
+                        }>;
+                        UserPromptSubmit?: Array<{
+                            matcher?: string;
+                            hooks: Array<{
+                                type: "command";
+                                command: string;
+                                timeout?: number;
+                                async?: boolean;
+                                enabled?: boolean;
+                            }>;
+                        }>;
+                        PreToolUse?: Array<{
+                            matcher?: string;
+                            hooks: Array<{
+                                type: "command";
+                                command: string;
+                                timeout?: number;
+                                async?: boolean;
+                                enabled?: boolean;
+                            }>;
+                        }>;
+                        PermissionRequest?: Array<{
+                            matcher?: string;
+                            hooks: Array<{
+                                type: "command";
+                                command: string;
+                                timeout?: number;
+                                async?: boolean;
+                                enabled?: boolean;
+                            }>;
+                        }>;
+                        PostToolUse?: Array<{
+                            matcher?: string;
+                            hooks: Array<{
+                                type: "command";
+                                command: string;
+                                timeout?: number;
+                                async?: boolean;
+                                enabled?: boolean;
+                            }>;
+                        }>;
+                        PostToolUseFailure?: Array<{
+                            matcher?: string;
+                            hooks: Array<{
+                                type: "command";
+                                command: string;
+                                timeout?: number;
+                                async?: boolean;
+                                enabled?: boolean;
+                            }>;
+                        }>;
+                        Stop?: Array<{
+                            matcher?: string;
+                            hooks: Array<{
+                                type: "command";
+                                command: string;
+                                timeout?: number;
+                                async?: boolean;
+                                enabled?: boolean;
+                            }>;
+                        }>;
+                    };
+                    allowManagedHooksOnly?: boolean;
+                    allowManagedMcpServersOnly?: boolean;
+                    allowManagedPermissionRulesOnly?: boolean;
+                    autoMemoryEnabled?: boolean;
+                    disabled?: {
+                        subagents?: Array<string>;
+                        commands?: Array<string>;
+                        skills?: Array<string>;
+                        mcpServers?: Array<string>;
+                        hooks?: Array<string>;
+                    };
+                } | null;
+                models?: {
+                    allowed: Array<string>;
+                };
+            }>;
+            next_page: string | null;
+        }>;
+        retrieve: (options: import("./core/transport.js").CallOptions<Types.AgentsRetrieveData>) => Promise<{
+            id: string;
+            archived_at: null | string;
+            created_at: string;
+            description: null | string;
+            mcp_servers: Array<Types.AgentManaged36>;
+            metadata: Types.AgentManaged37;
+            model: {
+                id: "claude-opus-5-5" | "claude-fable-5-1" | "claude-sonnet-5" | "claude-fable-5" | "claude-opus-5" | "claude-opus-4-8" | "claude-opus-4-7" | "claude-opus-4-6" | "claude-sonnet-4-6" | "claude-haiku-4-5" | "claude-haiku-4-5-20251001" | "claude-opus-4-5" | "claude-opus-4-5-20251101" | "claude-sonnet-4-5" | "claude-sonnet-4-5-20250929" | string;
+                effort?: Types.AgentManaged2 | Types.AgentManaged3 | Types.AgentManaged4 | Types.AgentManaged5 | Types.AgentManaged6;
+                inference_geo?: string;
+                speed?: "standard" | "fast";
+                settings?: {
+                    reasoning?: "low" | "medium" | "high" | "xhigh" | "max" | "none";
+                };
+            };
+            multiagent: null | Types.AgentManaged39;
+            name: string;
+            skills: Array<Types.AgentManaged42 | Types.AgentManaged43>;
+            system: null | string;
+            tools: Array<Types.AgentManaged44 | Types.AgentManaged54 | Types.AgentManaged57>;
+            type: "agent";
+            updated_at: string;
+            version: number;
+            kind: "personal" | "service";
+            computer_id?: string;
+            subagent_model?: string | null;
+            subagents?: Array<{
+                name: string;
+                description: string;
+                prompt: string;
+                tools?: Array<string>;
+                disallowed_tools?: Array<string>;
+                model?: string;
+            }> | null;
+            commands?: Array<{
+                name: string;
+                description?: string;
+                argument_hint?: string;
+                prompt: string;
+            }> | null;
+            settings?: {
+                hooks?: {
+                    SessionStart?: Array<{
+                        matcher?: string;
+                        hooks: Array<{
+                            type: "command";
+                            command: string;
+                            timeout?: number;
+                            async?: boolean;
+                            enabled?: boolean;
+                        }>;
+                    }>;
+                    UserPromptSubmit?: Array<{
+                        matcher?: string;
+                        hooks: Array<{
+                            type: "command";
+                            command: string;
+                            timeout?: number;
+                            async?: boolean;
+                            enabled?: boolean;
+                        }>;
+                    }>;
+                    PreToolUse?: Array<{
+                        matcher?: string;
+                        hooks: Array<{
+                            type: "command";
+                            command: string;
+                            timeout?: number;
+                            async?: boolean;
+                            enabled?: boolean;
+                        }>;
+                    }>;
+                    PermissionRequest?: Array<{
+                        matcher?: string;
+                        hooks: Array<{
+                            type: "command";
+                            command: string;
+                            timeout?: number;
+                            async?: boolean;
+                            enabled?: boolean;
+                        }>;
+                    }>;
+                    PostToolUse?: Array<{
+                        matcher?: string;
+                        hooks: Array<{
+                            type: "command";
+                            command: string;
+                            timeout?: number;
+                            async?: boolean;
+                            enabled?: boolean;
+                        }>;
+                    }>;
+                    PostToolUseFailure?: Array<{
+                        matcher?: string;
+                        hooks: Array<{
+                            type: "command";
+                            command: string;
+                            timeout?: number;
+                            async?: boolean;
+                            enabled?: boolean;
+                        }>;
+                    }>;
+                    Stop?: Array<{
+                        matcher?: string;
+                        hooks: Array<{
+                            type: "command";
+                            command: string;
+                            timeout?: number;
+                            async?: boolean;
+                            enabled?: boolean;
+                        }>;
+                    }>;
+                };
+                allowManagedHooksOnly?: boolean;
+                allowManagedMcpServersOnly?: boolean;
+                allowManagedPermissionRulesOnly?: boolean;
+                autoMemoryEnabled?: boolean;
+                disabled?: {
+                    subagents?: Array<string>;
+                    commands?: Array<string>;
+                    skills?: Array<string>;
+                    mcpServers?: Array<string>;
+                    hooks?: Array<string>;
+                };
+            } | null;
+            models?: {
+                allowed: Array<string>;
+            };
+        }>;
+        update: (options: import("./core/transport.js").CallOptions<Types.AgentsUpdateData>) => Promise<{
+            id: string;
+            archived_at: null | string;
+            created_at: string;
+            description: null | string;
+            mcp_servers: Array<Types.AgentManaged36>;
+            metadata: Types.AgentManaged37;
+            model: {
+                id: "claude-opus-5-5" | "claude-fable-5-1" | "claude-sonnet-5" | "claude-fable-5" | "claude-opus-5" | "claude-opus-4-8" | "claude-opus-4-7" | "claude-opus-4-6" | "claude-sonnet-4-6" | "claude-haiku-4-5" | "claude-haiku-4-5-20251001" | "claude-opus-4-5" | "claude-opus-4-5-20251101" | "claude-sonnet-4-5" | "claude-sonnet-4-5-20250929" | string;
+                effort?: Types.AgentManaged2 | Types.AgentManaged3 | Types.AgentManaged4 | Types.AgentManaged5 | Types.AgentManaged6;
+                inference_geo?: string;
+                speed?: "standard" | "fast";
+                settings?: {
+                    reasoning?: "low" | "medium" | "high" | "xhigh" | "max" | "none";
+                };
+            };
+            multiagent: null | Types.AgentManaged39;
+            name: string;
+            skills: Array<Types.AgentManaged42 | Types.AgentManaged43>;
+            system: null | string;
+            tools: Array<Types.AgentManaged44 | Types.AgentManaged54 | Types.AgentManaged57>;
+            type: "agent";
+            updated_at: string;
+            version: number;
+            kind: "personal" | "service";
+            computer_id?: string;
+            subagent_model?: string | null;
+            subagents?: Array<{
+                name: string;
+                description: string;
+                prompt: string;
+                tools?: Array<string>;
+                disallowed_tools?: Array<string>;
+                model?: string;
+            }> | null;
+            commands?: Array<{
+                name: string;
+                description?: string;
+                argument_hint?: string;
+                prompt: string;
+            }> | null;
+            settings?: {
+                hooks?: {
+                    SessionStart?: Array<{
+                        matcher?: string;
+                        hooks: Array<{
+                            type: "command";
+                            command: string;
+                            timeout?: number;
+                            async?: boolean;
+                            enabled?: boolean;
+                        }>;
+                    }>;
+                    UserPromptSubmit?: Array<{
+                        matcher?: string;
+                        hooks: Array<{
+                            type: "command";
+                            command: string;
+                            timeout?: number;
+                            async?: boolean;
+                            enabled?: boolean;
+                        }>;
+                    }>;
+                    PreToolUse?: Array<{
+                        matcher?: string;
+                        hooks: Array<{
+                            type: "command";
+                            command: string;
+                            timeout?: number;
+                            async?: boolean;
+                            enabled?: boolean;
+                        }>;
+                    }>;
+                    PermissionRequest?: Array<{
+                        matcher?: string;
+                        hooks: Array<{
+                            type: "command";
+                            command: string;
+                            timeout?: number;
+                            async?: boolean;
+                            enabled?: boolean;
+                        }>;
+                    }>;
+                    PostToolUse?: Array<{
+                        matcher?: string;
+                        hooks: Array<{
+                            type: "command";
+                            command: string;
+                            timeout?: number;
+                            async?: boolean;
+                            enabled?: boolean;
+                        }>;
+                    }>;
+                    PostToolUseFailure?: Array<{
+                        matcher?: string;
+                        hooks: Array<{
+                            type: "command";
+                            command: string;
+                            timeout?: number;
+                            async?: boolean;
+                            enabled?: boolean;
+                        }>;
+                    }>;
+                    Stop?: Array<{
+                        matcher?: string;
+                        hooks: Array<{
+                            type: "command";
+                            command: string;
+                            timeout?: number;
+                            async?: boolean;
+                            enabled?: boolean;
+                        }>;
+                    }>;
+                };
+                allowManagedHooksOnly?: boolean;
+                allowManagedMcpServersOnly?: boolean;
+                allowManagedPermissionRulesOnly?: boolean;
+                autoMemoryEnabled?: boolean;
+                disabled?: {
+                    subagents?: Array<string>;
+                    commands?: Array<string>;
+                    skills?: Array<string>;
+                    mcpServers?: Array<string>;
+                    hooks?: Array<string>;
+                };
+            } | null;
+            models?: {
+                allowed: Array<string>;
+            };
+        }>;
+        versions: {
+            list: (options: import("./core/transport.js").CallOptions<Types.AgentsVersionsListData>) => Promise<{
+                data: Array<{
+                    id: string;
+                    archived_at: null | string;
+                    created_at: string;
+                    description: null | string;
+                    mcp_servers: Array<Types.AgentManaged36>;
+                    metadata: Types.AgentManaged37;
+                    model: {
+                        id: "claude-opus-5-5" | "claude-fable-5-1" | "claude-sonnet-5" | "claude-fable-5" | "claude-opus-5" | "claude-opus-4-8" | "claude-opus-4-7" | "claude-opus-4-6" | "claude-sonnet-4-6" | "claude-haiku-4-5" | "claude-haiku-4-5-20251001" | "claude-opus-4-5" | "claude-opus-4-5-20251101" | "claude-sonnet-4-5" | "claude-sonnet-4-5-20250929" | string;
+                        effort?: Types.AgentManaged2 | Types.AgentManaged3 | Types.AgentManaged4 | Types.AgentManaged5 | Types.AgentManaged6;
+                        inference_geo?: string;
+                        speed?: "standard" | "fast";
+                        settings?: {
+                            reasoning?: "low" | "medium" | "high" | "xhigh" | "max" | "none";
+                        };
+                    };
+                    multiagent: null | Types.AgentManaged39;
+                    name: string;
+                    skills: Array<Types.AgentManaged42 | Types.AgentManaged43>;
+                    system: null | string;
+                    tools: Array<Types.AgentManaged44 | Types.AgentManaged54 | Types.AgentManaged57>;
+                    type: "agent";
+                    updated_at: string;
+                    version: number;
+                    kind: "personal" | "service";
+                    computer_id?: string;
+                    subagent_model?: string | null;
+                    subagents?: Array<{
+                        name: string;
+                        description: string;
+                        prompt: string;
+                        tools?: Array<string>;
+                        disallowed_tools?: Array<string>;
+                        model?: string;
+                    }> | null;
+                    commands?: Array<{
+                        name: string;
+                        description?: string;
+                        argument_hint?: string;
+                        prompt: string;
+                    }> | null;
+                    settings?: {
+                        hooks?: {
+                            SessionStart?: Array<{
+                                matcher?: string;
+                                hooks: Array<{
+                                    type: "command";
+                                    command: string;
+                                    timeout?: number;
+                                    async?: boolean;
+                                    enabled?: boolean;
+                                }>;
+                            }>;
+                            UserPromptSubmit?: Array<{
+                                matcher?: string;
+                                hooks: Array<{
+                                    type: "command";
+                                    command: string;
+                                    timeout?: number;
+                                    async?: boolean;
+                                    enabled?: boolean;
+                                }>;
+                            }>;
+                            PreToolUse?: Array<{
+                                matcher?: string;
+                                hooks: Array<{
+                                    type: "command";
+                                    command: string;
+                                    timeout?: number;
+                                    async?: boolean;
+                                    enabled?: boolean;
+                                }>;
+                            }>;
+                            PermissionRequest?: Array<{
+                                matcher?: string;
+                                hooks: Array<{
+                                    type: "command";
+                                    command: string;
+                                    timeout?: number;
+                                    async?: boolean;
+                                    enabled?: boolean;
+                                }>;
+                            }>;
+                            PostToolUse?: Array<{
+                                matcher?: string;
+                                hooks: Array<{
+                                    type: "command";
+                                    command: string;
+                                    timeout?: number;
+                                    async?: boolean;
+                                    enabled?: boolean;
+                                }>;
+                            }>;
+                            PostToolUseFailure?: Array<{
+                                matcher?: string;
+                                hooks: Array<{
+                                    type: "command";
+                                    command: string;
+                                    timeout?: number;
+                                    async?: boolean;
+                                    enabled?: boolean;
+                                }>;
+                            }>;
+                            Stop?: Array<{
+                                matcher?: string;
+                                hooks: Array<{
+                                    type: "command";
+                                    command: string;
+                                    timeout?: number;
+                                    async?: boolean;
+                                    enabled?: boolean;
+                                }>;
+                            }>;
+                        };
+                        allowManagedHooksOnly?: boolean;
+                        allowManagedMcpServersOnly?: boolean;
+                        allowManagedPermissionRulesOnly?: boolean;
+                        autoMemoryEnabled?: boolean;
+                        disabled?: {
+                            subagents?: Array<string>;
+                            commands?: Array<string>;
+                            skills?: Array<string>;
+                            mcpServers?: Array<string>;
+                            hooks?: Array<string>;
+                        };
+                    } | null;
+                    models?: {
+                        allowed: Array<string>;
+                    };
+                }>;
+                next_page: string | null;
+            }>;
+        };
+    };
+    computers: {
+        archive: (options: import("./core/transport.js").CallOptions<Types.ComputersArchiveData>) => Promise<{
+            type: "computer";
+            id: string;
+            name: string;
+            sandbox_id: string | null;
+            environment_id: string | null;
+            status: "active" | "archived";
+            created_at: string;
+            updated_at: string;
+            archived_at: string | null;
+        }>;
+        attachments: {
+            create: (options: import("./core/transport.js").CallOptions<Types.ComputersAttachmentsCreateData>) => Promise<{
+                path: string;
+                name: string;
+                type: "file" | "dir" | "symlink";
+                size: number;
+                mime_type: string;
+                read_only: boolean;
+                digest?: string | null;
+                updated_at: string | null;
+            }>;
+        };
+        connect: (options: import("./core/transport.js").CallOptions<Types.ConnectComputerData>) => Promise<{
+            sandbox_id: string;
+            envd_access_token: string;
+            template_id: string;
+            tier: "light" | "heavy";
+            lease_id: string | null;
+            lease_expires_at: string | null;
+        }>;
+        create: (options: import("./core/transport.js").CallOptions<Types.ComputersCreateData>) => Promise<{
+            type: "computer";
+            id: string;
+            name: string;
+            sandbox_id: string | null;
+            environment_id: string | null;
+            status: "active" | "archived";
+            created_at: string;
+            updated_at: string;
+            archived_at: string | null;
+        }>;
+        delete: (options: import("./core/transport.js").CallOptions<Types.ComputersDeleteData>) => Promise<{
+            id: string;
+            type: "computer_deleted";
+        }>;
+        files: {
+            list: (options: import("./core/transport.js").CallOptions<Types.ComputersFilesListData>) => Promise<{
+                data: Array<{
+                    path: string;
+                    name: string;
+                    type: "file" | "dir" | "symlink";
+                    size: number;
+                    mime_type: string;
+                    read_only: boolean;
+                    digest?: string | null;
+                    updated_at: string | null;
+                }>;
+                has_more: false;
+            }>;
+            retrieveContent: (options: import("./core/transport.js").CallOptions<Types.ComputersFilesContentData>) => Promise<Blob | File>;
+        };
+        leases: {
+            delete: (options: import("./core/transport.js").CallOptions<Types.ReleaseComputerLeaseData>) => Promise<{
+                id: string;
+                type: "computer_lease_released";
+            }>;
+            renew: {
+                create: (options: import("./core/transport.js").CallOptions<Types.RenewComputerLeaseData>) => Promise<{
+                    lease_id: string;
+                    lease_expires_at: string;
+                }>;
+            };
+        };
+        list: (options?: import("./core/transport.js").CallOptions<Types.ComputersListData> | undefined) => Promise<{
+            data: Array<{
+                type: "computer";
+                id: string;
+                name: string;
+                sandbox_id: string | null;
+                environment_id: string | null;
+                status: "active" | "archived";
+                created_at: string;
+                updated_at: string;
+                archived_at: string | null;
+            }>;
+            has_more: boolean;
+            next_page: string | null;
+        }>;
+        retrieve: (options: import("./core/transport.js").CallOptions<Types.ComputersRetrieveData>) => Promise<{
+            type: "computer";
+            id: string;
+            name: string;
+            sandbox_id: string | null;
+            environment_id: string | null;
+            status: "active" | "archived";
+            created_at: string;
+            updated_at: string;
+            archived_at: string | null;
+            implementation: "virtual" | "sandbox";
+            storage_bytes: number;
+            file_count: number;
+        }>;
+        update: (options: import("./core/transport.js").CallOptions<Types.ComputersUpdateData>) => Promise<{
+            type: "computer";
+            id: string;
+            name: string;
+            sandbox_id: string | null;
+            environment_id: string | null;
+            status: "active" | "archived";
+            created_at: string;
+            updated_at: string;
+            archived_at: string | null;
+        }>;
+    };
+    deploymentRuns: {
+        list: (options?: import("./core/transport.js").CallOptions<Types.DeploymentRunsListData> | undefined) => Promise<{
+            data: Array<Types.AgentManaged113>;
+            next_page: string | null;
+        }>;
+        retrieve: (options: import("./core/transport.js").CallOptions<Types.DeploymentRunsRetrieveData>) => Promise<Types.AgentManaged113>;
+    };
+    deployments: {
+        archive: (options: import("./core/transport.js").CallOptions<Types.DeploymentsArchiveData>) => Promise<{
+            id: string;
+            agent: {
+                id: string;
+                type: "agent";
+                version: number;
+            } | {
+                id: string;
+                type: "agent_with_overrides";
+                permission_mode?: "build" | "edit" | "plan" | "yolo" | null;
+                cwd?: string;
+                model?: string | {
+                    id: string;
+                    effort?: null | "low" | "medium" | "high" | "xhigh" | "max" | Types.AgentManaged2 | Types.AgentManaged3 | Types.AgentManaged4 | Types.AgentManaged5 | Types.AgentManaged6;
+                    speed?: null | "standard" | "fast";
+                };
+                version: number;
+            };
+            archived_at: null | string;
+            created_at: string;
+            description: null | string;
+            environment_id?: string | null;
+            initial_events: Array<Types.AgentManaged86 | Types.AgentManaged87 | Types.AgentManaged90>;
+            metadata: Types.AgentManaged91;
+            name: string;
+            paused_reason: null | Types.AgentManaged92 | Types.AgentManaged93;
+            resources: Array<Types.AgentManaged108 | Types.AgentManaged109 | Types.AgentManaged110>;
+            schedule: null | Types.AgentManaged111;
+            status: "active" | "paused";
+            type: "deployment";
+            updated_at: string;
+            vault_ids: Array<string>;
+            budget?: null | Types.AgentManaged76;
+            target: {
+                type: "environment" | "computer";
+            };
+        }>;
+        create: (options: import("./core/transport.js").CallOptions<Types.DeploymentsCreateData>) => Promise<{
+            id: string;
+            agent: {
+                id: string;
+                type: "agent";
+                version: number;
+            } | {
+                id: string;
+                type: "agent_with_overrides";
+                permission_mode?: "build" | "edit" | "plan" | "yolo" | null;
+                cwd?: string;
+                model?: string | {
+                    id: string;
+                    effort?: null | "low" | "medium" | "high" | "xhigh" | "max" | Types.AgentManaged2 | Types.AgentManaged3 | Types.AgentManaged4 | Types.AgentManaged5 | Types.AgentManaged6;
+                    speed?: null | "standard" | "fast";
+                };
+                version: number;
+            };
+            archived_at: null | string;
+            created_at: string;
+            description: null | string;
+            environment_id?: string | null;
+            initial_events: Array<Types.AgentManaged86 | Types.AgentManaged87 | Types.AgentManaged90>;
+            metadata: Types.AgentManaged91;
+            name: string;
+            paused_reason: null | Types.AgentManaged92 | Types.AgentManaged93;
+            resources: Array<Types.AgentManaged108 | Types.AgentManaged109 | Types.AgentManaged110>;
+            schedule: null | Types.AgentManaged111;
+            status: "active" | "paused";
+            type: "deployment";
+            updated_at: string;
+            vault_ids: Array<string>;
+            budget?: null | Types.AgentManaged76;
+            target: {
+                type: "environment" | "computer";
+            };
+        }>;
+        list: (options?: import("./core/transport.js").CallOptions<Types.DeploymentsListData> | undefined) => Promise<{
+            data: Array<{
+                id: string;
+                agent: {
+                    id: string;
+                    type: "agent";
+                    version: number;
+                } | {
+                    id: string;
+                    type: "agent_with_overrides";
+                    permission_mode?: "build" | "edit" | "plan" | "yolo" | null;
+                    cwd?: string;
+                    model?: string | {
+                        id: string;
+                        effort?: null | "low" | "medium" | "high" | "xhigh" | "max" | Types.AgentManaged2 | Types.AgentManaged3 | Types.AgentManaged4 | Types.AgentManaged5 | Types.AgentManaged6;
+                        speed?: null | "standard" | "fast";
+                    };
+                    version: number;
+                };
+                archived_at: null | string;
+                created_at: string;
+                description: null | string;
+                environment_id?: string | null;
+                initial_events: Array<Types.AgentManaged86 | Types.AgentManaged87 | Types.AgentManaged90>;
+                metadata: Types.AgentManaged91;
+                name: string;
+                paused_reason: null | Types.AgentManaged92 | Types.AgentManaged93;
+                resources: Array<Types.AgentManaged108 | Types.AgentManaged109 | Types.AgentManaged110>;
+                schedule: null | Types.AgentManaged111;
+                status: "active" | "paused";
+                type: "deployment";
+                updated_at: string;
+                vault_ids: Array<string>;
+                budget?: null | Types.AgentManaged76;
+                target: {
+                    type: "environment" | "computer";
+                };
+            }>;
+            next_page: string | null;
+        }>;
+        pause: (options: import("./core/transport.js").CallOptions<Types.DeploymentsPauseData>) => Promise<{
+            id: string;
+            agent: {
+                id: string;
+                type: "agent";
+                version: number;
+            } | {
+                id: string;
+                type: "agent_with_overrides";
+                permission_mode?: "build" | "edit" | "plan" | "yolo" | null;
+                cwd?: string;
+                model?: string | {
+                    id: string;
+                    effort?: null | "low" | "medium" | "high" | "xhigh" | "max" | Types.AgentManaged2 | Types.AgentManaged3 | Types.AgentManaged4 | Types.AgentManaged5 | Types.AgentManaged6;
+                    speed?: null | "standard" | "fast";
+                };
+                version: number;
+            };
+            archived_at: null | string;
+            created_at: string;
+            description: null | string;
+            environment_id?: string | null;
+            initial_events: Array<Types.AgentManaged86 | Types.AgentManaged87 | Types.AgentManaged90>;
+            metadata: Types.AgentManaged91;
+            name: string;
+            paused_reason: null | Types.AgentManaged92 | Types.AgentManaged93;
+            resources: Array<Types.AgentManaged108 | Types.AgentManaged109 | Types.AgentManaged110>;
+            schedule: null | Types.AgentManaged111;
+            status: "active" | "paused";
+            type: "deployment";
+            updated_at: string;
+            vault_ids: Array<string>;
+            budget?: null | Types.AgentManaged76;
+            target: {
+                type: "environment" | "computer";
+            };
+        }>;
+        retrieve: (options: import("./core/transport.js").CallOptions<Types.DeploymentsRetrieveData>) => Promise<{
+            id: string;
+            agent: {
+                id: string;
+                type: "agent";
+                version: number;
+            } | {
+                id: string;
+                type: "agent_with_overrides";
+                permission_mode?: "build" | "edit" | "plan" | "yolo" | null;
+                cwd?: string;
+                model?: string | {
+                    id: string;
+                    effort?: null | "low" | "medium" | "high" | "xhigh" | "max" | Types.AgentManaged2 | Types.AgentManaged3 | Types.AgentManaged4 | Types.AgentManaged5 | Types.AgentManaged6;
+                    speed?: null | "standard" | "fast";
+                };
+                version: number;
+            };
+            archived_at: null | string;
+            created_at: string;
+            description: null | string;
+            environment_id?: string | null;
+            initial_events: Array<Types.AgentManaged86 | Types.AgentManaged87 | Types.AgentManaged90>;
+            metadata: Types.AgentManaged91;
+            name: string;
+            paused_reason: null | Types.AgentManaged92 | Types.AgentManaged93;
+            resources: Array<Types.AgentManaged108 | Types.AgentManaged109 | Types.AgentManaged110>;
+            schedule: null | Types.AgentManaged111;
+            status: "active" | "paused";
+            type: "deployment";
+            updated_at: string;
+            vault_ids: Array<string>;
+            budget?: null | Types.AgentManaged76;
+            target: {
+                type: "environment" | "computer";
+            };
+        }>;
+        run: {
+            create: (options: import("./core/transport.js").CallOptions<Types.DeploymentsRunData>) => Promise<Types.AgentManaged113>;
+        };
+        unpause: {
+            create: (options: import("./core/transport.js").CallOptions<Types.DeploymentsUnpauseData>) => Promise<{
+                id: string;
+                agent: {
+                    id: string;
+                    type: "agent";
+                    version: number;
+                } | {
+                    id: string;
+                    type: "agent_with_overrides";
+                    permission_mode?: "build" | "edit" | "plan" | "yolo" | null;
+                    cwd?: string;
+                    model?: string | {
+                        id: string;
+                        effort?: null | "low" | "medium" | "high" | "xhigh" | "max" | Types.AgentManaged2 | Types.AgentManaged3 | Types.AgentManaged4 | Types.AgentManaged5 | Types.AgentManaged6;
+                        speed?: null | "standard" | "fast";
+                    };
+                    version: number;
+                };
+                archived_at: null | string;
+                created_at: string;
+                description: null | string;
+                environment_id?: string | null;
+                initial_events: Array<Types.AgentManaged86 | Types.AgentManaged87 | Types.AgentManaged90>;
+                metadata: Types.AgentManaged91;
+                name: string;
+                paused_reason: null | Types.AgentManaged92 | Types.AgentManaged93;
+                resources: Array<Types.AgentManaged108 | Types.AgentManaged109 | Types.AgentManaged110>;
+                schedule: null | Types.AgentManaged111;
+                status: "active" | "paused";
+                type: "deployment";
+                updated_at: string;
+                vault_ids: Array<string>;
+                budget?: null | Types.AgentManaged76;
+                target: {
+                    type: "environment" | "computer";
+                };
+            }>;
+        };
+        update: (options: import("./core/transport.js").CallOptions<Types.DeploymentsUpdateData>) => Promise<{
+            id: string;
+            agent: {
+                id: string;
+                type: "agent";
+                version: number;
+            } | {
+                id: string;
+                type: "agent_with_overrides";
+                permission_mode?: "build" | "edit" | "plan" | "yolo" | null;
+                cwd?: string;
+                model?: string | {
+                    id: string;
+                    effort?: null | "low" | "medium" | "high" | "xhigh" | "max" | Types.AgentManaged2 | Types.AgentManaged3 | Types.AgentManaged4 | Types.AgentManaged5 | Types.AgentManaged6;
+                    speed?: null | "standard" | "fast";
+                };
+                version: number;
+            };
+            archived_at: null | string;
+            created_at: string;
+            description: null | string;
+            environment_id?: string | null;
+            initial_events: Array<Types.AgentManaged86 | Types.AgentManaged87 | Types.AgentManaged90>;
+            metadata: Types.AgentManaged91;
+            name: string;
+            paused_reason: null | Types.AgentManaged92 | Types.AgentManaged93;
+            resources: Array<Types.AgentManaged108 | Types.AgentManaged109 | Types.AgentManaged110>;
+            schedule: null | Types.AgentManaged111;
+            status: "active" | "paused";
+            type: "deployment";
+            updated_at: string;
+            vault_ids: Array<string>;
+            budget?: null | Types.AgentManaged76;
+            target: {
+                type: "environment" | "computer";
+            };
+        }>;
+    };
+    embed: {
+        exchange: {
+            create: (options: import("./core/transport.js").CallOptions<Types.ExchangeEmbedCodeData>) => Promise<{
+                token: string;
+                expires_at: string;
+            }>;
+        };
+        retrieveAppearance: (options?: import("./core/transport.js").CallOptions<Types.GetEmbedAppearanceData> | undefined) => Promise<{
+            agent?: {
+                name?: string;
+                avatar?: string;
+            };
+            layout?: "inline" | "sidebar" | "popup" | "modal";
+            launcher?: {
+                type: "none" | "bubble" | "mascot";
+                image?: string;
+                position?: "bottom-right" | "bottom-left";
+                label?: string;
+            };
+            header?: {
+                title?: string;
+                subtitle?: string;
+                icon?: string;
+            };
+            theme?: {
+                colorScheme?: "light" | "dark" | "system";
+                accent?: string;
+                surface?: string;
+                grayscale?: "neutral" | "warm" | "cool";
+                radius?: "none" | "sm" | "md" | "lg" | "full";
+                density?: "compact" | "normal" | "spacious";
+                fontFamily?: string;
+                fontSize?: number;
+            };
+            locale?: "zh" | "en";
+            startScreen?: {
+                greeting?: string;
+                prompts?: Array<{
+                    label: string;
+                    prompt: string;
+                }>;
+            };
+            composer?: {
+                placeholder?: string;
+            };
+            disclaimer?: string;
+            footer?: string;
+            history?: {
+                enabled?: boolean;
+            };
+        }>;
+    };
+    embedTokens: {
+        anonymous: {
+            create: (options: import("./core/transport.js").CallOptions<Types.CreateAnonymousEmbedTokenData>) => Promise<{
+                token: string;
+                expires_at: string;
+                visitor_secret?: string;
+            }>;
+        };
+        create: (options: import("./core/transport.js").CallOptions<Types.CreateEmbedTokenData>) => Promise<{
+            hosted_url?: string;
+            id: string;
+            token: string;
+            expires_at: string;
+        }>;
+        list: (options?: import("./core/transport.js").CallOptions<Types.ListEmbedTokensData> | undefined) => Promise<{
+            data: Array<{
+                id: string;
+                type: "embed_token";
+                agent_id: string;
+                agent_version: number;
+                external_user_id: string;
+                created_at: string;
+                expires_at: string;
+                revoked_at: string | null;
+                host_origin: string | null;
+                issued_by: {
+                    type: "user" | "api_key";
+                    id: string;
+                };
+            }>;
+            next_page: string | null;
+        }>;
+        revoke: {
+            create: (options: import("./core/transport.js").CallOptions<Types.RevokeEmbedTokenData>) => Promise<{
+                id: string;
+                type: "embed_token";
+                agent_id: string;
+                agent_version: number;
+                external_user_id: string;
+                created_at: string;
+                expires_at: string;
+                revoked_at: string | null;
+                host_origin: string | null;
+                issued_by: {
+                    type: "user" | "api_key";
+                    id: string;
+                };
+            }>;
+        };
+    };
+    environments: {
+        archive: (options: import("./core/transport.js").CallOptions<Types.EnvironmentsArchiveData>) => Promise<Types.AgentManaged138>;
+        create: (options: import("./core/transport.js").CallOptions<Types.EnvironmentsCreateData>) => Promise<Types.AgentManaged138>;
+        list: (options?: import("./core/transport.js").CallOptions<Types.EnvironmentsListData> | undefined) => Promise<{
+            data: Array<Types.AgentManaged138>;
+            next_page: string | null;
+        }>;
+        retrieve: (options: import("./core/transport.js").CallOptions<Types.EnvironmentsRetrieveData>) => Promise<Types.AgentManaged138>;
+        update: (options: import("./core/transport.js").CallOptions<Types.EnvironmentsUpdateData>) => Promise<Types.AgentManaged138>;
+    };
+    sessions: {
+        archive: (options: import("./core/transport.js").CallOptions<Types.SessionsArchiveData>) => Promise<{
+            id: string;
+            agent: {
+                id: string;
+                description: null | string;
+                mcp_servers: Array<Types.AgentManaged36>;
+                model: {
+                    id: "claude-opus-5-5" | "claude-fable-5-1" | "claude-sonnet-5" | "claude-fable-5" | "claude-opus-5" | "claude-opus-4-8" | "claude-opus-4-7" | "claude-opus-4-6" | "claude-sonnet-4-6" | "claude-haiku-4-5" | "claude-haiku-4-5-20251001" | "claude-opus-4-5" | "claude-opus-4-5-20251101" | "claude-sonnet-4-5" | "claude-sonnet-4-5-20250929" | string;
+                    effort?: Types.AgentManaged2 | Types.AgentManaged3 | Types.AgentManaged4 | Types.AgentManaged5 | Types.AgentManaged6;
+                    inference_geo?: string;
+                    speed?: "standard" | "fast";
+                    settings?: {
+                        reasoning?: "low" | "medium" | "high" | "xhigh" | "max" | "none";
+                    };
+                };
+                multiagent: null | Types.AgentManaged171;
+                name: string;
+                skills: Array<Types.AgentManaged42 | Types.AgentManaged43>;
+                system: null | string;
+                tools: Array<Types.AgentManaged44 | Types.AgentManaged54 | Types.AgentManaged57>;
+                type: "agent";
+                version: number;
+            };
+            archived_at: null | string;
+            budget: null | Types.AgentManaged76;
+            created_at: string;
+            environment_id?: string;
+            metadata: Types.AgentManaged173;
+            outcome_evaluations: Array<Types.AgentManaged174>;
+            resources: Array<Types.AgentManaged175 | Types.AgentManaged176 | Types.AgentManaged177>;
+            stats: Types.AgentManaged178;
+            status: "rescheduling" | "running" | "idle" | "terminated";
+            title: null | string;
+            type: "session";
+            updated_at: string;
+            usage: Types.AgentManaged179;
+            vault_ids: Array<string>;
+            deployment_id?: null | string;
+            cwd: string;
+            computer_id?: string;
+            model?: {
+                id: string;
+                thinking: {
+                    efforts: Array<"low" | "medium" | "high" | "xhigh" | "max">;
+                    can_disable: boolean;
+                    default_effort: "low" | "medium" | "high" | "xhigh" | "max" | null;
+                } | null;
+            };
+            thinking?: {
+                effort: "low" | "medium" | "high" | "xhigh" | "max" | "none";
+            } | null;
+            forked_from?: {
+                session_id: string;
+                message_id: string;
+            } | null;
+            readonly external_user_id: string | null;
+            readonly source: "kit" | "iframe" | "hosted" | "api" | "automation" | null;
+        }>;
+        backgroundTasks: {
+            list: (options: import("./core/transport.js").CallOptions<Types.ListSessionBackgroundTasksData>) => Promise<{
+                data: Array<{
+                    id: string;
+                    kind: string;
+                    title: string;
+                    thread_id: string | null;
+                    status: "running" | "result_pending" | "completed" | "failed" | "cancelled" | "lost";
+                    started_at: string;
+                    ended_at: string | null;
+                    cancellable: boolean;
+                    notified_at: string | null;
+                    trigger_count: number | null;
+                }>;
+            }>;
+            retrieveOutput: (options: import("./core/transport.js").CallOptions<Types.GetSessionBackgroundTaskOutputData>) => Promise<{
+                text: string;
+                next_offset: number;
+                eof: boolean;
+                unavailable?: true;
+            }>;
+            stop: (options: import("./core/transport.js").CallOptions<Types.StopSessionBackgroundTaskData>) => Promise<{
+                id: string;
+                kind: string;
+                title: string;
+                thread_id: string | null;
+                status: "running" | "result_pending" | "completed" | "failed" | "cancelled" | "lost";
+                started_at: string;
+                ended_at: string | null;
+                cancellable: boolean;
+                notified_at: string | null;
+                trigger_count: number | null;
+            }>;
+        };
+        compact: (options: import("./core/transport.js").CallOptions<Types.CompactSessionData>) => Promise<{
+            type: "session_compaction";
+            id: string;
+            status: "queued" | "running" | "skipped" | "succeeded" | "failed";
+            reason?: string;
+        } | {
+            type: "session_compaction";
+            id: string;
+            status: "queued" | "running" | "skipped" | "succeeded" | "failed";
+            reason?: string;
+        }>;
+        compactions: {
+            list: (options: import("./core/transport.js").CallOptions<Types.ListSessionCompactionsData>) => Promise<{
+                data: Array<{
+                    type: "context_compaction";
+                    id: string;
+                    event_id: string | null;
+                    trigger: "auto" | "manual" | "model_downshift";
+                    status: "succeeded" | "failed";
+                    model: string;
+                    compacted_message_count: number;
+                    input_tokens_before: number;
+                    input_tokens_after: number | null;
+                    summary: string | null;
+                    error: string | null;
+                    created_at: string;
+                }>;
+            }>;
+        };
+        create: (options: import("./core/transport.js").CallOptions<Types.SessionsCreateData>) => Promise<{
+            id: string;
+            agent: {
+                id: string;
+                description: null | string;
+                mcp_servers: Array<Types.AgentManaged36>;
+                model: {
+                    id: "claude-opus-5-5" | "claude-fable-5-1" | "claude-sonnet-5" | "claude-fable-5" | "claude-opus-5" | "claude-opus-4-8" | "claude-opus-4-7" | "claude-opus-4-6" | "claude-sonnet-4-6" | "claude-haiku-4-5" | "claude-haiku-4-5-20251001" | "claude-opus-4-5" | "claude-opus-4-5-20251101" | "claude-sonnet-4-5" | "claude-sonnet-4-5-20250929" | string;
+                    effort?: Types.AgentManaged2 | Types.AgentManaged3 | Types.AgentManaged4 | Types.AgentManaged5 | Types.AgentManaged6;
+                    inference_geo?: string;
+                    speed?: "standard" | "fast";
+                    settings?: {
+                        reasoning?: "low" | "medium" | "high" | "xhigh" | "max" | "none";
+                    };
+                };
+                multiagent: null | Types.AgentManaged171;
+                name: string;
+                skills: Array<Types.AgentManaged42 | Types.AgentManaged43>;
+                system: null | string;
+                tools: Array<Types.AgentManaged44 | Types.AgentManaged54 | Types.AgentManaged57>;
+                type: "agent";
+                version: number;
+            };
+            archived_at: null | string;
+            budget: null | Types.AgentManaged76;
+            created_at: string;
+            environment_id?: string;
+            metadata: Types.AgentManaged173;
+            outcome_evaluations: Array<Types.AgentManaged174>;
+            resources: Array<Types.AgentManaged175 | Types.AgentManaged176 | Types.AgentManaged177>;
+            stats: Types.AgentManaged178;
+            status: "rescheduling" | "running" | "idle" | "terminated";
+            title: null | string;
+            type: "session";
+            updated_at: string;
+            usage: Types.AgentManaged179;
+            vault_ids: Array<string>;
+            deployment_id?: null | string;
+            cwd: string;
+            computer_id?: string;
+            model?: {
+                id: string;
+                thinking: {
+                    efforts: Array<"low" | "medium" | "high" | "xhigh" | "max">;
+                    can_disable: boolean;
+                    default_effort: "low" | "medium" | "high" | "xhigh" | "max" | null;
+                } | null;
+            };
+            thinking?: {
+                effort: "low" | "medium" | "high" | "xhigh" | "max" | "none";
+            } | null;
+            forked_from?: {
+                session_id: string;
+                message_id: string;
+            } | null;
+            readonly external_user_id: string | null;
+            readonly source: "kit" | "iframe" | "hosted" | "api" | "automation" | null;
+        }>;
+        events: {
+            list: (options: import("./core/transport.js").CallOptions<Types.SessionsEventsListData>) => Promise<{
+                data: Array<{
+                    id: string;
+                    content: Array<Types.AgentManaged60 | Types.AgentManaged61 | Types.AgentManaged65 | Types.AgentManaged70>;
+                    type: "user.message";
+                    processed_at?: null | string;
+                    praxis_context?: {
+                        items: Array<{
+                            name: string;
+                            value: string;
+                        }>;
+                    };
+                    message_id?: string;
+                } | Types.AgentManaged186 | Types.AgentManaged187 | Types.AgentManaged188 | Types.AgentManaged192 | {
+                    id: string;
+                    content: Array<{
+                        text: string;
+                        type: "text";
+                        citations?: Array<{
+                            type: "search_result_location";
+                            source: string;
+                            title: string;
+                            cited_text: string;
+                            search_result_index: number;
+                            start_block_index: number;
+                            end_block_index: number;
+                        }>;
+                    } | Types.AgentManaged70>;
+                    processed_at: string;
+                    type: "agent.message";
+                    run_id: string | null;
+                    message_id?: string;
+                } | {
+                    id: string;
+                    processed_at: string;
+                    type: "agent.thinking";
+                    run_id: string | null;
+                    message_id?: string;
+                } | {
+                    id: string;
+                    input: Types.AgentManaged197;
+                    mcp_server_name: string;
+                    name: string;
+                    processed_at: string;
+                    type: "agent.mcp_tool_use";
+                    evaluated_permission?: "allow" | "deny" | "ask";
+                    evaluation?: Types.AgentManaged198 | Types.AgentManaged199 | Types.AgentManaged200;
+                    session_thread_id?: null | string;
+                    run_id: string | null;
+                    _meta?: {
+                        ui?: {
+                            resourceUri?: string;
+                            visibility?: Array<string>;
+                            [key: string]: unknown;
+                        };
+                        "openai/ui"?: {
+                            [key: string]: unknown;
+                        };
+                    };
+                    source?: "app" | "codemode";
+                    parent_tool_use_id?: string;
+                    title?: string;
+                    input_titles?: {
+                        [key: string]: string;
+                    };
+                } | {
+                    id: string;
+                    mcp_tool_use_id: string;
+                    processed_at: string;
+                    type: "agent.mcp_tool_result";
+                    content?: Array<Types.AgentManaged60 | Types.AgentManaged61 | Types.AgentManaged65 | Types.AgentManaged189>;
+                    is_error?: null | false | true;
+                    run_id: string | null;
+                    structured_content?: unknown;
+                    _meta?: {
+                        [key: string]: unknown;
+                    };
+                    source?: "app" | "codemode";
+                } | {
+                    id: string;
+                    input: Types.AgentManaged206;
+                    name: string;
+                    processed_at: string;
+                    type: "agent.tool_use";
+                    evaluated_permission?: "allow" | "deny" | "ask";
+                    evaluation?: Types.AgentManaged198 | Types.AgentManaged199 | Types.AgentManaged200;
+                    session_thread_id?: null | string;
+                    run_id: string | null;
+                } | {
+                    id: string;
+                    processed_at: string;
+                    tool_use_id: string;
+                    type: "agent.tool_result";
+                    content?: Array<Types.AgentManaged60 | Types.AgentManaged61 | Types.AgentManaged65 | Types.AgentManaged189>;
+                    is_error?: null | false | true;
+                    run_id: string | null;
+                } | Types.AgentManaged208 | Types.AgentManaged209 | Types.AgentManaged210 | Types.AgentManaged211 | Types.AgentManaged223 | {
+                    id: string;
+                    processed_at: string;
+                    type: "session.status_running";
+                    run_id: string | null;
+                } | {
+                    id: string;
+                    processed_at: string;
+                    stop_reason: Types.AgentManaged226 | Types.AgentManaged227 | Types.AgentManaged228 | Types.AgentManaged229;
+                    type: "session.status_idle";
+                    run_id: string | null;
+                } | Types.AgentManaged230 | Types.AgentManaged231 | Types.AgentManaged232 | Types.AgentManaged233 | Types.AgentManaged235 | Types.AgentManaged236 | Types.AgentManaged237 | Types.AgentManaged238 | Types.AgentManaged239 | Types.AgentManaged240 | Types.AgentManaged241 | Types.AgentManaged242 | Types.AgentManaged243 | Types.AgentManaged244 | {
+                    id: string;
+                    processed_at: string;
+                    type: "session.updated";
+                    agent?: null | Types.AgentManaged170;
+                    budget?: null | Types.AgentManaged76;
+                    metadata?: Types.AgentManaged246;
+                    title?: null | string;
+                    model?: {
+                        id: string;
+                    };
+                } | Types.AgentManaged247 | Types.AgentManaged248 | {
+                    id: string;
+                    type: "session.forked";
+                    processed_at: string;
+                    forked_from_session_id: string;
+                    forked_from_message_id: string;
+                } | {
+                    id: string;
+                    type: "session.goal_changed";
+                    processed_at: string;
+                    action: "set" | "status_updated" | "cleared" | "usage_accounted";
+                    source: "command" | "runtime";
+                    goal: {
+                        goal_id: string;
+                        objective: string;
+                        summary_title: string | null;
+                        status: "active" | "paused" | "budget_limited" | "complete";
+                        token_budget: number | null;
+                        tokens_used: number;
+                        time_used_seconds: number;
+                        iteration: number;
+                        created_at: number;
+                        updated_at: number;
+                    } | null;
+                    previous_goal: {
+                        goal_id: string;
+                        objective: string;
+                        summary_title: string | null;
+                        status: "active" | "paused" | "budget_limited" | "complete";
+                        token_budget: number | null;
+                        tokens_used: number;
+                        time_used_seconds: number;
+                        iteration: number;
+                        created_at: number;
+                        updated_at: number;
+                    } | null;
+                } | {
+                    id: string;
+                    type: "session.goal_verification";
+                    processed_at: string;
+                    status: "started" | "completed" | "failed_closed" | "cancelled";
+                    goal_id: string;
+                    goal_iteration: number;
+                    verification_id: string;
+                    anchor_message_id: string | null;
+                    verification?: {
+                        passed: boolean;
+                        reason: string;
+                        next_action?: string;
+                    };
+                } | {
+                    id: string;
+                    type: "user.steer";
+                    event_id: string;
+                    processed_at: string;
+                } | {
+                    id: string;
+                    type: "user.tool_confirmation";
+                    processed_at: string;
+                    tool_use_id: string;
+                    result: "allow";
+                    answers: {
+                        [key: string]: string;
+                    };
+                    annotations?: {
+                        [key: string]: {
+                            preview?: string;
+                            notes?: string;
+                        };
+                    };
+                }>;
+                next_page: string | null;
+            }>;
+            send: (options: import("./core/transport.js").CallOptions<Types.SessionsEventsSendData>) => Promise<{
+                data?: Array<{
+                    id: string;
+                    content: Array<Types.AgentManaged60 | Types.AgentManaged61 | Types.AgentManaged65 | Types.AgentManaged70>;
+                    type: "user.message";
+                    processed_at?: null | string;
+                    praxis_context?: {
+                        items: Array<{
+                            name: string;
+                            value: string;
+                        }>;
+                    };
+                } | Types.AgentManaged186 | Types.AgentManaged187 | Types.AgentManaged188 | Types.AgentManaged238 | Types.AgentManaged243 | Types.AgentManaged247 | {
+                    id: string;
+                    type: "user.steer";
+                    event_id: string;
+                    processed_at: string;
+                } | {
+                    id: string;
+                    type: "user.tool_confirmation";
+                    processed_at: string;
+                    tool_use_id: string;
+                    result: "allow";
+                    answers: {
+                        [key: string]: string;
+                    };
+                    annotations?: {
+                        [key: string]: {
+                            preview?: string;
+                            notes?: string;
+                        };
+                    };
+                }>;
+            }>;
+            stream: (options: import("./core/transport.js").StreamOptions<Types.SessionsEventsStreamData>) => AsyncIterable<Types.AgentSseEvent>;
+        };
+        fork: (options: import("./core/transport.js").CallOptions<Types.ForkSessionData>) => Promise<{
+            id: string;
+            agent: {
+                id: string;
+                description: null | string;
+                mcp_servers: Array<{
+                    type: "url";
+                    name: string;
+                    url: string;
+                    headers?: {
+                        [key: string]: string;
+                    };
+                    timeout_ms?: number;
+                } | {
+                    type: "sse";
+                    name: string;
+                    url: string;
+                    headers?: {
+                        [key: string]: string;
+                    };
+                    timeout_ms?: number;
+                } | {
+                    type: "stdio";
+                    name: string;
+                    command: string;
+                    args?: Array<string>;
+                    env?: {
+                        [key: string]: string;
+                    };
+                    timeout_ms?: number;
+                }>;
+                model: {
+                    id: "claude-opus-5-5" | "claude-fable-5-1" | "claude-sonnet-5" | "claude-fable-5" | "claude-opus-5" | "claude-opus-4-8" | "claude-opus-4-7" | "claude-opus-4-6" | "claude-sonnet-4-6" | "claude-haiku-4-5" | "claude-haiku-4-5-20251001" | "claude-opus-4-5" | "claude-opus-4-5-20251101" | "claude-sonnet-4-5" | "claude-sonnet-4-5-20250929" | string;
+                    effort?: {
+                        type: "low";
+                    } | {
+                        type: "medium";
+                    } | {
+                        type: "high";
+                    } | {
+                        type: "xhigh";
+                    } | {
+                        type: "max";
+                    };
+                    inference_geo?: string;
+                    speed?: "standard" | "fast";
+                    settings?: {
+                        reasoning?: "low" | "medium" | "high" | "xhigh" | "max" | "none";
+                    };
+                };
+                multiagent: null | {
+                    agents: Array<{
+                        model: string;
+                        type: "advisor";
+                    } | {
+                        id: string;
+                        description: null | string;
+                        mcp_servers: Array<{
+                            type: "url";
+                            name: string;
+                            url: string;
+                            headers?: {
+                                [key: string]: string;
+                            };
+                            timeout_ms?: number;
+                        } | {
+                            type: "sse";
+                            name: string;
+                            url: string;
+                            headers?: {
+                                [key: string]: string;
+                            };
+                            timeout_ms?: number;
+                        } | {
+                            type: "stdio";
+                            name: string;
+                            command: string;
+                            args?: Array<string>;
+                            env?: {
+                                [key: string]: string;
+                            };
+                            timeout_ms?: number;
+                        }>;
+                        model: {
+                            id: "claude-opus-5-5" | "claude-fable-5-1" | "claude-sonnet-5" | "claude-fable-5" | "claude-opus-5" | "claude-opus-4-8" | "claude-opus-4-7" | "claude-opus-4-6" | "claude-sonnet-4-6" | "claude-haiku-4-5" | "claude-haiku-4-5-20251001" | "claude-opus-4-5" | "claude-opus-4-5-20251101" | "claude-sonnet-4-5" | "claude-sonnet-4-5-20250929" | string;
+                            effort?: {
+                                type: "low";
+                            } | {
+                                type: "medium";
+                            } | {
+                                type: "high";
+                            } | {
+                                type: "xhigh";
+                            } | {
+                                type: "max";
+                            };
+                            inference_geo?: string;
+                            speed?: "standard" | "fast";
+                        };
+                        name: string;
+                        skills: Array<{
+                            skill_id: string;
+                            type: "anthropic";
+                            version: string;
+                        } | {
+                            skill_id: string;
+                            type: "custom";
+                            version: string;
+                        }>;
+                        system: null | string;
+                        tools: Array<{
+                            configs: Array<{
+                                enabled: boolean;
+                                name: "bash";
+                                permission_policy: {
+                                    type: "always_allow";
+                                } | {
+                                    type: "always_ask";
+                                } | {
+                                    type: "auto";
+                                };
+                                type: "bash";
+                            } | {
+                                enabled: boolean;
+                                name: "edit";
+                                permission_policy: {
+                                    type: "always_allow";
+                                } | {
+                                    type: "always_ask";
+                                } | {
+                                    type: "auto";
+                                };
+                                type: "edit";
+                            } | {
+                                enabled: boolean;
+                                name: "read";
+                                permission_policy: {
+                                    type: "always_allow";
+                                } | {
+                                    type: "always_ask";
+                                } | {
+                                    type: "auto";
+                                };
+                                type: "read";
+                            } | {
+                                enabled: boolean;
+                                name: "write";
+                                permission_policy: {
+                                    type: "always_allow";
+                                } | {
+                                    type: "always_ask";
+                                } | {
+                                    type: "auto";
+                                };
+                                type: "write";
+                            } | {
+                                enabled: boolean;
+                                name: "glob";
+                                permission_policy: {
+                                    type: "always_allow";
+                                } | {
+                                    type: "always_ask";
+                                } | {
+                                    type: "auto";
+                                };
+                                type: "glob";
+                            } | {
+                                enabled: boolean;
+                                name: "grep";
+                                permission_policy: {
+                                    type: "always_allow";
+                                } | {
+                                    type: "always_ask";
+                                } | {
+                                    type: "auto";
+                                };
+                                type: "grep";
+                            } | {
+                                enabled: boolean;
+                                name: "web_fetch";
+                                permission_policy: {
+                                    type: "always_allow";
+                                } | {
+                                    type: "always_ask";
+                                } | {
+                                    type: "auto";
+                                };
+                                type: "web_fetch";
+                                allowed_domains?: Array<string>;
+                                blocked_domains?: Array<string>;
+                                max_content_tokens?: null | number;
+                            } | {
+                                enabled: boolean;
+                                name: "web_search";
+                                permission_policy: {
+                                    type: "always_allow";
+                                } | {
+                                    type: "always_ask";
+                                } | {
+                                    type: "auto";
+                                };
+                                type: "web_search";
+                                allowed_domains?: Array<string>;
+                                blocked_domains?: Array<string>;
+                                user_location?: null | {
+                                    type: "approximate";
+                                    city?: null | string;
+                                    country?: null | string;
+                                    region?: null | string;
+                                    timezone?: null | string;
+                                };
+                            } | {
+                                name: "task_output" | "task_stop" | "monitor" | "agent" | "send_message" | "codemode" | "skill";
+                                enabled: boolean;
+                                permission_policy: {
+                                    type: "always_allow" | "always_ask";
+                                };
+                            }>;
+                            default_config: {
+                                enabled: boolean;
+                                permission_policy: {
+                                    type: "always_allow";
+                                } | {
+                                    type: "always_ask";
+                                } | {
+                                    type: "auto";
+                                };
+                            };
+                            type: "agent_toolset_20260401";
+                        } | {
+                            type: "mcp_toolset";
+                            mcp_server_name: string;
+                            default_config?: {
+                                enabled?: boolean | null;
+                                permission_policy?: null | {
+                                    type: "always_allow" | "always_ask";
+                                };
+                            } | null;
+                            configs?: Array<{
+                                name: string;
+                                enabled?: boolean | null;
+                                permission_policy?: null | {
+                                    type: "always_allow" | "always_ask";
+                                };
+                            }> | null;
+                        } | {
+                            description: string;
+                            input_schema: {
+                                type: "object";
+                                properties?: null | {
+                                    [key: string]: unknown;
+                                };
+                                required?: null | Array<string>;
+                                [key: string]: unknown;
+                            };
+                            name: string;
+                            type: "custom";
+                        }>;
+                        type: "agent";
+                        version: number;
+                    }>;
+                    type: "coordinator";
+                };
+                name: string;
+                skills: Array<{
+                    skill_id: string;
+                    type: "anthropic";
+                    version: string;
+                } | {
+                    skill_id: string;
+                    type: "custom";
+                    version: string;
+                }>;
+                system: null | string;
+                tools: Array<{
+                    configs: Array<{
+                        enabled: boolean;
+                        name: "bash";
+                        permission_policy: {
+                            type: "always_allow";
+                        } | {
+                            type: "always_ask";
+                        } | {
+                            type: "auto";
+                        };
+                        type: "bash";
+                    } | {
+                        enabled: boolean;
+                        name: "edit";
+                        permission_policy: {
+                            type: "always_allow";
+                        } | {
+                            type: "always_ask";
+                        } | {
+                            type: "auto";
+                        };
+                        type: "edit";
+                    } | {
+                        enabled: boolean;
+                        name: "read";
+                        permission_policy: {
+                            type: "always_allow";
+                        } | {
+                            type: "always_ask";
+                        } | {
+                            type: "auto";
+                        };
+                        type: "read";
+                    } | {
+                        enabled: boolean;
+                        name: "write";
+                        permission_policy: {
+                            type: "always_allow";
+                        } | {
+                            type: "always_ask";
+                        } | {
+                            type: "auto";
+                        };
+                        type: "write";
+                    } | {
+                        enabled: boolean;
+                        name: "glob";
+                        permission_policy: {
+                            type: "always_allow";
+                        } | {
+                            type: "always_ask";
+                        } | {
+                            type: "auto";
+                        };
+                        type: "glob";
+                    } | {
+                        enabled: boolean;
+                        name: "grep";
+                        permission_policy: {
+                            type: "always_allow";
+                        } | {
+                            type: "always_ask";
+                        } | {
+                            type: "auto";
+                        };
+                        type: "grep";
+                    } | {
+                        enabled: boolean;
+                        name: "web_fetch";
+                        permission_policy: {
+                            type: "always_allow";
+                        } | {
+                            type: "always_ask";
+                        } | {
+                            type: "auto";
+                        };
+                        type: "web_fetch";
+                        allowed_domains?: Array<string>;
+                        blocked_domains?: Array<string>;
+                        max_content_tokens?: null | number;
+                    } | {
+                        enabled: boolean;
+                        name: "web_search";
+                        permission_policy: {
+                            type: "always_allow";
+                        } | {
+                            type: "always_ask";
+                        } | {
+                            type: "auto";
+                        };
+                        type: "web_search";
+                        allowed_domains?: Array<string>;
+                        blocked_domains?: Array<string>;
+                        user_location?: null | {
+                            type: "approximate";
+                            city?: null | string;
+                            country?: null | string;
+                            region?: null | string;
+                            timezone?: null | string;
+                        };
+                    } | {
+                        name: "task_output" | "task_stop" | "monitor" | "agent" | "send_message" | "codemode" | "skill";
+                        enabled: boolean;
+                        permission_policy: {
+                            type: "always_allow" | "always_ask";
+                        };
+                    }>;
+                    default_config: {
+                        enabled: boolean;
+                        permission_policy: {
+                            type: "always_allow";
+                        } | {
+                            type: "always_ask";
+                        } | {
+                            type: "auto";
+                        };
+                    };
+                    type: "agent_toolset_20260401";
+                } | {
+                    type: "mcp_toolset";
+                    mcp_server_name: string;
+                    default_config?: {
+                        enabled?: boolean | null;
+                        permission_policy?: null | {
+                            type: "always_allow" | "always_ask";
+                        };
+                    } | null;
+                    configs?: Array<{
+                        name: string;
+                        enabled?: boolean | null;
+                        permission_policy?: null | {
+                            type: "always_allow" | "always_ask";
+                        };
+                    }> | null;
+                } | {
+                    description: string;
+                    input_schema: {
+                        type: "object";
+                        properties?: null | {
+                            [key: string]: unknown;
+                        };
+                        required?: null | Array<string>;
+                        [key: string]: unknown;
+                    };
+                    name: string;
+                    type: "custom";
+                }>;
+                type: "agent";
+                version: number;
+            };
+            archived_at: null | string;
+            budget: null | {
+                max_list_cost: {
+                    amount: string;
+                    currency: "USD";
+                };
+                type: "limit";
+            };
+            created_at: string;
+            environment_id?: string;
+            metadata: {
+                [key: string]: string;
+            };
+            outcome_evaluations: Array<{
+                completed_at: null | string;
+                description: string;
+                explanation: null | string;
+                iteration: number;
+                outcome_id: string;
+                result: string;
+                type: "outcome_evaluation";
+            }>;
+            resources: Array<{
+                id: string;
+                created_at: string;
+                mount_path: string;
+                type: "github_repository";
+                updated_at: string;
+                url: string;
+                checkout?: null | {
+                    name: string;
+                    type: "branch";
+                } | {
+                    sha: string;
+                    type: "commit";
+                };
+            } | {
+                id: string;
+                created_at: string;
+                file_id: string;
+                mount_path: string;
+                type: "file";
+                updated_at: string;
+            } | {
+                memory_store_id: string;
+                type: "memory_store";
+                access?: null | "read_write" | "read_only";
+                description?: string;
+                instructions?: null | string;
+                mount_path?: null | string;
+                name?: null | string;
+            }>;
+            stats: {
+                active_seconds?: number;
+                duration_seconds?: number;
+            };
+            status: "rescheduling" | "running" | "idle" | "terminated";
+            title: null | string;
+            type: "session";
+            updated_at: string;
+            usage: {
+                active_seconds?: number;
+                cache_creation?: {
+                    ephemeral_1h_input_tokens?: number;
+                    ephemeral_5m_input_tokens?: number;
+                };
+                cache_read_input_tokens?: number;
+                input_tokens?: number;
+                list_cost?: null | {
+                    amount: string;
+                    currency: "USD";
+                };
+                output_tokens?: number;
+                server_tool_use?: null | {
+                    web_fetch_requests?: number;
+                    web_search_requests?: number;
+                };
+            };
+            vault_ids: Array<string>;
+            deployment_id?: null | string;
+            cwd: string;
+            computer_id?: string;
+            model?: {
+                id: string;
+                thinking: {
+                    efforts: Array<"low" | "medium" | "high" | "xhigh" | "max">;
+                    can_disable: boolean;
+                    default_effort: "low" | "medium" | "high" | "xhigh" | "max" | null;
+                } | null;
+            };
+            thinking?: {
+                effort: "low" | "medium" | "high" | "xhigh" | "max" | "none";
+            } | null;
+            forked_from?: {
+                session_id: string;
+                message_id: string;
+            } | null;
+            readonly external_user_id: string | null;
+            readonly source: "kit" | "iframe" | "hosted" | "api" | "automation" | null;
+        }>;
+        list: (options?: import("./core/transport.js").CallOptions<Types.SessionsListData> | undefined) => Promise<{
+            data: Array<{
+                id: string;
+                agent: {
+                    id: string;
+                    description: null | string;
+                    mcp_servers: Array<Types.AgentManaged36>;
+                    model: {
+                        id: "claude-opus-5-5" | "claude-fable-5-1" | "claude-sonnet-5" | "claude-fable-5" | "claude-opus-5" | "claude-opus-4-8" | "claude-opus-4-7" | "claude-opus-4-6" | "claude-sonnet-4-6" | "claude-haiku-4-5" | "claude-haiku-4-5-20251001" | "claude-opus-4-5" | "claude-opus-4-5-20251101" | "claude-sonnet-4-5" | "claude-sonnet-4-5-20250929" | string;
+                        effort?: Types.AgentManaged2 | Types.AgentManaged3 | Types.AgentManaged4 | Types.AgentManaged5 | Types.AgentManaged6;
+                        inference_geo?: string;
+                        speed?: "standard" | "fast";
+                        settings?: {
+                            reasoning?: "low" | "medium" | "high" | "xhigh" | "max" | "none";
+                        };
+                    };
+                    multiagent: null | Types.AgentManaged171;
+                    name: string;
+                    skills: Array<Types.AgentManaged42 | Types.AgentManaged43>;
+                    system: null | string;
+                    tools: Array<Types.AgentManaged44 | Types.AgentManaged54 | Types.AgentManaged57>;
+                    type: "agent";
+                    version: number;
+                };
+                archived_at: null | string;
+                budget: null | Types.AgentManaged76;
+                created_at: string;
+                environment_id?: string;
+                metadata: Types.AgentManaged173;
+                outcome_evaluations: Array<Types.AgentManaged174>;
+                resources: Array<Types.AgentManaged175 | Types.AgentManaged176 | Types.AgentManaged177>;
+                stats: Types.AgentManaged178;
+                status: "rescheduling" | "running" | "idle" | "terminated";
+                title: null | string;
+                type: "session";
+                updated_at: string;
+                usage: Types.AgentManaged179;
+                vault_ids: Array<string>;
+                deployment_id?: null | string;
+                cwd: string;
+                computer_id?: string;
+                model?: {
+                    id: string;
+                    thinking: {
+                        efforts: Array<"low" | "medium" | "high" | "xhigh" | "max">;
+                        can_disable: boolean;
+                        default_effort: "low" | "medium" | "high" | "xhigh" | "max" | null;
+                    } | null;
+                };
+                thinking?: {
+                    effort: "low" | "medium" | "high" | "xhigh" | "max" | "none";
+                } | null;
+                forked_from?: {
+                    session_id: string;
+                    message_id: string;
+                } | null;
+                readonly external_user_id: string | null;
+                readonly source: "kit" | "iframe" | "hosted" | "api" | "automation" | null;
+            }>;
+            next_page: string | null;
+        }>;
+        resources: {
+            create: (options: import("./core/transport.js").CallOptions<Types.SessionsResourcesAddData>) => Promise<Types.AgentManaged176>;
+            delete: (options: import("./core/transport.js").CallOptions<RenameParameters<Types.SessionsResourcesDeleteData, {
+                query: {
+                    "session_id": "query_session_id";
+                };
+            }>>) => Promise<Types.AgentManaged255>;
+            list: (options: import("./core/transport.js").CallOptions<Types.SessionsResourcesListData>) => Promise<{
+                data: Array<Types.AgentManaged175 | Types.AgentManaged176 | Types.AgentManaged177>;
+                next_page: string | null;
+            }>;
+            retrieve: (options: import("./core/transport.js").CallOptions<RenameParameters<Types.SessionsResourcesRetrieveData, {
+                query: {
+                    "session_id": "query_session_id";
+                };
+            }>>) => Promise<Types.AgentManaged175 | Types.AgentManaged176 | Types.AgentManaged177>;
+        };
+        retrieve: (options: import("./core/transport.js").CallOptions<Types.SessionsRetrieveData>) => Promise<{
+            id: string;
+            agent: {
+                id: string;
+                description: null | string;
+                mcp_servers: Array<Types.AgentManaged36>;
+                model: {
+                    id: "claude-opus-5-5" | "claude-fable-5-1" | "claude-sonnet-5" | "claude-fable-5" | "claude-opus-5" | "claude-opus-4-8" | "claude-opus-4-7" | "claude-opus-4-6" | "claude-sonnet-4-6" | "claude-haiku-4-5" | "claude-haiku-4-5-20251001" | "claude-opus-4-5" | "claude-opus-4-5-20251101" | "claude-sonnet-4-5" | "claude-sonnet-4-5-20250929" | string;
+                    effort?: Types.AgentManaged2 | Types.AgentManaged3 | Types.AgentManaged4 | Types.AgentManaged5 | Types.AgentManaged6;
+                    inference_geo?: string;
+                    speed?: "standard" | "fast";
+                    settings?: {
+                        reasoning?: "low" | "medium" | "high" | "xhigh" | "max" | "none";
+                    };
+                };
+                multiagent: null | Types.AgentManaged171;
+                name: string;
+                skills: Array<Types.AgentManaged42 | Types.AgentManaged43>;
+                system: null | string;
+                tools: Array<Types.AgentManaged44 | Types.AgentManaged54 | Types.AgentManaged57>;
+                type: "agent";
+                version: number;
+            };
+            archived_at: null | string;
+            budget: null | Types.AgentManaged76;
+            created_at: string;
+            environment_id?: string;
+            metadata: Types.AgentManaged173;
+            outcome_evaluations: Array<Types.AgentManaged174>;
+            resources: Array<Types.AgentManaged175 | Types.AgentManaged176 | Types.AgentManaged177>;
+            stats: Types.AgentManaged178;
+            status: "rescheduling" | "running" | "idle" | "terminated";
+            title: null | string;
+            type: "session";
+            updated_at: string;
+            usage: Types.AgentManaged179;
+            vault_ids: Array<string>;
+            deployment_id?: null | string;
+            cwd: string;
+            computer_id?: string;
+            model?: {
+                id: string;
+                thinking: {
+                    efforts: Array<"low" | "medium" | "high" | "xhigh" | "max">;
+                    can_disable: boolean;
+                    default_effort: "low" | "medium" | "high" | "xhigh" | "max" | null;
+                } | null;
+            };
+            thinking?: {
+                effort: "low" | "medium" | "high" | "xhigh" | "max" | "none";
+            } | null;
+            forked_from?: {
+                session_id: string;
+                message_id: string;
+            } | null;
+            readonly external_user_id: string | null;
+            readonly source: "kit" | "iframe" | "hosted" | "api" | "automation" | null;
+        }>;
+        retrieveCompact: (options: import("./core/transport.js").CallOptions<Types.GetSessionCompactionData>) => Promise<{
+            type: "session_compaction";
+            id: string;
+            status: "queued" | "running" | "skipped" | "succeeded" | "failed";
+            reason?: string;
+        }>;
+        retrieveContext: (options: import("./core/transport.js").CallOptions<Types.GetSessionContextData>) => Promise<{
+            type: "session_context";
+            session_id: string;
+            model: {
+                id: string;
+                display_name: string;
+                thinking: {
+                    efforts: Array<"low" | "medium" | "high" | "xhigh" | "max">;
+                    can_disable: boolean;
+                    default_effort: "low" | "medium" | "high" | "xhigh" | "max" | null;
+                } | null;
+            };
+            total_tokens: number | null;
+            total_tokens_source: "actual" | "estimated" | null;
+            max_tokens: number | null;
+            max_input_tokens: number | null;
+            percentage: number;
+            auto_compact_threshold: number | null;
+            is_auto_compact_enabled: boolean;
+            clear_tool_results_at: number;
+            detail: "summary";
+            categories: Array<{
+                key: string;
+                name: string;
+                tokens: number;
+                kind: "used" | "free" | "buffer" | "deferred";
+            }>;
+            mcp_tools: Array<{
+                name: string;
+                server_name: string;
+                tokens: number;
+            }>;
+            plugin_blocks: Array<{
+                name: string;
+                tokens: number;
+            }>;
+            message_breakdown: {
+                user_message_tokens: number;
+                assistant_message_tokens: number;
+                tool_call_tokens: number;
+                tool_result_tokens: number;
+                reasoning_tokens: number;
+                tool_calls_by_type: Array<{
+                    name: string;
+                    call_tokens: number;
+                    result_tokens: number;
+                }>;
+            };
+            compaction_summary: {
+                tokens: number;
+            } | null;
+            excluded_items: {
+                count: number;
+                tokens: number;
+            };
+            measured_at: string | null;
+        }>;
+        runs: {
+            deleteFeedback: (options: import("./core/transport.js").CallOptions<Types.DeleteRunFeedbackData>) => Promise<void>;
+            feedback: {
+                create: (options: import("./core/transport.js").CallOptions<Types.SetRunFeedbackData>) => Promise<{
+                    type: "run_feedback";
+                    session_id: string;
+                    run_id: string;
+                    rating: "positive" | "negative";
+                    comment: string | null;
+                    created_at: string;
+                    updated_at: string;
+                }>;
+            };
+        };
+        threads: {
+            archive: (options: import("./core/transport.js").CallOptions<RenameParameters<Types.SessionsThreadsArchiveData, {
+                query: {
+                    "session_id": "query_session_id";
+                };
+            }>>) => Promise<Types.AgentManaged256>;
+            events: {
+                list: (options: import("./core/transport.js").CallOptions<RenameParameters<Types.SessionsThreadsEventsListData, {
+                    query: {
+                        "session_id": "query_session_id";
+                    };
+                }>>) => Promise<{
+                    data: Array<{
+                        id: string;
+                        content: Array<Types.AgentManaged60 | Types.AgentManaged61 | Types.AgentManaged65 | Types.AgentManaged70>;
+                        type: "user.message";
+                        processed_at?: null | string;
+                        praxis_context?: {
+                            items: Array<{
+                                name: string;
+                                value: string;
+                            }>;
+                        };
+                        message_id?: string;
+                    } | Types.AgentManaged186 | Types.AgentManaged187 | Types.AgentManaged188 | Types.AgentManaged192 | {
+                        id: string;
+                        content: Array<{
+                            text: string;
+                            type: "text";
+                            citations?: Array<{
+                                type: "search_result_location";
+                                source: string;
+                                title: string;
+                                cited_text: string;
+                                search_result_index: number;
+                                start_block_index: number;
+                                end_block_index: number;
+                            }>;
+                        } | Types.AgentManaged70>;
+                        processed_at: string;
+                        type: "agent.message";
+                        run_id: string | null;
+                        message_id?: string;
+                    } | {
+                        id: string;
+                        processed_at: string;
+                        type: "agent.thinking";
+                        run_id: string | null;
+                        message_id?: string;
+                    } | {
+                        id: string;
+                        input: Types.AgentManaged197;
+                        mcp_server_name: string;
+                        name: string;
+                        processed_at: string;
+                        type: "agent.mcp_tool_use";
+                        evaluated_permission?: "allow" | "deny" | "ask";
+                        evaluation?: Types.AgentManaged198 | Types.AgentManaged199 | Types.AgentManaged200;
+                        session_thread_id?: null | string;
+                        run_id: string | null;
+                        parent_tool_use_id?: string;
+                        _meta?: {
+                            ui?: {
+                                resourceUri?: string;
+                                visibility?: Array<string>;
+                                [key: string]: unknown;
+                            };
+                            "openai/ui"?: {
+                                [key: string]: unknown;
+                            };
+                        };
+                        source?: "app" | "codemode";
+                        title?: string;
+                        input_titles?: {
+                            [key: string]: string;
+                        };
+                    } | {
+                        id: string;
+                        mcp_tool_use_id: string;
+                        processed_at: string;
+                        type: "agent.mcp_tool_result";
+                        content?: Array<Types.AgentManaged60 | Types.AgentManaged61 | Types.AgentManaged65 | Types.AgentManaged189>;
+                        is_error?: null | false | true;
+                        run_id: string | null;
+                        structured_content?: unknown;
+                        _meta?: {
+                            [key: string]: unknown;
+                        };
+                        source?: "app" | "codemode";
+                    } | {
+                        id: string;
+                        input: Types.AgentManaged206;
+                        name: string;
+                        processed_at: string;
+                        type: "agent.tool_use";
+                        evaluated_permission?: "allow" | "deny" | "ask";
+                        evaluation?: Types.AgentManaged198 | Types.AgentManaged199 | Types.AgentManaged200;
+                        session_thread_id?: null | string;
+                        run_id: string | null;
+                    } | {
+                        id: string;
+                        processed_at: string;
+                        tool_use_id: string;
+                        type: "agent.tool_result";
+                        content?: Array<Types.AgentManaged60 | Types.AgentManaged61 | Types.AgentManaged65 | Types.AgentManaged189>;
+                        is_error?: null | false | true;
+                        run_id: string | null;
+                    } | Types.AgentManaged208 | Types.AgentManaged209 | Types.AgentManaged210 | Types.AgentManaged211 | Types.AgentManaged223 | {
+                        id: string;
+                        processed_at: string;
+                        type: "session.status_running";
+                        run_id: string | null;
+                    } | {
+                        id: string;
+                        processed_at: string;
+                        stop_reason: Types.AgentManaged226 | Types.AgentManaged227 | Types.AgentManaged228 | Types.AgentManaged229;
+                        type: "session.status_idle";
+                        run_id: string | null;
+                    } | Types.AgentManaged230 | Types.AgentManaged231 | Types.AgentManaged232 | Types.AgentManaged233 | Types.AgentManaged235 | Types.AgentManaged236 | Types.AgentManaged237 | Types.AgentManaged238 | Types.AgentManaged239 | Types.AgentManaged240 | Types.AgentManaged241 | Types.AgentManaged242 | Types.AgentManaged243 | Types.AgentManaged244 | {
+                        id: string;
+                        processed_at: string;
+                        type: "session.updated";
+                        agent?: null | Types.AgentManaged170;
+                        budget?: null | Types.AgentManaged76;
+                        metadata?: Types.AgentManaged246;
+                        title?: null | string;
+                        model?: {
+                            id: string;
+                        };
+                    } | Types.AgentManaged247 | Types.AgentManaged248 | {
+                        id: string;
+                        type: "session.forked";
+                        processed_at: string;
+                        forked_from_session_id: string;
+                        forked_from_message_id: string;
+                    } | {
+                        id: string;
+                        type: "session.goal_changed";
+                        processed_at: string;
+                        action: "set" | "status_updated" | "cleared" | "usage_accounted";
+                        source: "command" | "runtime";
+                        goal: {
+                            goal_id: string;
+                            objective: string;
+                            summary_title: string | null;
+                            status: "active" | "paused" | "budget_limited" | "complete";
+                            token_budget: number | null;
+                            tokens_used: number;
+                            time_used_seconds: number;
+                            iteration: number;
+                            created_at: number;
+                            updated_at: number;
+                        } | null;
+                        previous_goal: {
+                            goal_id: string;
+                            objective: string;
+                            summary_title: string | null;
+                            status: "active" | "paused" | "budget_limited" | "complete";
+                            token_budget: number | null;
+                            tokens_used: number;
+                            time_used_seconds: number;
+                            iteration: number;
+                            created_at: number;
+                            updated_at: number;
+                        } | null;
+                    } | {
+                        id: string;
+                        type: "session.goal_verification";
+                        processed_at: string;
+                        status: "started" | "completed" | "failed_closed" | "cancelled";
+                        goal_id: string;
+                        goal_iteration: number;
+                        verification_id: string;
+                        anchor_message_id: string | null;
+                        verification?: {
+                            passed: boolean;
+                            reason: string;
+                            next_action?: string;
+                        };
+                    } | {
+                        id: string;
+                        type: "user.steer";
+                        event_id: string;
+                        processed_at: string;
+                    }>;
+                    next_page: string | null;
+                }>;
+            };
+            list: (options: import("./core/transport.js").CallOptions<Types.SessionsThreadsListData>) => Promise<{
+                data: Array<Types.AgentManaged256>;
+                next_page: string | null;
+            }>;
+            retrieve: (options: import("./core/transport.js").CallOptions<RenameParameters<Types.SessionsThreadsRetrieveData, {
+                query: {
+                    "session_id": "query_session_id";
+                };
+            }>>) => Promise<Types.AgentManaged256>;
+            stream: (options: import("./core/transport.js").StreamOptions<RenameParameters<Types.SessionsThreadsEventsStreamData, {
+                query: {
+                    "session_id": "query_session_id";
+                };
+            }>>) => AsyncIterable<Types.AgentSseEvent>;
+        };
+        update: (options: import("./core/transport.js").CallOptions<Types.SessionsUpdateData>) => Promise<{
+            id: string;
+            agent: {
+                id: string;
+                description: null | string;
+                mcp_servers: Array<Types.AgentManaged36>;
+                model: {
+                    id: "claude-opus-5-5" | "claude-fable-5-1" | "claude-sonnet-5" | "claude-fable-5" | "claude-opus-5" | "claude-opus-4-8" | "claude-opus-4-7" | "claude-opus-4-6" | "claude-sonnet-4-6" | "claude-haiku-4-5" | "claude-haiku-4-5-20251001" | "claude-opus-4-5" | "claude-opus-4-5-20251101" | "claude-sonnet-4-5" | "claude-sonnet-4-5-20250929" | string;
+                    effort?: Types.AgentManaged2 | Types.AgentManaged3 | Types.AgentManaged4 | Types.AgentManaged5 | Types.AgentManaged6;
+                    inference_geo?: string;
+                    speed?: "standard" | "fast";
+                    settings?: {
+                        reasoning?: "low" | "medium" | "high" | "xhigh" | "max" | "none";
+                    };
+                };
+                multiagent: null | Types.AgentManaged171;
+                name: string;
+                skills: Array<Types.AgentManaged42 | Types.AgentManaged43>;
+                system: null | string;
+                tools: Array<Types.AgentManaged44 | Types.AgentManaged54 | Types.AgentManaged57>;
+                type: "agent";
+                version: number;
+            };
+            archived_at: null | string;
+            budget: null | Types.AgentManaged76;
+            created_at: string;
+            environment_id?: string;
+            metadata: Types.AgentManaged173;
+            outcome_evaluations: Array<Types.AgentManaged174>;
+            resources: Array<Types.AgentManaged175 | Types.AgentManaged176 | Types.AgentManaged177>;
+            stats: Types.AgentManaged178;
+            status: "rescheduling" | "running" | "idle" | "terminated";
+            title: null | string;
+            type: "session";
+            updated_at: string;
+            usage: Types.AgentManaged179;
+            vault_ids: Array<string>;
+            deployment_id?: null | string;
+            cwd: string;
+            computer_id?: string;
+            model?: {
+                id: string;
+                thinking: {
+                    efforts: Array<"low" | "medium" | "high" | "xhigh" | "max">;
+                    can_disable: boolean;
+                    default_effort: "low" | "medium" | "high" | "xhigh" | "max" | null;
+                } | null;
+            };
+            thinking?: {
+                effort: "low" | "medium" | "high" | "xhigh" | "max" | "none";
+            } | null;
+            forked_from?: {
+                session_id: string;
+                message_id: string;
+            } | null;
+            readonly external_user_id: string | null;
+            readonly source: "kit" | "iframe" | "hosted" | "api" | "automation" | null;
+        }>;
+    };
+    toolsets: {
+        list: (options?: import("./core/transport.js").CallOptions<Types.ListToolsetsData> | undefined) => Promise<{
+            data: Array<{
+                type: string;
+                plugin: {
+                    name: string;
+                    version: string;
+                };
+                description: string;
+                environment: string;
+                tools: Array<{
+                    name: string;
+                    description: string;
+                    input_schema: {
+                        [key: string]: unknown;
+                    };
+                    read_only: boolean;
+                    default_permission_policy: "always_allow" | "always_ask";
+                    mod: string;
+                    configurable: boolean;
+                }>;
+            }>;
+            next_page: null;
+        }>;
+    };
+};
+export declare function createApplication(transport: Transport): {
+    assets: {
+        upload: {
+            create: (options: import("./core/transport.js").CallOptions<Types.ApplicationUploadAssetsData>) => Promise<Types.ApplicationAssetUploadResult>;
+        };
+    };
+    subdomain: {
+        retrieve: (options?: import("./core/transport.js").CallOptions<Types.ApplicationGetSubdomainData> | undefined) => Promise<Types.ApplicationAccountSubdomain>;
+        update: (options: import("./core/transport.js").CallOptions<Types.ApplicationPutSubdomainData>) => Promise<Types.ApplicationAccountSubdomain>;
+    };
+    workers: {
+        assetsUploadSession: {
+            create: (options: import("./core/transport.js").CallOptions<Types.ApplicationCreateAssetUploadSessionData>) => Promise<Types.ApplicationAssetUploadSession>;
+        };
+        components: {
+            list: (options: import("./core/transport.js").CallOptions<Types.ApplicationListComponentsData>) => Promise<Types.ApplicationComponent[]>;
+        };
+        create: (options: import("./core/transport.js").CallOptions<Types.ApplicationCreateWorkerData>) => Promise<Types.ApplicationWorker>;
+        delete: (options: import("./core/transport.js").CallOptions<Types.ApplicationDeleteWorkerData>) => Promise<Types.ApplicationWorker>;
+        deployments: {
+            create: (options: import("./core/transport.js").CallOptions<Types.ApplicationCreateDeploymentData>) => Promise<Types.ApplicationDeployment>;
+            list: (options: import("./core/transport.js").CallOptions<Types.ApplicationListDeploymentsData>) => Promise<import("./automation.js").Page<Types.ApplicationDeployment>>;
+            retrieve: (options: import("./core/transport.js").CallOptions<Types.ApplicationGetDeploymentData>) => Promise<Types.ApplicationDeployment>;
+        };
+        events: {
+            list: (options: import("./core/transport.js").CallOptions<Types.ApplicationListEventsData>) => Promise<Types.ApplicationEventPage>;
+        };
+        grants: {
+            create: (options: import("./core/transport.js").CallOptions<Types.ApplicationCreateGrantData>) => Promise<Types.ApplicationGrant>;
+            delete: (options: import("./core/transport.js").CallOptions<Types.ApplicationDeleteGrantData>) => Promise<{
+                deleted: true;
+            }>;
+            list: (options: import("./core/transport.js").CallOptions<Types.ApplicationListGrantsData>) => Promise<Types.ApplicationGrant[]>;
+        };
+        list: (options?: import("./core/transport.js").CallOptions<Types.ApplicationListWorkersData> | undefined) => Promise<import("./automation.js").Page<Types.ApplicationWorker>>;
+        restore: (options: import("./core/transport.js").CallOptions<Types.ApplicationRestoreWorkerData>) => Promise<Types.ApplicationWorker>;
+        retrieve: (options: import("./core/transport.js").CallOptions<Types.ApplicationGetWorkerData>) => Promise<Types.ApplicationWorkerDetail>;
+        secrets: {
+            delete: (options: import("./core/transport.js").CallOptions<Types.ApplicationDeleteSecretData>) => Promise<{
+                deployment: Types.ApplicationDeployment;
+            }>;
+            list: (options: import("./core/transport.js").CallOptions<Types.ApplicationListSecretsData>) => Promise<Types.ApplicationSecret[]>;
+            update: (options: import("./core/transport.js").CallOptions<Types.ApplicationPutSecretData>) => Promise<Types.ApplicationSecretWriteResult>;
+        };
+        update: (options: import("./core/transport.js").CallOptions<Types.ApplicationUpdateWorkerData>) => Promise<Types.ApplicationWorker>;
+        versions: {
+            create: (options: import("./core/transport.js").CallOptions<Types.ApplicationCreateVersionData>) => Promise<Types.ApplicationCreateVersionResult>;
+            list: (options: import("./core/transport.js").CallOptions<Types.ApplicationListVersionsData>) => Promise<import("./automation.js").Page<Types.ApplicationVersion>>;
+            retrieve: (options: import("./core/transport.js").CallOptions<Types.ApplicationGetVersionData>) => Promise<Types.ApplicationVersion>;
+        };
+    };
+};
+export declare function createAutomation(transport: Transport): {
+    actions: {
+        archive: (options: import("./core/transport.js").CallOptions<Types.AutomationActionsArchiveData>) => Promise<Types.AutomationActionArchiveResult>;
+        create: (options: import("./core/transport.js").CallOptions<Types.AutomationActionsCreateData>) => Promise<Types.AutomationActionDef>;
+        dependents: {
+            list: (options: import("./core/transport.js").CallOptions<Types.AutomationActionsDependentsData>) => Promise<import("./automation.js").Page<Types.AutomationDependent>>;
+        };
+        invocations: {
+            list: (options: import("./core/transport.js").CallOptions<Types.AutomationActionsInvocationsData>) => Promise<import("./automation.js").Page<Types.AutomationInvocation>>;
+        };
+        list: (options?: import("./core/transport.js").CallOptions<Types.AutomationActionsListData> | undefined) => Promise<import("./automation.js").Page<Types.AutomationActionListItem>>;
+        restore: (options: import("./core/transport.js").CallOptions<Types.AutomationActionsRestoreData>) => Promise<Types.AutomationActionDef>;
+        retrieve: (options: import("./core/transport.js").CallOptions<Types.AutomationActionsGetData>) => Promise<Types.AutomationActionDef>;
+        revisions: {
+            list: (options: import("./core/transport.js").CallOptions<Types.AutomationActionsRevisionsData>) => Promise<import("./automation.js").Page<Types.AutomationRevisionSummary>>;
+            retrieve: (options: import("./core/transport.js").CallOptions<Types.AutomationActionsRevisionData>) => Promise<Types.AutomationRevisionListItem>;
+        };
+        rollback: (options: import("./core/transport.js").CallOptions<Types.AutomationActionsRollbackData>) => Promise<Types.AutomationActionDef>;
+        update: (options: import("./core/transport.js").CallOptions<Types.AutomationActionsUpdateData>) => Promise<Types.AutomationActionUpdateResult>;
+    };
+    hooks: {
+        send: (options: import("./core/transport.js").CallOptions<Types.AutomationHooksReceiveData>) => Promise<Types.AutomationFiring>;
+    };
+    resolve: {
+        retrieve: (options: import("./core/transport.js").CallOptions<Types.AutomationResolveResolveData>) => Promise<Types.AutomationResolveResult>;
+    };
+    runs: {
+        artifacts: {
+            list: (options: import("./core/transport.js").CallOptions<Types.AutomationRunsArtifactsData>) => Promise<import("./automation.js").Page<Types.AutomationRunArtifact>>;
+        };
+        calls: {
+            list: (options: import("./core/transport.js").CallOptions<Types.AutomationRunsCallsData>) => Promise<import("./automation.js").Page<Types.AutomationCall>>;
+        };
+        cancel: (options: import("./core/transport.js").CallOptions<Types.AutomationRunsCancelData>) => Promise<Types.AutomationRun>;
+        create: (options: import("./core/transport.js").CallOptions<Types.AutomationRunsCreateData>) => Promise<Types.AutomationRun>;
+        events: (options: import("./core/transport.js").StreamOptions<Types.AutomationRunsEventsData>) => AsyncIterable<Types.PraxisSdkSseGetAutomationV1RunsIdEvents>;
+        list: (options?: import("./core/transport.js").CallOptions<Types.AutomationRunsListData> | undefined) => Promise<import("./automation.js").Page<Types.AutomationRun>>;
+        logs: (options: import("./core/transport.js").StreamOptions<Types.AutomationRunsLogsData>) => AsyncIterable<Types.PraxisSdkSseGetAutomationV1RunsIdLogs>;
+        rerun: (options: import("./core/transport.js").CallOptions<Types.AutomationRunsRerunData>) => Promise<Types.AutomationRun>;
+        resume: (options: import("./core/transport.js").CallOptions<Types.AutomationRunsResumeData>) => Promise<Types.AutomationRun>;
+        retrieve: (options: import("./core/transport.js").CallOptions<Types.AutomationRunsGetData>) => Promise<Types.AutomationExpandedRun>;
+        retrieveSource: (options: import("./core/transport.js").CallOptions<Types.AutomationRunsSourceData>) => Promise<{
+            language: Types.AutomationSourceLanguage;
+            source: string;
+            sha256: string;
+        }>;
+        suspend: (options: import("./core/transport.js").CallOptions<Types.AutomationRunsSuspendData>) => Promise<Types.AutomationRun>;
+        tasks: {
+            list: (options: import("./core/transport.js").CallOptions<Types.AutomationRunsTasksData>) => Promise<import("./automation.js").Page<Types.AutomationTask | Types.AutomationTaskGroup>>;
+        };
+        waits: {
+            complete: (options: import("./core/transport.js").CallOptions<Types.AutomationRunsCompleteWaitData>) => Promise<{
+                id: string;
+                run_id: string;
+                kind: "event" | "timer" | "child";
+                state: "cancelled" | "open" | "resolved" | "expired";
+                task: null | {
+                    reference: string;
+                    name: string;
+                };
+                resume_at: null | string;
+                event_type: null | string;
+                child_run_id: null | string;
+                created_at: string;
+                expires_at: null | string;
+                resolved_at: null | string;
+                replayed: boolean;
+            }>;
+            list: (options: import("./core/transport.js").CallOptions<Types.AutomationRunsWaitsData>) => Promise<import("./automation.js").Page<Types.AutomationWait>>;
+        };
+    };
+    scripts: {
+        archive: (options: import("./core/transport.js").CallOptions<Types.AutomationScriptsArchiveData>) => Promise<Types.AutomationDefinition>;
+        create: (options: import("./core/transport.js").CallOptions<Types.AutomationScriptsCreateData>) => Promise<Types.AutomationDefinitionDetail>;
+        distTags: {
+            delete: (options: import("./core/transport.js").CallOptions<Types.AutomationScriptsDeleteDistTagData>) => Promise<{
+                [key: string]: Types.AutomationDistTag;
+            }>;
+            list: (options: import("./core/transport.js").CallOptions<Types.AutomationScriptsDistTagsData>) => Promise<{
+                [key: string]: Types.AutomationDistTag;
+            }>;
+            set: (options: import("./core/transport.js").CallOptions<Types.AutomationScriptsSetDistTagData>) => Promise<{
+                [key: string]: Types.AutomationDistTag;
+            }>;
+        };
+        list: (options?: import("./core/transport.js").CallOptions<Types.AutomationScriptsListData> | undefined) => Promise<import("./automation.js").Page<Types.AutomationDefinition>>;
+        restore: (options: import("./core/transport.js").CallOptions<Types.AutomationScriptsRestoreData>) => Promise<Types.AutomationDefinition>;
+        retrieve: (options: import("./core/transport.js").CallOptions<Types.AutomationScriptsGetData>) => Promise<Types.AutomationDefinitionDetail>;
+        update: (options: import("./core/transport.js").CallOptions<Types.AutomationScriptsPatchData>) => Promise<Types.AutomationDefinitionDetail>;
+        versions: {
+            create: (options: import("./core/transport.js").CallOptions<Types.AutomationScriptsPublishData>) => Promise<Types.AutomationVersion>;
+            deprecate: (options: import("./core/transport.js").CallOptions<Types.AutomationScriptsDeprecateData>) => Promise<Types.AutomationVersion>;
+            list: (options: import("./core/transport.js").CallOptions<Types.AutomationScriptsVersionsData>) => Promise<import("./automation.js").Page<Types.AutomationVersionListItem>>;
+            publish: (options: import("./core/transport.js").CallOptions<Types.AutomationScriptsPublishData>) => Promise<Types.AutomationVersion>;
+            retrieve: (options: import("./core/transport.js").CallOptions<Types.AutomationScriptsVersionData>) => Promise<Types.AutomationVersion>;
+        };
+    };
+    targets: {
+        list: (options?: import("./core/transport.js").CallOptions<Types.AutomationTargetsTargetsData> | undefined) => Promise<import("./automation.js").Page<Types.AutomationTargetHit>>;
+    };
+    triggers: {
+        create: (options: import("./core/transport.js").CallOptions<Types.AutomationTriggersCreateData>) => Promise<Types.AutomationTriggerCreateResult>;
+        delete: (options: import("./core/transport.js").CallOptions<Types.AutomationTriggersDeleteData>) => Promise<void>;
+        fire: (options: import("./core/transport.js").CallOptions<Types.AutomationTriggersFireData>) => Promise<Types.AutomationFiring>;
+        firings: {
+            list: (options: import("./core/transport.js").CallOptions<Types.AutomationTriggersFiringsData>) => Promise<import("./automation.js").Page<Types.AutomationFiring>>;
+        };
+        list: (options?: import("./core/transport.js").CallOptions<Types.AutomationTriggersListData> | undefined) => Promise<import("./automation.js").Page<Types.AutomationTrigger>>;
+        pause: (options: import("./core/transport.js").CallOptions<Types.AutomationTriggersPauseData>) => Promise<Types.AutomationTrigger>;
+        preview: (options: import("./core/transport.js").CallOptions<Types.AutomationTriggersPreviewData>) => Promise<Types.AutomationTriggerPreview>;
+        resume: (options: import("./core/transport.js").CallOptions<Types.AutomationTriggersResumeData>) => Promise<Types.AutomationTrigger>;
+        retrieve: (options: import("./core/transport.js").CallOptions<Types.AutomationTriggersGetData>) => Promise<Types.AutomationTrigger>;
+        rotateWebhook: (options: import("./core/transport.js").CallOptions<Types.AutomationTriggersRotateWebhookData>) => Promise<Types.AutomationWebhookUrl>;
+        update: (options: import("./core/transport.js").CallOptions<Types.AutomationTriggersPatchData>) => Promise<Types.AutomationTrigger>;
+    };
+    validate: {
+        create: (options: import("./core/transport.js").CallOptions<Types.AutomationValidateValidateData>) => Promise<Types.AutomationValidateResult>;
+    };
+    workflows: {
+        archive: (options: import("./core/transport.js").CallOptions<Types.AutomationWorkflowsArchiveData>) => Promise<Types.AutomationDefinition>;
+        create: (options: import("./core/transport.js").CallOptions<Types.AutomationWorkflowsCreateData>) => Promise<Types.AutomationDefinitionDetail>;
+        distTags: {
+            delete: (options: import("./core/transport.js").CallOptions<Types.AutomationWorkflowsDeleteDistTagData>) => Promise<{
+                [key: string]: Types.AutomationDistTag;
+            }>;
+            list: (options: import("./core/transport.js").CallOptions<Types.AutomationWorkflowsDistTagsData>) => Promise<{
+                [key: string]: Types.AutomationDistTag;
+            }>;
+            set: (options: import("./core/transport.js").CallOptions<Types.AutomationWorkflowsSetDistTagData>) => Promise<{
+                [key: string]: Types.AutomationDistTag;
+            }>;
+        };
+        list: (options?: import("./core/transport.js").CallOptions<Types.AutomationWorkflowsListData> | undefined) => Promise<import("./automation.js").Page<Types.AutomationDefinition>>;
+        restore: (options: import("./core/transport.js").CallOptions<Types.AutomationWorkflowsRestoreData>) => Promise<Types.AutomationDefinition>;
+        retrieve: (options: import("./core/transport.js").CallOptions<Types.AutomationWorkflowsGetData>) => Promise<Types.AutomationDefinitionDetail>;
+        update: (options: import("./core/transport.js").CallOptions<Types.AutomationWorkflowsPatchData>) => Promise<Types.AutomationDefinitionDetail>;
+        versions: {
+            create: (options: import("./core/transport.js").CallOptions<Types.AutomationWorkflowsPublishData>) => Promise<Types.AutomationVersion>;
+            deprecate: (options: import("./core/transport.js").CallOptions<Types.AutomationWorkflowsDeprecateData>) => Promise<Types.AutomationVersion>;
+            list: (options: import("./core/transport.js").CallOptions<Types.AutomationWorkflowsVersionsData>) => Promise<import("./automation.js").Page<Types.AutomationVersionListItem>>;
+            publish: (options: import("./core/transport.js").CallOptions<Types.AutomationWorkflowsPublishData>) => Promise<Types.AutomationVersion>;
+            retrieve: (options: import("./core/transport.js").CallOptions<Types.AutomationWorkflowsVersionData>) => Promise<Types.AutomationVersion>;
+        };
+    };
+};
+export declare function createBrowser(transport: Transport): {
+    connect: {
+        retrieve: (options?: import("./core/transport.js").CallOptions<Types.BrowserConnectData> | undefined) => Promise<unknown>;
+    };
+    contexts: {
+        create: (options: import("./core/transport.js").CallOptions<Types.BrowserCreateContextData>) => Promise<Types.BrowserContextCreateResult>;
+        delete: (options: import("./core/transport.js").CallOptions<Types.BrowserDeleteContextData>) => Promise<{
+            deleted: true;
+        }>;
+        list: (options?: import("./core/transport.js").CallOptions<Types.BrowserListContextsData> | undefined) => Promise<{
+            data: Array<Types.BrowserContext>;
+            nextCursor: string | null;
+        }>;
+        retrieve: (options: import("./core/transport.js").CallOptions<Types.BrowserGetContextData>) => Promise<Types.BrowserContext>;
+        update: (options: import("./core/transport.js").CallOptions<Types.BrowserUpdateContextData>) => Promise<Types.BrowserContext>;
+    };
+    live: {
+        retrieve: (options: import("./core/transport.js").CallOptions<Types.BrowserLiveViewData>) => Promise<unknown>;
+    };
+    seleniumUnsupported: {
+        retrieve: (options?: import("./core/transport.js").CallOptions<Types.BrowserSeleniumUnsupportedData> | undefined) => Promise<unknown>;
+    };
+    sessions: {
+        create: (options: import("./core/transport.js").CallOptions<Types.BrowserCreateSessionData>) => Promise<Types.BrowserSessionCreateResult>;
+        events: {
+            list: (options: import("./core/transport.js").CallOptions<Types.BrowserListEventsData>) => Promise<{
+                data: Array<Types.BrowserEventRecord>;
+                nextCursor: string | null;
+            }>;
+        };
+        handoff: {
+            complete: (options: import("./core/transport.js").CallOptions<Types.BrowserCompleteHandoffData>) => Promise<Types.BrowserEventRecord>;
+            create: (options: import("./core/transport.js").CallOptions<Types.BrowserRequestHandoffData>) => Promise<Types.BrowserEventRecord>;
+        };
+        list: (options?: import("./core/transport.js").CallOptions<Types.BrowserListSessionsData> | undefined) => Promise<{
+            data: Array<Types.BrowserSession>;
+            nextCursor: string | null;
+        }>;
+        retrieve: (options: import("./core/transport.js").CallOptions<Types.BrowserGetSessionData>) => Promise<Types.BrowserSessionGetResult>;
+        retrieveDebug: (options: import("./core/transport.js").CallOptions<Types.BrowserGetDebugData>) => Promise<Types.BrowserSessionLiveUrls>;
+        stream: (options: import("./core/transport.js").StreamOptions<Types.BrowserStreamSessionData>) => AsyncIterable<Types.BrowserStreamMessage>;
+        update: (options: import("./core/transport.js").CallOptions<Types.BrowserCloseSessionData>) => Promise<Types.BrowserSession>;
+        viewer: {
+            create: (options: import("./core/transport.js").CallOptions<Types.BrowserViewerHeartbeatData>) => Promise<{
+                ok: true;
+            }>;
+        };
+    };
+};
+export declare function createDatabase(transport: Transport): {
+    databases: {
+        create: (options: import("./core/transport.js").CallOptions<Types.DatabaseCreateDatabaseData>) => Promise<Types.DatabaseDatabase>;
+        delete: (options: import("./core/transport.js").CallOptions<Types.DatabaseDeleteDatabaseData>) => Promise<Types.DatabaseDatabase>;
+        events: {
+            list: (options: import("./core/transport.js").CallOptions<Types.DatabaseListEventsData>) => Promise<Types.DatabasePage & {
+                data: Array<Types.DatabaseDatabaseEvent>;
+            }>;
+        };
+        list: (options?: import("./core/transport.js").CallOptions<Types.DatabaseListDatabasesData> | undefined) => Promise<import("./automation.js").Page<Types.DatabaseDatabase>>;
+        purge: {
+            create: (options: import("./core/transport.js").CallOptions<Types.DatabasePurgeDatabaseData>) => Promise<{
+                id: string;
+                object: "database";
+                purged: true;
+            }>;
+        };
+        rest: {
+            create: (options: import("./core/transport.js").CallOptions<Types.DatabaseInsertData>) => Promise<(Types.DatabaseRow | Types.DatabaseProjectedRow)[]>;
+            delete: (options: import("./core/transport.js").CallOptions<Types.DatabaseDeleteData>) => Promise<void | (Types.DatabaseRow | Types.DatabaseProjectedRow)[]>;
+            head: (options: import("./core/transport.js").CallOptions<Types.DatabaseHeadData>) => Promise<unknown>;
+            retrieve: (options: import("./core/transport.js").CallOptions<Types.DatabaseSelectData>) => Promise<(Types.DatabaseRow | Types.DatabaseProjectedRow)[]>;
+            update: (options: import("./core/transport.js").CallOptions<Types.DatabaseUpdateData>) => Promise<void | (Types.DatabaseRow | Types.DatabaseProjectedRow)[]>;
+        };
+        restore: (options: import("./core/transport.js").CallOptions<Types.DatabaseRestoreDatabaseData>) => Promise<Types.DatabaseDatabase>;
+        retrieve: (options: import("./core/transport.js").CallOptions<Types.DatabaseGetDatabaseData>) => Promise<Types.DatabaseDatabase>;
+        tables: {
+            create: (options: import("./core/transport.js").CallOptions<Types.DatabaseCreateTableData>) => Promise<Types.DatabaseTable>;
+            delete: (options: import("./core/transport.js").CallOptions<Types.DatabaseDeleteTableData>) => Promise<{
+                deleted: true;
+            }>;
+            fields: {
+                create: (options: import("./core/transport.js").CallOptions<Types.DatabaseAddFieldData>) => Promise<Types.DatabaseTable>;
+                delete: (options: import("./core/transport.js").CallOptions<Types.DatabaseDeleteFieldData>) => Promise<Types.DatabaseTable>;
+                update: (options: import("./core/transport.js").CallOptions<Types.DatabaseUpdateFieldData>) => Promise<Types.DatabaseTable>;
+            };
+            list: (options: import("./core/transport.js").CallOptions<Types.DatabaseListTablesData>) => Promise<Types.DatabasePage & {
+                data: Array<Types.DatabaseTable>;
+            }>;
+            retrieve: (options: import("./core/transport.js").CallOptions<Types.DatabaseGetTableData>) => Promise<Types.DatabaseTable>;
+            update: (options: import("./core/transport.js").CallOptions<Types.DatabaseUpdateTableData>) => Promise<Types.DatabaseTable>;
+        };
+        update: (options: import("./core/transport.js").CallOptions<Types.DatabaseUpdateDatabaseData>) => Promise<Types.DatabaseDatabase>;
+    };
+};
+export declare function createFile(transport: Transport): {
+    files: {
+        create: (options: import("./core/transport.js").CallOptions<Types.FileCreateFileData>) => Promise<Types.OwnFileOpenAiFile>;
+        delete: (options: import("./core/transport.js").CallOptions<Types.FileDeleteFileData>) => Promise<Types.OwnFileDeleteFileResponse>;
+        list: (options?: import("./core/transport.js").CallOptions<Types.FileListFilesData> | undefined) => Promise<Types.OwnFileListFilesResponse>;
+        retrieve: (options: import("./core/transport.js").CallOptions<Types.FileRetrieveFileData>) => Promise<Types.OwnFileOpenAiFile>;
+        retrieveContent: (options: import("./core/transport.js").CallOptions<Types.FileRetrieveFileContentData>) => Promise<Blob | File>;
+    };
+};
+export declare function createKnowledge(transport: Transport): {
+    vectorStores: {
+        create: (options: import("./core/transport.js").CallOptions<Types.KnowledgeCreateVectorStoreData>) => Promise<Types.KnowledgeNativeVectorStore>;
+        delete: (options: import("./core/transport.js").CallOptions<Types.KnowledgeDeleteVectorStoreData>) => Promise<Types.KnowledgeNativeVectorStore>;
+        events: {
+            list: (options: import("./core/transport.js").CallOptions<Types.KnowledgeListEventsData>) => Promise<Types.KnowledgeEventList>;
+        };
+        fileBatches: {
+            cancel: (options: import("./core/transport.js").CallOptions<Types.KnowledgeCancelFileBatchData>) => Promise<Types.KnowledgeFileBatch>;
+            create: (options: import("./core/transport.js").CallOptions<Types.KnowledgeCreateFileBatchData>) => Promise<Types.KnowledgeFileBatch>;
+            files: {
+                list: (options: import("./core/transport.js").CallOptions<Types.KnowledgeListBatchFilesData>) => Promise<Types.KnowledgeNativeVectorStoreFileList>;
+            };
+            retrieve: (options: import("./core/transport.js").CallOptions<Types.KnowledgeRetrieveFileBatchData>) => Promise<Types.KnowledgeFileBatch>;
+        };
+        files: {
+            create: (options: import("./core/transport.js").CallOptions<Types.KnowledgeAttachFileData>) => Promise<Types.KnowledgeNativeVectorStoreFile>;
+            delete: (options: import("./core/transport.js").CallOptions<Types.KnowledgeRemoveFileData>) => Promise<Types.KnowledgeRemovedFile>;
+            list: (options: import("./core/transport.js").CallOptions<Types.KnowledgeListFilesData>) => Promise<Types.KnowledgeNativeVectorStoreFileList>;
+            retrieve: (options: import("./core/transport.js").CallOptions<Types.KnowledgeRetrieveFileData>) => Promise<Types.KnowledgeNativeVectorStoreFile>;
+            retrieveContent: (options: import("./core/transport.js").CallOptions<Types.KnowledgeRetrieveFileContentData>) => Promise<Types.KnowledgeFileContent>;
+            retry: {
+                create: (options: import("./core/transport.js").CallOptions<Types.KnowledgeRetryFileData>) => Promise<Types.KnowledgeNativeVectorStoreFile>;
+            };
+            segments: {
+                list: (options: import("./core/transport.js").CallOptions<Types.KnowledgeListSegmentsData>) => Promise<Types.KnowledgeSegmentList>;
+            };
+            update: (options: import("./core/transport.js").CallOptions<Types.KnowledgeUpdateFileData>) => Promise<Types.KnowledgeNativeVectorStoreFile>;
+        };
+        list: (options?: import("./core/transport.js").CallOptions<Types.KnowledgeListVectorStoresData> | undefined) => Promise<Types.KnowledgeNativeVectorStoreList>;
+        purge: {
+            create: (options: import("./core/transport.js").CallOptions<Types.KnowledgePurgeVectorStoreData>) => Promise<Types.KnowledgePurgedVectorStore>;
+        };
+        restore: (options: import("./core/transport.js").CallOptions<Types.KnowledgeRestoreVectorStoreData>) => Promise<Types.KnowledgeNativeVectorStore>;
+        retrieve: (options: import("./core/transport.js").CallOptions<Types.KnowledgeRetrieveVectorStoreData>) => Promise<Types.KnowledgeNativeExpandedVectorStore>;
+        search: {
+            create: (options: import("./core/transport.js").CallOptions<Types.KnowledgeSearchVectorStoreData>) => Promise<Types.KnowledgeNativeSearchPage>;
+        };
+        segments: {
+            retrieve: (options: import("./core/transport.js").CallOptions<Types.KnowledgeRetrieveSegmentData>) => Promise<Types.KnowledgeSegmentDetail>;
+        };
+        update: (options: import("./core/transport.js").CallOptions<Types.KnowledgeUpdateVectorStoreData>) => Promise<Types.KnowledgeNativeVectorStore>;
+    };
+};
+export declare function createMedia(transport: Transport): {
+    libraries: {
+        assets: {
+            batch: (options: import("./core/transport.js").CallOptions<Types.MediaBatchAssetsData>) => Promise<Types.MediaJob>;
+            create: (options: import("./core/transport.js").CallOptions<Types.MediaUploadAssetData>) => Promise<Types.MediaUploadResult>;
+            delete: (options: import("./core/transport.js").CallOptions<Types.MediaDeleteAssetData>) => Promise<Types.MediaDeleted>;
+            import: {
+                create: (options: import("./core/transport.js").CallOptions<Types.MediaImportAssetData>) => Promise<Types.MediaAsset>;
+            };
+            list: (options: import("./core/transport.js").CallOptions<Types.MediaListAssetsData>) => Promise<import("./automation.js").Page<Types.MediaAsset>>;
+            reprocess: {
+                create: (options: import("./core/transport.js").CallOptions<Types.MediaReprocessAssetData>) => Promise<Types.MediaAsset>;
+            };
+            retrieve: (options: import("./core/transport.js").CallOptions<Types.MediaGetAssetData>) => Promise<Types.MediaAsset>;
+            understandings: {
+                list: (options: import("./core/transport.js").CallOptions<Types.MediaListUnderstandingsData>) => Promise<import("./automation.js").Page<Types.MediaUnderstanding>>;
+            };
+            update: (options: import("./core/transport.js").CallOptions<Types.MediaUpdateAssetData>) => Promise<Types.MediaAsset>;
+        };
+        batches: {
+            create: (options: import("./core/transport.js").CallOptions<Types.MediaCreateBatchData>) => Promise<Types.MediaJob>;
+            retrieve: (options: import("./core/transport.js").CallOptions<Types.MediaGetBatchData>) => Promise<Types.MediaJob>;
+        };
+        create: (options: import("./core/transport.js").CallOptions<Types.MediaCreateLibraryData>) => Promise<Types.MediaLibrary>;
+        delete: (options: import("./core/transport.js").CallOptions<Types.MediaDeleteLibraryData>) => Promise<Types.MediaLibrary>;
+        events: {
+            list: (options: import("./core/transport.js").CallOptions<Types.MediaListEventsData>) => Promise<Types.MediaMediaEventPage>;
+        };
+        folders: {
+            list: (options: import("./core/transport.js").CallOptions<Types.MediaListFoldersData>) => Promise<Types.MediaFolders>;
+        };
+        jobs: {
+            retrieve: (options: import("./core/transport.js").CallOptions<Types.MediaGetJobData>) => Promise<Types.MediaJob>;
+        };
+        list: (options?: import("./core/transport.js").CallOptions<Types.MediaListLibrariesData> | undefined) => Promise<import("./automation.js").Page<Types.MediaLibrary>>;
+        purge: {
+            create: (options: import("./core/transport.js").CallOptions<Types.MediaPurgeLibraryData>) => Promise<Types.MediaPurgedLibrary>;
+        };
+        restore: (options: import("./core/transport.js").CallOptions<Types.MediaRestoreLibraryData>) => Promise<Types.MediaLibrary>;
+        retrieve: (options: import("./core/transport.js").CallOptions<Types.MediaGetLibraryData>) => Promise<Types.MediaLibrary>;
+        search: {
+            create: (options: import("./core/transport.js").CallOptions<Types.MediaSearchData>) => Promise<Types.MediaSemanticSearchResult>;
+            expression: {
+                create: (options: import("./core/transport.js").CallOptions<Types.MediaExpressionSearchData>) => Promise<Types.MediaExpressionSearchResult>;
+            };
+            semantic: {
+                create: (options: import("./core/transport.js").CallOptions<Types.MediaSemanticSearchData>) => Promise<Types.MediaSemanticSearchResult>;
+            };
+            visual: {
+                create: (options: import("./core/transport.js").CallOptions<Types.MediaVisualSearchData>) => Promise<Types.MediaSemanticSearchResult>;
+            };
+        };
+        update: (options: import("./core/transport.js").CallOptions<Types.MediaUpdateLibraryData>) => Promise<Types.MediaLibrary>;
+    };
+};
+export declare function createMeta(transport: Transport): {
+    health: {
+        retrieve: (options?: import("./core/transport.js").CallOptions<Types.HealthCheckData> | undefined) => Promise<string>;
+    };
+    methods: {
+        list: (options?: import("./core/transport.js").CallOptions<Types.MetaMethodsSearchData> | undefined) => Promise<{
+            has_more?: boolean;
+            first_id?: string | null;
+            last_id?: string | null;
+            data: Array<{
+                params: string;
+                name: string;
+                summary: string;
+                http: string;
+                path: string;
+            }>;
+        }>;
+        retrieve: (options: import("./core/transport.js").CallOptions<Types.MetaMethodsRetrieveData>) => Promise<Types.MetaMethod>;
+    };
+};
+export declare function createModel(transport: Transport): {
+    audio: {
+        speech: {
+            create: (options: import("./core/transport.js").CallOptions<Types.CreateAudioSpeechData>) => Promise<Blob | File>;
+        };
+        transcriptions: {
+            create: (options: import("./core/transport.js").CallOptions<Types.CreateAudioTranscriptionData>) => Promise<{
+                text: string;
+                task?: "transcribe";
+                language?: string;
+                duration?: number;
+                segments?: Array<{
+                    id: number;
+                    start: number;
+                    end: number;
+                    text: string;
+                    temperature?: number;
+                    avg_logprob?: number;
+                    compression_ratio?: number;
+                    no_speech_prob?: number;
+                }>;
+            }>;
+        };
+    };
+    chat: {
+        completions: {
+            create: import("./core/bindings.js").MixedMethod<Types.CreateChatCompletionData, {
+                id: string;
+                object: "chat.completion";
+                created: number;
+                model: string;
+                choices: Array<{
+                    index: number;
+                    message: {
+                        role: string;
+                        content: string | null;
+                        reasoning?: string | null;
+                        reasoning_details?: Array<{
+                            [key: string]: unknown;
+                        }> | null;
+                    };
+                    finish_reason: string | null;
+                    logprobs?: unknown | null;
+                }>;
+                usage: {
+                    prompt_tokens: number;
+                    completion_tokens: number;
+                    total_tokens: number;
+                    prompt_tokens_details: {
+                        cached_tokens: number;
+                        audio_tokens: number;
+                    };
+                    completion_tokens_details: {
+                        reasoning_tokens: number;
+                        audio_tokens: number;
+                    };
+                    prompt_cache_hit_tokens?: number;
+                    prompt_cache_miss_tokens?: number;
+                };
+                system_fingerprint: string | null;
+                service_tier?: string | null;
+                providerMetadata: {
+                    praxis: {
+                        generationId: string | null;
+                        cost: number | null;
+                        credential: "platform" | "byok";
+                        model: string;
+                    };
+                };
+            }, Types.PraxisSdkSsePostModelV1ChatCompletions>;
+        };
+    };
+    conversations: {
+        create: (options?: import("./core/transport.js").CallOptions<Types.CreateConversationData> | undefined) => Promise<Types.Conversation>;
+        delete: (options: import("./core/transport.js").CallOptions<Types.DeleteConversationData>) => Promise<{
+            id?: string;
+            object?: "conversation.deleted";
+            deleted?: boolean;
+        }>;
+        items: {
+            create: (options: import("./core/transport.js").CallOptions<Types.CreateConversationItemsData>) => Promise<Types.ConversationItemList>;
+            delete: (options: import("./core/transport.js").CallOptions<Types.DeleteConversationItemData>) => Promise<Types.Conversation>;
+            list: (options: import("./core/transport.js").CallOptions<Types.ListConversationItemsData>) => Promise<Types.ConversationItemList>;
+            retrieve: (options: import("./core/transport.js").CallOptions<Types.RetrieveConversationItemData>) => Promise<{
+                [key: string]: unknown;
+            }>;
+        };
+        retrieve: (options: import("./core/transport.js").CallOptions<Types.RetrieveConversationData>) => Promise<Types.Conversation>;
+        update: (options: import("./core/transport.js").CallOptions<Types.UpdateConversationData>) => Promise<Types.Conversation>;
+    };
+    embeddings: {
+        create: (options: import("./core/transport.js").CallOptions<Types.CreateEmbeddingData>) => Promise<{
+            data: Array<{
+                embedding: Array<number> | string;
+                index?: number;
+                object: "embedding";
+            }>;
+            id?: string;
+            model: string;
+            object: "list";
+            usage?: {
+                cost?: number;
+                cost_details?: Types.OpenaiCostDetails;
+                is_byok?: boolean;
+                prompt_tokens: number;
+                prompt_tokens_details?: {
+                    audio_tokens?: number;
+                    file_tokens?: number;
+                    image_tokens?: number;
+                    text_tokens?: number;
+                    video_tokens?: number;
+                };
+                total_tokens: number;
+            };
+        }>;
+    };
+    generation: {
+        retrieve: (options: import("./core/transport.js").CallOptions<Types.GetGenerationData>) => Promise<{
+            id: string;
+            model: string;
+            cost: number | null;
+            usage: {
+                prompt_tokens: number;
+                completion_tokens: number;
+                total_tokens: number;
+                cached_input_tokens: number;
+            };
+            latency_ms: number | null;
+            created: number;
+        }>;
+    };
+    images: {
+        edits: {
+            create: (options: import("./core/transport.js").CallOptions<Types.EditImageData>) => Promise<{
+                [key: string]: unknown;
+                created: number;
+                data: Array<{
+                    url?: string;
+                    b64_json?: string;
+                    [key: string]: unknown;
+                }>;
+            }>;
+        };
+        generations: {
+            create: (options: import("./core/transport.js").CallOptions<Types.CreateImageData>) => Promise<{
+                created?: number;
+                data?: Array<{
+                    url?: string;
+                    b64_json?: string;
+                    revised_prompt?: string;
+                }>;
+            }>;
+        };
+    };
+    messages: {
+        countTokens: (options: import("./core/transport.js").CallOptions<Types.CountTokensData>) => Promise<Types.AnthropicMessageTokensCount>;
+        create: import("./core/bindings.js").MixedMethod<Types.CreateMessageData, Types.AnthropicMessage, Types.PraxisSdkSsePostModelV1Messages>;
+    };
+    models: {
+        list: (options?: import("./core/transport.js").CallOptions<Types.ListModelsData> | undefined) => Promise<{
+            object: "list";
+            data: Array<{
+                id: string;
+                object: "model";
+                created: number;
+                owned_by: string;
+                name: string;
+                description: string | null;
+                context_window: number | null;
+                max_tokens: number | null;
+                type: "language" | "image" | "embedding" | "ocr" | "transcription" | "speech" | "video" | "reranking";
+                supported_apis: Array<string>;
+                tags: Array<string>;
+                architecture: {
+                    modality: string;
+                    input_modalities: Array<string>;
+                    output_modalities: Array<string>;
+                    tokenizer: string | null;
+                    instruct_type: string | null;
+                };
+                x_praxis: {
+                    input_modalities: {
+                        text: "native" | "converted" | "unsupported";
+                        image: "native" | "converted" | "unsupported";
+                        pdf: "native" | "converted" | "unsupported";
+                        docx: "native" | "converted" | "unsupported";
+                        pptx: "native" | "converted" | "unsupported";
+                        xlsx: "native" | "converted" | "unsupported";
+                        audio: "native" | "converted" | "unsupported";
+                        video: "native" | "converted" | "unsupported";
+                    };
+                };
+                pricing: {
+                    input?: string;
+                    output?: string;
+                    input_cache_read?: string;
+                    input_cache_write?: string;
+                    image?: string;
+                    video_second?: string;
+                    audio_input_minute?: string;
+                    audio_output_minute?: string;
+                    input_character?: string;
+                    page?: string;
+                };
+                released: string;
+            }>;
+        }>;
+        retrieve: (options: import("./core/transport.js").CallOptions<Types.RetrieveModelData>) => Promise<{
+            id: string;
+            object: "model";
+            created: number;
+            owned_by: string;
+            name: string;
+            description: string | null;
+            context_window: number | null;
+            max_tokens: number | null;
+            type: "language" | "image" | "embedding" | "ocr" | "transcription" | "speech" | "video" | "reranking";
+            supported_apis: Array<string>;
+            tags: Array<string>;
+            architecture: {
+                modality: string;
+                input_modalities: Array<string>;
+                output_modalities: Array<string>;
+                tokenizer: string | null;
+                instruct_type: string | null;
+            };
+            x_praxis: {
+                input_modalities: {
+                    text: "native" | "converted" | "unsupported";
+                    image: "native" | "converted" | "unsupported";
+                    pdf: "native" | "converted" | "unsupported";
+                    docx: "native" | "converted" | "unsupported";
+                    pptx: "native" | "converted" | "unsupported";
+                    xlsx: "native" | "converted" | "unsupported";
+                    audio: "native" | "converted" | "unsupported";
+                    video: "native" | "converted" | "unsupported";
+                };
+            };
+            pricing: {
+                input?: string;
+                output?: string;
+                input_cache_read?: string;
+                input_cache_write?: string;
+                image?: string;
+                video_second?: string;
+                audio_input_minute?: string;
+                audio_output_minute?: string;
+                input_character?: string;
+                page?: string;
+            };
+            released: string;
+        }>;
+    };
+    ocr: {
+        create: (options: import("./core/transport.js").CallOptions<Types.CreateOcrData>) => Promise<{
+            [key: string]: unknown;
+            pages: Array<{
+                index: number;
+                markdown: string;
+                images: Array<{
+                    id: string;
+                    top_left_x: number | null;
+                    top_left_y: number | null;
+                    bottom_right_x: number | null;
+                    bottom_right_y: number | null;
+                    image_base64?: string | null;
+                    image_annotation?: string | null;
+                    [key: string]: unknown;
+                }>;
+                dimensions: {
+                    dpi: number;
+                    height: number;
+                    width: number;
+                    [key: string]: unknown;
+                } | null;
+                tables?: Array<{
+                    id: string;
+                    content: string;
+                    format: "markdown" | "html";
+                    word_confidence_scores?: Array<{
+                        text: string;
+                        confidence: number;
+                        start_index: number;
+                        [key: string]: unknown;
+                    }> | null;
+                    [key: string]: unknown;
+                }>;
+                hyperlinks?: Array<string>;
+                header?: string | null;
+                footer?: string | null;
+                blocks?: Array<{
+                    top_left_x: number;
+                    top_left_y: number;
+                    bottom_right_x: number;
+                    bottom_right_y: number;
+                    content: string;
+                    confidence_scores?: {
+                        average_content_confidence_score?: number | null;
+                        minimum_content_confidence_score?: number | null;
+                        block_type_confidence_score?: number | null;
+                        [key: string]: unknown;
+                    } | null;
+                    type?: "text" | "list" | "title" | "equation" | "caption" | "code" | "references" | "aside_text" | "header" | "footer" | "signature";
+                    [key: string]: unknown;
+                } | {
+                    top_left_x: number;
+                    top_left_y: number;
+                    bottom_right_x: number;
+                    bottom_right_y: number;
+                    content: string;
+                    confidence_scores?: {
+                        average_content_confidence_score?: number | null;
+                        minimum_content_confidence_score?: number | null;
+                        block_type_confidence_score?: number | null;
+                        [key: string]: unknown;
+                    } | null;
+                    type?: "image";
+                    image_id: string;
+                    [key: string]: unknown;
+                } | {
+                    top_left_x: number;
+                    top_left_y: number;
+                    bottom_right_x: number;
+                    bottom_right_y: number;
+                    content: string;
+                    confidence_scores?: {
+                        average_content_confidence_score?: number | null;
+                        minimum_content_confidence_score?: number | null;
+                        block_type_confidence_score?: number | null;
+                        [key: string]: unknown;
+                    } | null;
+                    type?: "table";
+                    table_id?: string | null;
+                    [key: string]: unknown;
+                }> | null;
+                confidence_scores?: {
+                    word_confidence_scores?: Array<{
+                        text: string;
+                        confidence: number;
+                        start_index: number;
+                        [key: string]: unknown;
+                    }>;
+                    average_page_confidence_score: number;
+                    minimum_page_confidence_score: number;
+                    [key: string]: unknown;
+                } | null;
+                [key: string]: unknown;
+            }>;
+            model: string;
+            usage_info: {
+                pages_processed: number;
+                doc_size_bytes?: number | null;
+                [key: string]: unknown;
+            };
+            document_annotation?: string | null;
+        }>;
+    };
+    rerank: {
+        create: (options: import("./core/transport.js").CallOptions<Types.RerankData>) => Promise<{
+            results: Array<{
+                index: number;
+                relevance_score: number;
+            }>;
+        }>;
+    };
+    responses: {
+        cancel: (options: import("./core/transport.js").CallOptions<Types.CancelResponseData>) => Promise<{
+            [key: string]: unknown;
+        }>;
+        compact: (options: import("./core/transport.js").CallOptions<Types.CompactResponseData>) => Promise<{
+            [key: string]: unknown;
+        }>;
+        create: import("./core/bindings.js").MixedMethod<Types.CreateResponseData, Types.OpenaiOpenResponsesResult, Types.PraxisSdkSsePostModelV1Responses>;
+        delete: (options: import("./core/transport.js").CallOptions<Types.DeleteResponseData>) => Promise<{
+            [key: string]: unknown;
+        }>;
+        inputItems: {
+            list: (options: import("./core/transport.js").CallOptions<Types.ListResponseInputItemsData>) => Promise<{
+                [key: string]: unknown;
+            }>;
+        };
+        inputTokens: {
+            create: (options: import("./core/transport.js").CallOptions<Types.CountResponseInputTokensData>) => Promise<{
+                [key: string]: unknown;
+            }>;
+        };
+        retrieve: (options: import("./core/transport.js").CallOptions<Types.RetrieveResponseData>) => Promise<{
+            [key: string]: unknown;
+        }>;
+    };
+    videos: {
+        create: (options: import("./core/transport.js").CallOptions<Types.CreateVideoData>) => Promise<{
+            id: string;
+            object: "video";
+            model: string;
+            status: "queued" | "in_progress" | "completed" | "failed";
+            progress: number;
+            created_at: number;
+            completed_at: number | null;
+            expires_at: number | null;
+            seconds: string;
+            size: string;
+            prompt?: string | null;
+            remixed_from_video_id?: null;
+            error: {
+                code?: string;
+                message?: string;
+            } | null;
+            polling_url: string;
+            unsigned_urls: Array<string>;
+            usage?: {
+                cost: number;
+            };
+        }>;
+        delete: (options: import("./core/transport.js").CallOptions<Types.DeleteVideoData>) => Promise<{
+            id: string;
+            object: "video.deleted";
+            deleted: true;
+        }>;
+        list: (options?: import("./core/transport.js").CallOptions<Types.ListVideosData> | undefined) => Promise<{
+            object: "list";
+            data: Array<{
+                id: string;
+                object: "video";
+                model: string;
+                status: "queued" | "in_progress" | "completed" | "failed";
+                progress: number;
+                created_at: number;
+                completed_at: number | null;
+                expires_at: number | null;
+                seconds: string;
+                size: string;
+                prompt?: string | null;
+                remixed_from_video_id?: null;
+                error: {
+                    code?: string;
+                    message?: string;
+                } | null;
+                polling_url: string;
+                unsigned_urls: Array<string>;
+                usage?: {
+                    cost: number;
+                };
+            }>;
+            has_more: boolean;
+            first_id: string | null;
+            last_id: string | null;
+        }>;
+        remix: (options: import("./core/transport.js").CallOptions<Types.RemixVideoData>) => Promise<unknown>;
+        retrieve: (options: import("./core/transport.js").CallOptions<Types.RetrieveVideoData>) => Promise<{
+            id: string;
+            object: "video";
+            model: string;
+            status: "queued" | "in_progress" | "completed" | "failed";
+            progress: number;
+            created_at: number;
+            completed_at: number | null;
+            expires_at: number | null;
+            seconds: string;
+            size: string;
+            prompt?: string | null;
+            remixed_from_video_id?: null;
+            error: {
+                code?: string;
+                message?: string;
+            } | null;
+            polling_url: string;
+            unsigned_urls: Array<string>;
+            usage?: {
+                cost: number;
+            };
+        }>;
+        retrieveContent: (options: import("./core/transport.js").CallOptions<Types.DownloadVideoContentData>) => Promise<Blob | File>;
+    };
+};
+export declare function createOrganization(transport: Transport): {
+    charges: {
+        list: (options: import("./core/transport.js").CallOptions<Types.ExportOrganizationChargesData>) => Promise<{
+            ChargePeriodStart: string;
+            ChargePeriodEnd: string;
+            BilledCost: string;
+            BillingCurrency: "CNY" | "USD";
+            ServiceName: string;
+            ServiceCategory: string;
+            ResourceId: string;
+            ResourceName: string;
+            ConsumedQuantity: string;
+            ConsumedUnit: string;
+            ChargeCategory: "Usage" | "Adjustment";
+            ChargeClass: "Correction" | null;
+            ChargeDescription: string;
+            x_RequestId: string | null;
+            x_EventId: string;
+        }>;
+    };
+    costs: {
+        list: (options: import("./core/transport.js").CallOptions<Types.ListOrganizationCostsData>) => Promise<{
+            object: "page";
+            data: Array<{
+                object: "bucket";
+                starting_at: string;
+                ending_at: string;
+                estimated: boolean;
+                results: Array<{
+                    ServiceName?: string;
+                    ServiceCategory?: string;
+                    ResourceId?: string;
+                    ResourceName?: string;
+                    BilledCost: string;
+                    BillingCurrency: "CNY" | "USD";
+                    x_EventCount: string;
+                }>;
+            }>;
+            has_more: boolean;
+            next_page: string | null;
+        }>;
+    };
+    events: {
+        list: (options: import("./core/transport.js").CallOptions<Types.ListOrganizationEventsData>) => Promise<{
+            object: "page";
+            data: Array<{
+                object: "usage.event";
+                id: string;
+                occurred_at: string;
+                ServiceName: string;
+                ServiceCategory: string;
+                ResourceId: string;
+                ResourceName: string;
+                BilledCost: string;
+                BillingCurrency: "CNY" | "USD";
+                ChargeClass: "Correction" | null;
+                request_id: string | null;
+                settlement: {
+                    status: "settled" | "no_charge" | "rejected";
+                    shortfall: string | null;
+                    zero_reason: string | null;
+                };
+                lines: Array<{
+                    meter: string;
+                    display_name: string;
+                    ConsumedQuantity: string;
+                    ConsumedUnit: string;
+                }>;
+            }>;
+            has_more: boolean;
+            next_page: string | null;
+        }>;
+        retrieve: (options: import("./core/transport.js").CallOptions<Types.GetOrganizationEventData>) => Promise<{
+            object: "usage.event";
+            id: string;
+            occurred_at: string;
+            ServiceName: string;
+            ServiceCategory: string;
+            ResourceId: string;
+            ResourceName: string;
+            BilledCost: string;
+            BillingCurrency: "CNY" | "USD";
+            ChargeClass: "Correction" | null;
+            request_id: string | null;
+            settlement: {
+                status: "settled" | "no_charge" | "rejected";
+                shortfall: string | null;
+                zero_reason: string | null;
+            };
+            lines?: Array<{
+                meter: string;
+                display_name: string;
+                ConsumedQuantity: string;
+                ConsumedUnit: string;
+                ListUnitPrice: string | null;
+                PricingUnit: string | null;
+                BilledCost: string;
+            }>;
+            x_Charges?: Array<{
+                transaction_id: string;
+                BilledCost: string;
+                BillingCurrency: "CNY" | "USD";
+                sub_account: "cash" | "promotional";
+            }>;
+        }>;
+    };
+    feedback: {
+        counts: {
+            list: (options?: import("./core/transport.js").CallOptions<Types.GetOrganizationFeedbackCountsData> | undefined) => Promise<{
+                object: "feedback.counts";
+                open: number;
+                awaiting_customer: number;
+                in_progress: number;
+                resolved: number;
+                closed: number;
+                total: number;
+            }>;
+        };
+        create: (options: import("./core/transport.js").CallOptions<Types.CreateOrganizationFeedbackData>) => Promise<{
+            id: string;
+        }>;
+        list: (options?: import("./core/transport.js").CallOptions<Types.ListOrganizationFeedbackData> | undefined) => Promise<{
+            object: "page";
+            data: Array<{
+                object: "feedback";
+                id: string;
+                title?: string | null;
+                type?: string | null;
+                message: string;
+                phase: "open" | "awaiting_customer" | "in_progress" | "resolved" | "closed";
+                status: "unresolved" | "resolved" | "ignored";
+                source: "console" | "api" | "codemode";
+                url?: string | null;
+                first_response_due_time?: string | null;
+                first_response_time?: string | null;
+                last_message_time: string;
+                unread: boolean;
+                create_time: string;
+                update_time: string;
+                reporter?: {
+                    type?: "user" | "api_key" | "agent_session";
+                };
+                last_message_preview?: {
+                    author_kind?: "customer" | "staff" | "system";
+                    body?: string;
+                    create_time?: string;
+                } | null;
+                attachments: Array<{
+                    id?: string;
+                    name?: string;
+                    content_type?: string;
+                    size?: number;
+                    create_time?: string;
+                }>;
+            }>;
+            has_more: boolean;
+            next_page: string | null;
+        }>;
+        messages: {
+            create: (options: import("./core/transport.js").CallOptions<Types.CreateOrganizationFeedbackMessageData>) => Promise<{
+                object: "feedback.message";
+                id: string;
+                feedback_id: string;
+                author: {
+                    kind?: "customer" | "staff" | "system";
+                    name?: string;
+                };
+                body: string;
+                event?: {
+                    type?: "phase_changed" | "assigned";
+                    from?: string | null;
+                    to?: string | null;
+                } | null;
+                attachments: Array<{
+                    id?: string;
+                    name?: string;
+                    content_type?: string;
+                    size?: number;
+                    create_time?: string;
+                }>;
+                create_time: string;
+            }>;
+            list: (options: import("./core/transport.js").CallOptions<Types.ListOrganizationFeedbackMessagesData>) => Promise<{
+                object: "page";
+                data: Array<{
+                    object: "feedback.message";
+                    id: string;
+                    feedback_id: string;
+                    author: {
+                        kind?: "customer" | "staff" | "system";
+                        name?: string;
+                    };
+                    body: string;
+                    event?: {
+                        type?: "phase_changed" | "assigned";
+                        from?: string | null;
+                        to?: string | null;
+                    } | null;
+                    attachments: Array<{
+                        id?: string;
+                        name?: string;
+                        content_type?: string;
+                        size?: number;
+                        create_time?: string;
+                    }>;
+                    create_time: string;
+                }>;
+                has_more: boolean;
+                next_page: string | null;
+            }>;
+        };
+        retrieve: (options: import("./core/transport.js").CallOptions<Types.GetOrganizationFeedbackData>) => Promise<{
+            object: "feedback";
+            id: string;
+            title?: string | null;
+            type?: string | null;
+            message: string;
+            phase: "open" | "awaiting_customer" | "in_progress" | "resolved" | "closed";
+            status: "unresolved" | "resolved" | "ignored";
+            source: "console" | "api" | "codemode";
+            url?: string | null;
+            first_response_due_time?: string | null;
+            first_response_time?: string | null;
+            last_message_time: string;
+            unread: boolean;
+            create_time: string;
+            update_time: string;
+            reporter?: {
+                type?: "user" | "api_key" | "agent_session";
+            };
+            last_message_preview?: {
+                author_kind?: "customer" | "staff" | "system";
+                body?: string;
+                create_time?: string;
+            } | null;
+            attachments: Array<{
+                id?: string;
+                name?: string;
+                content_type?: string;
+                size?: number;
+                create_time?: string;
+            }>;
+        }>;
+    };
+    usage: {
+        list: (options: import("./core/transport.js").CallOptions<Types.ListOrganizationUsageData>) => Promise<{
+            object: "page";
+            data: Array<{
+                object: "bucket";
+                starting_at: string;
+                ending_at: string;
+                estimated: boolean;
+                results: Array<{
+                    ServiceName?: string;
+                    ServiceCategory?: string;
+                    ResourceId?: string;
+                    ResourceName?: string;
+                    ConsumedQuantity: string;
+                    ConsumedUnit: string;
+                    x_EventCount: string;
+                }>;
+            }>;
+            has_more: boolean;
+            next_page: string | null;
+        }>;
+    };
+};
+export declare function createSandbox(transport: Transport): {
+    sandboxes: {
+        commands: {
+            run: (options: import("./core/transport.js").CallOptions<Types.RunSandboxCommandData>) => Promise<{
+                stdout: string;
+                stderr: string;
+                exitCode: number;
+            }>;
+        };
+        connect: (options: import("./core/transport.js").CallOptions<Types.PostSandboxV1SandboxesBySandboxIdConnectData>) => Promise<Types.SandboxSandbox>;
+        create: (options: import("./core/transport.js").CallOptions<Types.PostSandboxV1SandboxesData>) => Promise<Types.SandboxSandbox>;
+        delete: (options: import("./core/transport.js").CallOptions<Types.DeleteSandboxV1SandboxesBySandboxIdData>) => Promise<void>;
+        extend: (options: import("./core/transport.js").CallOptions<Types.ExtendSandboxData>) => Promise<{
+            endAt: string;
+        }>;
+        files: {
+            list: (options: import("./core/transport.js").CallOptions<Types.ListSandboxFilesData>) => Promise<{
+                name: string;
+                path: string;
+                type: "file" | "dir" | "symlink";
+                size: number;
+            }[]>;
+            makeDir: (options: import("./core/transport.js").CallOptions<Types.MakeSandboxDirectoryData>) => Promise<boolean>;
+            read: (options: import("./core/transport.js").CallOptions<Types.ReadSandboxFileData>) => Promise<string>;
+            remove: (options: import("./core/transport.js").CallOptions<Types.RemoveSandboxFileData>) => Promise<void>;
+            write: (options: import("./core/transport.js").CallOptions<Types.WriteSandboxFileData>) => Promise<{
+                name: string;
+                path: string;
+                type: "file" | "dir" | "symlink";
+                size: number;
+            }>;
+        };
+        fork: (options: import("./core/transport.js").CallOptions<Types.PostSandboxV1SandboxesBySandboxIdForkData>) => Promise<Types.SandboxSandboxForkResult[]>;
+        list: (options?: import("./core/transport.js").CallOptions<Types.GetSandboxV1SandboxesData> | undefined) => Promise<Types.SandboxListedSandbox[]>;
+        logs: {
+            list: (options: import("./core/transport.js").CallOptions<Types.GetSandboxV1SandboxesBySandboxIdLogsData>) => Promise<Types.SandboxSandboxLogsV2Response>;
+        };
+        metrics: {
+            list: (options: import("./core/transport.js").CallOptions<Types.GetSandboxV1SandboxesBySandboxIdMetricsData>) => Promise<Types.SandboxSandboxMetric[]>;
+        };
+        pause: (options: import("./core/transport.js").CallOptions<Types.PostSandboxV1SandboxesBySandboxIdPauseData>) => Promise<void>;
+        processes: {
+            list: (options: import("./core/transport.js").CallOptions<Types.ListObservedProcessesData>) => Promise<{
+                processes: Array<{
+                    processId: string;
+                    pid: number;
+                    tag?: string;
+                    config: {
+                        cmd: string;
+                        args: Array<string>;
+                        cwd?: string;
+                    };
+                    pty?: boolean;
+                    startedAt?: string;
+                    exitedAt?: string;
+                    exitCode?: number;
+                    state: "running" | "exited" | "unknown";
+                    observed: boolean;
+                    observationGap: boolean;
+                    outputTruncated: boolean;
+                }>;
+            }>;
+            retrieveOutput: (options: import("./core/transport.js").CallOptions<Types.GetObservedProcessOutputData>) => Promise<{
+                chunks: Array<{
+                    seq: number;
+                    stream: "stdout" | "stderr" | "pty";
+                    data: string;
+                    timestamp: number;
+                }>;
+                complete: boolean;
+                gap: boolean;
+                truncated: boolean;
+                exitCode: number | null;
+            }>;
+        };
+        retrieve: (options: import("./core/transport.js").CallOptions<Types.GetSandboxV1SandboxesBySandboxIdData>) => Promise<Types.SandboxSandboxDetail>;
+        snapshots: {
+            create: (options: import("./core/transport.js").CallOptions<Types.PostSandboxV1SandboxesBySandboxIdSnapshotsData>) => Promise<Types.SandboxSnapshotInfo>;
+        };
+        timeout: (options: import("./core/transport.js").CallOptions<Types.PostSandboxV1SandboxesBySandboxIdTimeoutData>) => Promise<void>;
+        update: (options: import("./core/transport.js").CallOptions<Types.RenameSandboxData>) => Promise<Types.SandboxSandboxDetail & {
+            name: string;
+        }>;
+        updateNetwork: (options: import("./core/transport.js").CallOptions<Types.PutSandboxV1SandboxesBySandboxIdNetworkData>) => Promise<void>;
+        upgrade: {
+            create: (options: import("./core/transport.js").CallOptions<Types.UpgradeSandboxData>) => Promise<Types.SandboxSandboxDetail>;
+        };
+    };
+    snapshots: {
+        delete: (options: import("./core/transport.js").CallOptions<Types.DeleteSandboxV1SnapshotsBySnapshotIdData>) => Promise<void>;
+        list: (options?: import("./core/transport.js").CallOptions<Types.GetSandboxV1SnapshotsData> | undefined) => Promise<Types.SandboxSnapshotInfo[]>;
+    };
+    templates: {
+        list: (options?: import("./core/transport.js").CallOptions<Types.GetSandboxV1TemplatesData> | undefined) => Promise<Types.SandboxTemplate[]>;
+    };
+    volumes: {
+        create: (options: import("./core/transport.js").CallOptions<Types.PostSandboxV1VolumesData>) => Promise<Types.SandboxVolumeAndToken>;
+        delete: (options: import("./core/transport.js").CallOptions<Types.DeleteSandboxV1VolumesByVolumeIdData>) => Promise<void>;
+        list: (options?: import("./core/transport.js").CallOptions<Types.GetSandboxV1VolumesData> | undefined) => Promise<Types.SandboxVolume[]>;
+        retrieve: (options: import("./core/transport.js").CallOptions<Types.GetSandboxV1VolumesByVolumeIdData>) => Promise<Types.SandboxVolumeAndToken>;
+    };
+};
+export declare function createSearch(transport: Transport): {
+    crawl: {
+        create: (options: import("./core/transport.js").CallOptions<Types.SearchCrawlData>) => Promise<{
+            base_url?: string;
+            results?: Array<{
+                url?: string;
+                raw_content?: string;
+                favicon?: string;
+            }>;
+            response_time?: number;
+            usage?: {
+                [key: string]: unknown;
+            };
+            request_id?: string;
+        }>;
+    };
+    extract: {
+        create: (options: import("./core/transport.js").CallOptions<Types.SearchExtractData>) => Promise<{
+            results?: Array<{
+                url?: string;
+                raw_content?: string;
+                images?: Array<string>;
+                favicon?: string;
+            }>;
+            failed_results?: Array<{
+                url?: string;
+                error?: string;
+            }>;
+            response_time?: number;
+            usage?: {
+                [key: string]: unknown;
+            };
+            request_id?: string;
+        }>;
+    };
+    map: {
+        create: (options: import("./core/transport.js").CallOptions<Types.SearchMapData>) => Promise<{
+            base_url?: string;
+            results?: Array<string>;
+            response_time?: number;
+            usage?: {
+                [key: string]: unknown;
+            };
+            request_id?: string;
+        }>;
+    };
+    search: {
+        create: (options: import("./core/transport.js").CallOptions<Types.SearchSearchData>) => Promise<{
+            query: string;
+            answer: string;
+            images: Array<{
+                url?: string;
+                description?: string;
+            }>;
+            results: Array<{
+                title?: string;
+                url?: string;
+                content?: string;
+                score?: number;
+                raw_content?: string;
+                published_date?: string;
+                favicon?: string;
+                images?: Array<{
+                    url?: string;
+                    description?: string;
+                }>;
+                id?: string;
+            }>;
+            auto_parameters?: {
+                [key: string]: unknown;
+            };
+            response_time: number;
+            usage?: {
+                [key: string]: unknown;
+            };
+            request_id?: string;
+        }>;
+    };
+};
+export declare function createVault(transport: Transport): {
+    authorizations: {
+        create: (options: import("./core/transport.js").CallOptions<Types.VaultCreateAuthorizationData>) => Promise<Types.VaultAuthorization>;
+        retrieve: (options: import("./core/transport.js").CallOptions<Types.VaultGetAuthorizationData>) => Promise<Types.VaultAuthorization>;
+        retrieveCallback: (options?: import("./core/transport.js").CallOptions<Types.VaultAuthorizationCallbackData> | undefined) => Promise<string>;
+    };
+    connect: {
+        continue: {
+            create: (options: import("./core/transport.js").CallOptions<Types.VaultConnectContinueData>) => Promise<unknown>;
+        };
+        deny: {
+            create: (options: import("./core/transport.js").CallOptions<Types.VaultConnectDenyData>) => Promise<string>;
+        };
+        retrieve: (options: import("./core/transport.js").CallOptions<Types.VaultConnectPageData>) => Promise<string>;
+    };
+    oauth: {
+        retrieveClientMetadata: (options?: import("./core/transport.js").CallOptions<Types.VaultOAuthClientMetadataData> | undefined) => Promise<Types.VaultOAuthClientMetadata>;
+    };
+    settings: {
+        returnUrls: {
+            list: (options?: import("./core/transport.js").CallOptions<Types.VaultGetReturnUrlsData> | undefined) => Promise<Types.VaultReturnUrls>;
+            update: (options: import("./core/transport.js").CallOptions<Types.VaultSetReturnUrlsData>) => Promise<Types.VaultReturnUrls>;
+        };
+    };
+    templates: {
+        list: (options?: import("./core/transport.js").CallOptions<Types.VaultListTemplatesData> | undefined) => Promise<Types.VaultTemplateList>;
+    };
+    vaults: {
+        archive: (options: import("./core/transport.js").CallOptions<Types.VaultArchiveVaultData>) => Promise<Types.VaultVault>;
+        check: (options: import("./core/transport.js").CallOptions<Types.VaultCheckVaultsData>) => Promise<Types.VaultCheckVaultsResult>;
+        create: (options: import("./core/transport.js").CallOptions<Types.VaultCreateVaultData>) => Promise<Types.VaultVault>;
+        delete: (options: import("./core/transport.js").CallOptions<Types.VaultDeleteVaultData>) => Promise<Types.VaultVaultDeleted>;
+        events: {
+            list: (options: import("./core/transport.js").CallOptions<Types.VaultListEventsData>) => Promise<import("./automation.js").Page<Types.VaultVaultEvent>>;
+        };
+        list: (options?: import("./core/transport.js").CallOptions<Types.VaultListVaultsData> | undefined) => Promise<import("./automation.js").Page<Types.VaultVault>>;
+        retrieve: (options: import("./core/transport.js").CallOptions<Types.VaultGetVaultData>) => Promise<Types.VaultVault>;
+        secrets: {
+            archive: (options: import("./core/transport.js").CallOptions<Types.VaultArchiveSecretData>) => Promise<Types.VaultSecret>;
+            create: (options: import("./core/transport.js").CallOptions<Types.VaultCreateSecretData>) => Promise<Types.VaultSecret>;
+            delete: (options: import("./core/transport.js").CallOptions<Types.VaultDeleteSecretData>) => Promise<Types.VaultSecretDeleted>;
+            import: (options: import("./core/transport.js").CallOptions<Types.VaultImportSecretsData>) => Promise<Types.VaultImportResult>;
+            list: (options: import("./core/transport.js").CallOptions<Types.VaultListSecretsData>) => Promise<import("./automation.js").Page<Types.VaultSecret>>;
+            refresh: {
+                create: (options: import("./core/transport.js").CallOptions<Types.VaultRefreshSecretData>) => Promise<Types.VaultSecret>;
+            };
+            retrieve: (options: import("./core/transport.js").CallOptions<Types.VaultGetSecretData>) => Promise<Types.VaultSecret>;
+            update: (options: import("./core/transport.js").CallOptions<Types.VaultUpdateSecretData>) => Promise<Types.VaultSecret>;
+            validate: {
+                create: (options: import("./core/transport.js").CallOptions<Types.VaultValidateSecretData>) => Promise<Types.VaultSecretValidation>;
+            };
+        };
+        update: (options: import("./core/transport.js").CallOptions<Types.VaultUpdateVaultData>) => Promise<Types.VaultVault>;
+    };
+};
+export declare const resourceFactories: {
+    agent: typeof createAgent;
+    application: typeof createApplication;
+    automation: typeof createAutomation;
+    browser: typeof createBrowser;
+    database: typeof createDatabase;
+    file: typeof createFile;
+    knowledge: typeof createKnowledge;
+    media: typeof createMedia;
+    meta: typeof createMeta;
+    model: typeof createModel;
+    organization: typeof createOrganization;
+    sandbox: typeof createSandbox;
+    search: typeof createSearch;
+    vault: typeof createVault;
+};