@blade-hq/agent-kit 0.4.1 → 0.4.4

package/dist/blade-client-nOsdVlb1.d.ts

@@ -0,0 +1,1498 @@
+import * as arktype_internal_variants_object_ts from 'arktype/internal/variants/object.ts';
+import * as arktype_internal_variants_string_ts from 'arktype/internal/variants/string.ts';
+import { T as TurnProjection } from './projection-DIfyh6RK.js';
+import { S as SessionInfo, T as TemplateId, b as SessionDetail, c as Solution, B as BizRole } from './session-CDeiO81j.js';
+import { Socket } from 'socket.io-client';
+
+declare class BladeApiError extends Error {
+    readonly response: Response;
+    readonly status: number;
+    readonly statusText: string;
+    constructor(response: Response, message?: string);
+}
+type HttpMethod = "DELETE" | "GET" | "PATCH" | "POST" | "PUT" | (string & {});
+interface BladeFetchInit {
+    body?: BodyInit | null;
+    credentials?: RequestCredentials;
+    expectOk?: boolean;
+    headers?: HeadersInit;
+    signal?: AbortSignal | null;
+}
+
+interface ApiKeyPublic {
+    id: string;
+    name: string;
+    masked: string;
+    created_at: string;
+    last_used_at: string | null;
+    /**
+     * 完整 key 原文。后端按 #761 设计存明文，支持反复获取；存量 hash-only 行为 null。
+     */
+    plaintext: string | null;
+}
+interface ApiKeyCreateResponse {
+    key: ApiKeyPublic;
+    plaintext: string;
+}
+declare class ApiKeysResource {
+    private client;
+    constructor(client: BladeClient);
+    listApiKeys(): Promise<ApiKeyPublic[]>;
+    createApiKey(name: string): Promise<ApiKeyCreateResponse>;
+    renameApiKey(id: string, name: string): Promise<ApiKeyPublic>;
+    deleteApiKey(id: string): Promise<void>;
+}
+
+interface UserInfo {
+    id: string;
+    username: string;
+    display_name?: string | null;
+    avatar_url: string | null;
+    token: string;
+    auth_type: "casdoor";
+    is_admin?: boolean;
+}
+interface ProvidersResponse {
+    providers: Array<{
+        name: string;
+        authorize_url: string;
+    }>;
+    password_enabled: boolean;
+}
+declare class AuthResource {
+    private client;
+    constructor(client: BladeClient);
+    getProviders(): Promise<ProvidersResponse>;
+    getMe(): Promise<UserInfo>;
+    logout(): Promise<{
+        logout_url: string;
+    }>;
+}
+
+type GisGoalStatus = "pending" | "active" | "done" | "cancelled";
+interface GisGoal {
+    id: string;
+    title: string;
+    description?: string | null;
+    status: GisGoalStatus;
+    priority: 1 | 2 | 3;
+    created_at: string;
+    updated_at: string;
+}
+interface GisResource$1 {
+    id: string;
+    name: string;
+    type: string;
+    quantity: number;
+    unit?: string | null;
+    location?: string | null;
+    note?: string | null;
+    created_at: string;
+    updated_at: string;
+}
+interface GisState {
+    goals: GisGoal[];
+    resources: GisResource$1[];
+    targets: GisTarget[];
+}
+interface GisTarget {
+    id: string;
+    name: string;
+    description?: string | null;
+    location?: string | null;
+    lat?: number | null;
+    lng?: number | null;
+    status: GisGoalStatus;
+    priority: 1 | 2 | 3;
+    created_at: string;
+    updated_at: string;
+}
+interface GisMapCommand {
+    id: string;
+    action: string;
+    payload?: unknown;
+    toolCallId?: string | null;
+    createdAt: number;
+}
+interface RuntimeConfig {
+    sentryDsn: string;
+    gisMapUrl: string;
+    bladeOsPath: string;
+}
+
+declare class GisResource {
+    private client;
+    constructor(client: BladeClient);
+    fetchGisState(sessionId: string, init?: RequestInit): Promise<GisState>;
+    fetchRuntimeConfig(init?: RequestInit): Promise<RuntimeConfig>;
+}
+
+interface DeviceUuidResponse {
+    device_uuid: string;
+}
+interface LicenseValidateResponse {
+    version?: string;
+    expired?: number;
+    validate: boolean;
+    remaining_days?: number;
+    remaining_hours?: number;
+    message?: string;
+    device_uuid?: string;
+}
+interface LicenseStatusResponse {
+    enabled: boolean;
+}
+interface UploadLicenseResponse {
+    success: boolean;
+    message: string;
+    remaining_days?: number;
+}
+declare class LicensesResource {
+    private client;
+    constructor(client: BladeClient);
+    getDeviceUuid(): Promise<DeviceUuidResponse>;
+    validateLicense(): Promise<LicenseValidateResponse>;
+    getLicenseStatus(): Promise<LicenseStatusResponse>;
+    uploadLicense(file: File): Promise<UploadLicenseResponse>;
+}
+
+interface Memory {
+    id: number;
+    type: "feedback" | "experience";
+    content: string;
+    skill_name: string | null;
+    record_type: "memory" | "skill_comment" | null;
+    scope: string | null;
+    owner: string | null;
+    topic: string | null;
+    mem0_id: string | null;
+    superseded_by: number | null;
+    write_reason: string | null;
+    created_at: string;
+    updated_at: string | null;
+    hit_count: number;
+    last_hit_at: string | null;
+    disabled: boolean;
+    source_session: string;
+}
+interface MemoryListResponse {
+    items: Memory[];
+    total: number;
+}
+interface MemoryListParams {
+    keyword?: string;
+    skill_name?: string;
+    type?: string;
+    record_type?: string;
+    scope?: string;
+    owner?: string;
+    topic?: string;
+    status?: string;
+    offset?: number;
+    limit?: number;
+}
+interface MemoryCreateBody {
+    content: string;
+    type?: "feedback" | "experience";
+    skill_name?: string | null;
+    record_type?: "memory" | "skill_comment" | null;
+    scope?: string | null;
+    owner?: string | null;
+    topic?: string | null;
+    mem0_id?: string | null;
+    write_reason?: string | null;
+}
+declare class MemoriesResource {
+    private client;
+    constructor(client: BladeClient);
+    createMemory(body: MemoryCreateBody): Promise<Memory>;
+    listMemories(params?: MemoryListParams): Promise<MemoryListResponse>;
+    getMemory(id: number): Promise<Memory>;
+    updateMemory(id: number, body: Partial<MemoryCreateBody>): Promise<Memory>;
+    patchMemory(id: number, disabled: boolean): Promise<Memory>;
+    deleteMemory(id: number): Promise<{
+        ok: boolean;
+    }>;
+    batchMemories(action: "delete" | "disable" | "enable", ids: number[]): Promise<{
+        ok: boolean;
+        count: number;
+    }>;
+}
+
+declare const ModelOption: arktype_internal_variants_object_ts.ObjectType<{
+    id: string;
+    label: string;
+}, {}>;
+type ModelOption = typeof ModelOption.infer;
+declare const ModelsConfig: arktype_internal_variants_object_ts.ObjectType<{
+    default: string;
+    models: {
+        id: string;
+        label: string;
+    }[];
+}, {}>;
+type ModelsConfig = typeof ModelsConfig.infer;
+declare class ModelsResource {
+    private client;
+    constructor(client: BladeClient);
+    getModelsConfig(init?: RequestInit): Promise<ModelsConfig>;
+}
+
+declare const AgentDriver: arktype_internal_variants_string_ts.StringType<"dify", {}>;
+type AgentDriver = typeof AgentDriver.infer;
+declare const AgentResource: arktype_internal_variants_object_ts.ObjectType<{
+    id: string;
+    name: string;
+    description: string;
+    tags: string[];
+    type: "agent";
+    subtype: "dify";
+    config: Record<string, unknown>;
+}, {}>;
+type AgentResource = typeof AgentResource.infer;
+
+declare const MysqlConfig: arktype_internal_variants_object_ts.ObjectType<{
+    host: string;
+    port: number;
+    user: string;
+    password: string;
+    database: string;
+    charset?: string | undefined;
+    tables?: string[] | undefined;
+    ssl?: boolean | undefined;
+    connection_pool_size?: number | undefined;
+    query_timeout?: number | undefined;
+}, {}>;
+type MysqlConfig = typeof MysqlConfig.infer;
+declare const PostgresqlConfig: arktype_internal_variants_object_ts.ObjectType<{
+    host: string;
+    port: number;
+    user: string;
+    password: string;
+    database: string;
+    schema?: string | undefined;
+    tables?: string[] | undefined;
+    ssl_mode?: string | undefined;
+    connection_pool_size?: number | undefined;
+    query_timeout?: number | undefined;
+}, {}>;
+type PostgresqlConfig = typeof PostgresqlConfig.infer;
+declare const DatabaseDriver: arktype_internal_variants_string_ts.StringType<"mysql" | "postgresql", {}>;
+type DatabaseDriver = typeof DatabaseDriver.infer;
+declare const DatabaseResource: arktype_internal_variants_object_ts.ObjectType<{
+    id: string;
+    name: string;
+    description: string;
+    tags: string[];
+    type: "data";
+    subtype: "db";
+    driver: "mysql" | "postgresql";
+    config: Record<string, unknown>;
+}, {}>;
+type DatabaseResource = typeof DatabaseResource.infer;
+
+declare const DifyKnowledgeConfig: arktype_internal_variants_object_ts.ObjectType<{
+    base_url: string;
+    api_key: string;
+    kg_name: string;
+}, {}>;
+type DifyKnowledgeConfig = typeof DifyKnowledgeConfig.infer;
+declare const KnowledgeDriver: arktype_internal_variants_string_ts.StringType<"dify", {}>;
+type KnowledgeDriver = typeof KnowledgeDriver.infer;
+declare const KnowledgeResource: arktype_internal_variants_object_ts.ObjectType<{
+    id: string;
+    name: string;
+    description: string;
+    tags: string[];
+    type: "knowledge";
+    subtype: "dify";
+    config: Record<string, unknown>;
+}, {}>;
+type KnowledgeResource = typeof KnowledgeResource.infer;
+
+declare const McpToolConfig: arktype_internal_variants_object_ts.ObjectType<{
+    server_url?: string | undefined;
+    command?: string | undefined;
+    args?: string[] | undefined;
+    env?: Record<string, string> | undefined;
+}, {}>;
+type McpToolConfig = typeof McpToolConfig.infer;
+declare const HttpToolConfig: arktype_internal_variants_object_ts.ObjectType<{
+    openapi_json_path: string;
+    base_url?: string | undefined;
+    auth_header?: string | undefined;
+}, {}>;
+type HttpToolConfig = typeof HttpToolConfig.infer;
+declare const ToolDriver: arktype_internal_variants_string_ts.StringType<"mcp" | "http", {}>;
+type ToolDriver = typeof ToolDriver.infer;
+declare const ToolResource: arktype_internal_variants_object_ts.ObjectType<{
+    id: string;
+    name: string;
+    description: string;
+    tags: string[];
+    type: "tools";
+    subtype: "mcp" | "http";
+    config: Record<string, unknown>;
+}, {}>;
+type ToolResource = typeof ToolResource.infer;
+
+declare const REGISTRY_PREFIX = "/api-registry";
+type RawResourceResponse = {
+    id: number | string;
+    type: string;
+    subtype: string;
+    driver?: string | null;
+    name: string;
+    description: string;
+    tags: string[];
+    config: Record<string, unknown>;
+    status?: string | null;
+    status_message?: string | null;
+    last_checked_at?: string | null;
+    extra?: Record<string, unknown>;
+    capabilities?: string[];
+    actions?: unknown[];
+    created_at?: string;
+    updated_at?: string;
+    [key: string]: unknown;
+};
+declare function normalizeResource<T extends Record<string, unknown>>(raw: RawResourceResponse): T;
+type ResourceApi<T extends Record<string, unknown>> = {
+    list(init?: RequestInit): Promise<T[]>;
+    get(id: string, init?: RequestInit): Promise<T>;
+    create(data: Partial<T>, init?: RequestInit): Promise<T>;
+    update(id: string, data: Partial<T>, init?: RequestInit): Promise<T>;
+    delete(id: string, init?: RequestInit): Promise<void>;
+};
+type SkillOrgOption = {
+    id: string;
+    display_name: string;
+    kind: "personal" | "org";
+    is_mine: boolean;
+};
+type SkillOrgListResponse = {
+    orgs: string[];
+    org_options?: SkillOrgOption[];
+};
+declare class RegistryResource {
+    private client;
+    readonly databaseApi: ResourceApi<DatabaseResource>;
+    readonly toolApi: ResourceApi<ToolResource>;
+    readonly knowledgeApi: ResourceApi<KnowledgeResource>;
+    readonly agentApi: ResourceApi<AgentResource>;
+    constructor(client: BladeClient);
+    createResourceApi<T extends Record<string, unknown>>(apiType: string): ResourceApi<T>;
+    listSkillOrgs(): Promise<SkillOrgListResponse>;
+    publishSkill(sessionId: string, org: string, version: string): Promise<{
+        success: boolean;
+        skill_id: string;
+        version: string;
+    }>;
+}
+
+interface PreviewUrlItem {
+    name: string;
+    url: string;
+}
+interface QuickScenario {
+    id: number;
+    name: string;
+    prompt_template: string;
+    skills: string[];
+    preview_urls: PreviewUrlItem[];
+    init_script: string;
+    icon: string;
+    created_at: string;
+    updated_at: string;
+}
+interface BladeHubScenarioResource {
+    resource_id: string;
+    resource_name: string;
+    name: string;
+    description: string;
+    prompt_template: string;
+    skills: string[];
+    preview_urls: PreviewUrlItem[];
+    init_script: string;
+    icon: string;
+    raw?: Record<string, unknown>;
+}
+interface CreateQuickScenarioPayload {
+    name: string;
+    prompt_template?: string;
+    skills?: string[];
+    preview_urls?: PreviewUrlItem[];
+    init_script?: string;
+    icon?: string;
+}
+interface UpdateQuickScenarioPayload extends CreateQuickScenarioPayload {
+}
+declare class ScenariosResource {
+    private client;
+    constructor(client: BladeClient);
+    listQuickScenarios(init?: RequestInit): Promise<QuickScenario[]>;
+    createQuickScenario(payload: CreateQuickScenarioPayload, init?: RequestInit): Promise<QuickScenario>;
+    deleteQuickScenario(scenarioId: number, init?: RequestInit): Promise<{
+        ok: boolean;
+    }>;
+    updateQuickScenario(scenarioId: number, payload: UpdateQuickScenarioPayload, init?: RequestInit): Promise<QuickScenario>;
+    listBladeHubScenarioResources(limit?: number, init?: RequestInit): Promise<BladeHubScenarioResource[]>;
+}
+
+interface BackgroundTask {
+    id: string;
+    command: string;
+    description?: string;
+    status: "running" | "done" | "failed";
+    exit_code?: number | null;
+    elapsed_seconds: number;
+    output_lines_count?: number;
+    output_preview?: string[];
+    output?: string;
+}
+
+declare const TaskStatus: arktype_internal_variants_string_ts.StringType<"pending" | "done" | "failed" | "in_progress" | "skipped", {}>;
+type TaskStatus = typeof TaskStatus.infer;
+declare const Task: arktype_internal_variants_object_ts.ObjectType<{
+    id: string;
+    goal: string;
+    skills: string[];
+    depends_on: string[];
+    status: "pending" | "done" | "failed" | "in_progress" | "skipped";
+    result_summary: string;
+    number: string;
+}, {}>;
+type Task = typeof Task.infer;
+
+interface CreateSessionRequest {
+    intent?: string;
+    template_id?: TemplateId;
+    solution_id?: string;
+    biz_role_id?: string | null;
+    primary_skill_id?: string | null;
+    model?: string | null;
+    software_factory_id?: number | null;
+    memory_enabled?: boolean | null;
+}
+interface CheckpointNode {
+    id: string;
+    parent_id: string | null;
+    content_preview: string;
+    content: string;
+    timestamp: string;
+}
+type ContentPart = {
+    type: "text";
+    text: string;
+} | {
+    type: "image_url";
+    image_url: {
+        url: string;
+        detail?: string;
+    };
+};
+interface HistoryNode {
+    id: string;
+    parent_id: string | null;
+    kind: string;
+    role: string;
+    timestamp: string;
+    preview: string;
+    content: string | ContentPart[];
+    tool_calls: Array<{
+        id?: string;
+        type?: string;
+        function?: {
+            name?: string;
+            arguments?: string;
+        };
+    }> | null;
+    usage: {
+        prompt_tokens?: number;
+        completion_tokens?: number;
+        total_tokens?: number;
+    } | null;
+    total_tokens: number;
+    token_diff: number;
+    is_deprecated: boolean;
+    loop_name: string;
+}
+interface SessionHistory {
+    nodes: HistoryNode[];
+    active_branch: string | null;
+    branches: string[];
+    system_prompt_tokens?: number | null;
+    tools_tokens?: number | null;
+    tokenizer_model?: string | null;
+}
+interface TokenizeResult {
+    model: string;
+    prompt_tokens: number;
+    prompt: string;
+}
+interface PaginatedSessionsResult {
+    items: SessionInfo[];
+    total: number;
+    limit: number;
+    offset: number;
+    content_match_truncated?: boolean;
+}
+interface SkillDevSession {
+    session: SessionInfo;
+    skill_id: string;
+    display_name: string;
+    skill_description: string;
+}
+interface ShareLinkResult {
+    token: string;
+    url: string;
+    expires_at: string | null;
+}
+interface SessionContextStats {
+    tokens_used: number;
+    context_window: number;
+    compaction_ratio: number;
+}
+interface FileEntry {
+    name: string;
+    path: string;
+    is_dir: boolean;
+    created_at: number;
+    tags?: string[];
+}
+type UploadFileEntry = File | {
+    file: File;
+    name: string;
+};
+interface ImportPreviewSkill {
+    name: string;
+    description: string;
+    path: string;
+}
+interface ImportPreviewScenario {
+    scenario?: {
+        name?: string;
+    };
+    skills?: string[];
+    preview_urls?: string[];
+    init_script?: string;
+    generated_at?: string;
+}
+interface ImportPreview {
+    user_messages: string[];
+    turn_count: number;
+    skills: ImportPreviewSkill[];
+    scenario: ImportPreviewScenario | null;
+}
+declare class SessionsResource {
+    private client;
+    constructor(client: BladeClient);
+    private fetchSessionsPage;
+    listSessions(template_id_prefix?: string): Promise<SessionInfo[]>;
+    listSessionsPaginated(params: {
+        limit: number;
+        offset: number;
+        template_id_prefix?: string;
+        q?: string;
+    }): Promise<PaginatedSessionsResult>;
+    listSessionsWithSkillData(): Promise<SkillDevSession[]>;
+    createSession(intent?: string, template_id?: TemplateId, primary_skill_id?: string | null): Promise<{
+        session_id: string;
+    }>;
+    createSessionWithRequest(request: CreateSessionRequest): Promise<{
+        session_id: string;
+    }>;
+    getSession(sessionId: string, init?: RequestInit): Promise<SessionDetail>;
+    updateSession(sessionId: string, payload: {
+        intent?: string;
+    }): Promise<SessionDetail>;
+    pinSession(sessionId: string, pinned: boolean): Promise<SessionInfo>;
+    startReplaySession(sourceSessionId: string, speed?: 1 | 2 | 5): Promise<{
+        session_id: string;
+    }>;
+    updateReplaySession(sessionId: string, payload: {
+        speed?: 1 | 2 | 5;
+        status?: "autonomous";
+    }): Promise<{
+        replay_state: SessionInfo["replay_state"];
+    }>;
+    updateSharing(sessionId: string, shared: boolean): Promise<{
+        shared: boolean;
+    }>;
+    updateSessionMemory(sessionId: string, memoryEnabled: boolean): Promise<{
+        memory_enabled: boolean;
+    }>;
+    createShare(sessionId: string): Promise<ShareLinkResult>;
+    revokeShare(sessionId: string, token: string): Promise<{
+        revoked: boolean;
+    }>;
+    getSharedSession(token: string): Promise<TurnProjection[]>;
+    getSessionTasks(sessionId: string): Promise<Task[]>;
+    getSessionTurns(sessionId: string): Promise<TurnProjection[]>;
+    getSessionContextStats(sessionId: string, init?: RequestInit): Promise<SessionContextStats>;
+    getSessionHistory(sessionId: string, init?: RequestInit): Promise<SessionHistory>;
+    tokenizePrompt(prompt: string, model?: string): Promise<TokenizeResult>;
+    tokenizeMessages(messages: Array<Record<string, unknown>>, options?: {
+        model?: string;
+        add_generation_prompt?: boolean;
+        enable_thinking?: boolean | null;
+        tools?: Array<Record<string, unknown>>;
+    }): Promise<TokenizeResult>;
+    getSessionCheckpoints(sessionId: string, init?: RequestInit): Promise<{
+        nodes: CheckpointNode[];
+        leaf_id: string | null;
+    }>;
+    checkoutSession(sessionId: string, checkpointId: string, position: "before" | "turn_end"): Promise<{
+        id: string;
+        content: string;
+        position: string;
+    }>;
+    rewindSession(sessionId: string, checkpointId: string): Promise<{
+        id: string;
+        content: string;
+    }>;
+    switchBranch(sessionId: string, checkpointId: string): Promise<{
+        id: string;
+        leaf_id: string;
+    }>;
+    deleteSession(sessionId: string): Promise<{
+        deleted: boolean;
+    }>;
+    listBackgroundTasks(sessionId: string, init?: RequestInit): Promise<BackgroundTask[]>;
+    getBackgroundTask(sessionId: string, taskId: string, tail?: number, init?: RequestInit): Promise<BackgroundTask>;
+    stopBackgroundTask(sessionId: string, taskId: string): Promise<{
+        message: string;
+        task?: BackgroundTask | null;
+    }>;
+    listDir(sessionId: string, dirPath: string): Promise<FileEntry[]>;
+    uploadFiles(sessionId: string, dirPath: string, files: FileList | File[] | UploadFileEntry[]): Promise<{
+        uploaded: string[];
+        failed: string[];
+    }>;
+    deleteFile(sessionId: string, filePath: string): Promise<void>;
+    writeFile(sessionId: string, filePath: string, content: string): Promise<{
+        success: boolean;
+    }>;
+    renameFile(sessionId: string, filePath: string, newName: string): Promise<{
+        path: string;
+    }>;
+    copyFile(sessionId: string, filePath: string): Promise<{
+        path: string;
+    }>;
+    shareFile(sessionId: string, sourcePath: string, linkName?: string, shareFolder?: string): Promise<{
+        path: string;
+        target: string;
+    }>;
+    getDownloadDirUrl(sessionId: string, dirPath: string): string;
+    exportSession(sessionId: string): Promise<void>;
+    previewImport(file: File): Promise<ImportPreview>;
+    importSession(file: File, name?: string, solutionId?: string | null): Promise<{
+        session_id: string;
+    }>;
+}
+
+declare const PartnerSkillName: arktype_internal_variants_string_ts.StringType<`${string}/${string}`, {}>;
+type PartnerSkillName = typeof PartnerSkillName.infer;
+declare const PartnerSkillFile: arktype_internal_variants_object_ts.ObjectType<{
+    path: string;
+    content: string;
+}, {}>;
+type PartnerSkillFile = typeof PartnerSkillFile.infer;
+declare const PartnerSkillInstallPayload: arktype_internal_variants_object_ts.ObjectType<{
+    name: `${string}/${string}`;
+    files: {
+        path: string;
+        content: string;
+    }[];
+}, {}>;
+type PartnerSkillInstallPayload = typeof PartnerSkillInstallPayload.infer;
+declare const PartnerSkillInstallResult: arktype_internal_variants_object_ts.ObjectType<{
+    name: `${string}/${string}`;
+    skill_dir: string;
+    file_count: number;
+    overwritten: boolean;
+}, {}>;
+type PartnerSkillInstallResult = typeof PartnerSkillInstallResult.infer;
+
+interface SkillSummary {
+    skill_id: string;
+    display_name: string;
+    dir_name: string;
+    description: string;
+    path: string;
+    references: string[];
+    local: boolean;
+}
+interface SkillSearchResult {
+    skill_id: string;
+    display_name: string;
+    dir_name: string;
+    description: string;
+    local: boolean;
+}
+type SkillDisplayTarget = {
+    skill_id?: string | null;
+    display_name?: string | null;
+    skillId?: string | null;
+    displayName?: string | null;
+};
+declare function skillDisplayName(skill: SkillDisplayTarget): string;
+interface SkillStats {
+    loaded_skill_count: number;
+    loaded_skill_names: string[];
+    remote_configured: boolean;
+    remote_connected: boolean;
+    installed_skill_count: number;
+}
+interface StepSpec {
+    n: number;
+    label: string;
+}
+interface StageSpec {
+    id: string;
+    name: string;
+    steps: StepSpec[];
+}
+interface ParallelMode {
+    id: string;
+    name: string;
+    prompt_hint: string;
+}
+interface SkillDetail extends SkillSummary {
+    content: string;
+    stages?: StageSpec[];
+    parallel_modes?: ParallelMode[];
+}
+
+interface GlobalSkillStats {
+    remote_configured: boolean;
+    remote_connected: boolean;
+    installed_skill_count: number;
+}
+declare class SkillsResource {
+    private client;
+    constructor(client: BladeClient);
+    listSkills(init?: RequestInit): Promise<SkillSummary[]>;
+    listSessionSkills(sessionId: string, init?: RequestInit): Promise<SkillSummary[]>;
+    resyncSkills(sessionId: string, init?: RequestInit): Promise<{
+        detail?: string;
+        copied: number;
+        removed: number;
+        preserved: number;
+    }>;
+    searchSkills(query: string, limit?: number, init?: RequestInit): Promise<SkillSearchResult[]>;
+    getSkillStats(sessionId: string, init?: RequestInit): Promise<SkillStats>;
+    getGlobalSkillStats(init?: RequestInit): Promise<GlobalSkillStats>;
+    getSkill(skillName: string, init?: RequestInit): Promise<SkillDetail>;
+    installPartnerSkill(sessionId: string, payload: PartnerSkillInstallPayload, init?: RequestInit): Promise<PartnerSkillInstallResult>;
+}
+
+interface SoftwareFactoryTopicModule {
+    software_id: number;
+    topic_key: string;
+    topic_title: string;
+    topic_description: string;
+    module_key: string;
+    module_name: string;
+    required: boolean;
+    enabled: boolean;
+    order_index: number;
+    session_id: string | null;
+    sub_key: string;
+    label: string;
+    opt: string;
+    assignee_name: string | null;
+    assignee_type: string | null;
+    timeline_json: string;
+    created_at: string;
+    updated_at: string;
+}
+interface SoftwareFactoryModuleBlueprint {
+    key: string;
+    name: string;
+    required: boolean;
+    order_index: number;
+}
+interface SoftwareFactorySoftware {
+    id: number;
+    name: string;
+    description: string;
+    issue_session_id: string | null;
+    created_at: string;
+    updated_at: string;
+    module_blueprints: SoftwareFactoryModuleBlueprint[];
+    topic_modules: SoftwareFactoryTopicModule[];
+}
+interface CreateSoftwareFactorySoftwarePayload {
+    name: string;
+    description?: string;
+}
+interface SoftwareFactorySharedFile {
+    id: number;
+    software_id: number;
+    module_key: string;
+    module_name: string;
+    session_id: string;
+    file_path: string;
+    file_name: string;
+    created_at: string;
+    updated_at: string;
+}
+interface CreateSoftwareFactorySharedFilePayload {
+    module_key: string;
+    session_id: string;
+    file_path: string;
+    file_name?: string;
+}
+interface SoftwareFactoryTopic {
+    id: number;
+    software_id: number;
+    topic_key: string;
+    title: string;
+    description: string;
+    order_index: number;
+    created_at: string;
+    updated_at: string;
+}
+interface CodingTask {
+    name: string;
+    path: string;
+    files: string[];
+}
+interface CodingTaskTopic {
+    topic_name: string;
+    tasks: CodingTask[];
+}
+declare class SoftwareFactoryResource {
+    private client;
+    constructor(client: BladeClient);
+    listSoftware(): Promise<SoftwareFactorySoftware[]>;
+    getSoftware(softwareId: number): Promise<SoftwareFactorySoftware>;
+    deleteSoftware(softwareId: number): Promise<{
+        ok: boolean;
+    }>;
+    createSoftware(payload: CreateSoftwareFactorySoftwarePayload): Promise<SoftwareFactorySoftware>;
+    updateSoftware(softwareId: number, payload: {
+        name?: string;
+        description?: string;
+    }): Promise<SoftwareFactorySoftware>;
+    bindTopicModuleSession(softwareId: number, topicKey: string, moduleKey: string, sessionId: string, assignee?: {
+        name?: string | null;
+        type?: string | null;
+    }): Promise<SoftwareFactorySoftware>;
+    submitModuleForReview(softwareId: number, topicKey: string, moduleKey: string, subKey?: string): Promise<SoftwareFactoryTopicModule>;
+    completeModule(softwareId: number, topicKey: string, moduleKey: string, subKey?: string): Promise<SoftwareFactoryTopicModule>;
+    reopenModule(softwareId: number, topicKey: string, moduleKey: string, subKey?: string): Promise<SoftwareFactoryTopicModule>;
+    listSharedFiles(softwareId: number): Promise<SoftwareFactorySharedFile[]>;
+    createSharedFile(softwareId: number, payload: CreateSoftwareFactorySharedFilePayload): Promise<SoftwareFactorySharedFile>;
+    uploadSoftwareDocuments(softwareId: number, files: File[]): Promise<{
+        uploaded: string[];
+        failed: string[];
+    }>;
+    ensureIssueSession(softwareId: number): Promise<{
+        session_id: string;
+    }>;
+    listCodingTasks(softwareId: number): Promise<{
+        topics: CodingTaskTopic[];
+    }>;
+    startCoding(softwareId: number, payload: {
+        topic_name: string;
+        task_paths: string[];
+        assignee_name?: string | null;
+        assignee_type?: string | null;
+    }): Promise<{
+        session_id: string;
+        topic_name: string;
+        task_names: string[];
+    }>;
+    readShareFileContent(softwareId: number, path: string): Promise<{
+        content: string;
+    }>;
+    syncShare(softwareId: number): Promise<{
+        synced_sessions: string[];
+    }>;
+    listTopics(softwareId: number): Promise<SoftwareFactoryTopic[]>;
+    replaceTopics(softwareId: number, topics: Array<{
+        topic_key: string;
+        title: string;
+        description?: string;
+    }>): Promise<SoftwareFactoryTopic[]>;
+    getFactoryExportUrl(softwareId: number): string;
+    importFactory(file: File): Promise<{
+        software_id: number;
+        session_id_map: Record<string, string>;
+    }>;
+}
+
+declare class SolutionsResource {
+    private client;
+    constructor(client: BladeClient);
+    fetchSolutions(): Promise<Solution[]>;
+    fetchSolutionFile(solutionId: string, filePath: string): Promise<string>;
+    fetchSolutionBizRoles(solutionId: string, userId?: string): Promise<BizRole[]>;
+}
+
+declare class UserPreferencesResource {
+    private client;
+    constructor(client: BladeClient);
+    getUserPreference(key: string): Promise<string | null>;
+    setUserPreference(key: string, value: string): Promise<void>;
+}
+
+interface PortMapping {
+    host_port: number;
+    container_port: number;
+}
+interface VibeCodingSessionInfo {
+    session_id: string;
+    name: string;
+    coding_template: string;
+    test_port: number;
+    deploy_port: number | null;
+    test_service: string | null;
+    deploy_service: string | null;
+    deploy_version: string | null;
+    max_version: string | null;
+}
+interface VibeCodingSessionStatus extends VibeCodingSessionInfo {
+}
+interface VibeCodingDebugSessionStatus {
+    session_id: string;
+    running: boolean;
+    test_running: boolean;
+    ports: PortMapping[];
+}
+interface VibeCodingDeployStatus {
+    deploy_running: boolean;
+    deploy_version: string | null;
+    deploy_port: number | null;
+}
+interface VibeCodingDeployRecord {
+    version: string;
+    release_path: string;
+    note: string | null;
+    created_at: string;
+}
+type DeployBumpMode = "major" | "minor" | "patch";
+interface CreateVibeCodingSessionParams {
+    name?: string;
+    coding_template?: string;
+    model?: string | null;
+}
+interface CreateVibeCodingSessionResult {
+    session_id: string;
+    test_port: number;
+}
+declare class VibeCodingResource {
+    private client;
+    constructor(client: BladeClient);
+    createVibeCodingSession(params: CreateVibeCodingSessionParams): Promise<CreateVibeCodingSessionResult>;
+    listVibeCodingSessionInfos(): Promise<VibeCodingSessionInfo[]>;
+    getVibeCodingSessionDebugStatus(sessionId: string): Promise<VibeCodingDebugSessionStatus>;
+    getVibeCodingSessionStatus(sessionId: string): Promise<VibeCodingSessionStatus>;
+    getVibeCodingDeployStatus(sessionId: string): Promise<VibeCodingDeployStatus>;
+    startVibeCodingService(sessionId: string): Promise<{
+        ok: boolean;
+        details: string;
+    }>;
+    stopVibeCodingService(sessionId: string): Promise<{
+        ok: boolean;
+        details: string;
+    }>;
+    updateVibeCodingDebugService(sessionId: string): Promise<{
+        ok: boolean;
+        session_id: string;
+    }>;
+    deployVibeCodingSession(sessionId: string, note?: string, bump?: DeployBumpMode): Promise<{
+        ok: boolean;
+        version: string;
+        deploy_port: number;
+        release_dir: string;
+    }>;
+    listVibeCodingDeployVersions(sessionId: string): Promise<VibeCodingDeployRecord[]>;
+    startVibeCodingDeployService(sessionId: string, version?: string): Promise<{
+        ok: boolean;
+        details: string;
+        deploy_version: string;
+        release_dir: string;
+    }>;
+    stopVibeCodingDeployService(sessionId: string, version?: string): Promise<{
+        ok: boolean;
+        details: string;
+    }>;
+    deleteVibeCodingDeployVersion(sessionId: string, version: string): Promise<{
+        ok: boolean;
+    }>;
+    deleteVibeCodingSession(sessionId: string): Promise<{
+        ok: boolean;
+    }>;
+    probeVibeCodingService(sessionId: string, url: string): Promise<{
+        reachable: boolean;
+    }>;
+    exportVibeCodingSession(sessionId: string): Promise<void>;
+    importVibeCodingSession(file: File, name?: string, codingTemplate?: string): Promise<CreateVibeCodingSessionResult>;
+}
+
+interface AuthOptions {
+    token?: string | (() => string | null | undefined);
+}
+
+type AsrAudioPayload = ArrayBuffer | Uint8Array;
+declare namespace ChatSendPayloadSchema {
+    type SessionId = string;
+    type Mode = (("planning" | "executing") | null);
+    type AskuserAnswer = ({
+        [k: string]: unknown;
+    } | null);
+    type Model = (string | null);
+    type FromStep = (number | string | null);
+    type Quotes = (unknown[] | null);
+    type DeprecateEntryIds = (string[] | null);
+    type ReplayDecision = (string | null);
+    type RuntimeEnv = ({
+        [k: string]: string;
+    } | null);
+    interface ChatSendPayload {
+        session_id: SessionId;
+        message: Message;
+        mode?: Mode;
+        askuser_answer?: AskuserAnswer;
+        model?: Model;
+        whatif?: (WhatIfPayload | null);
+        replay_decision?: ReplayDecision;
+        runtime_env?: RuntimeEnv;
+        [k: string]: unknown;
+    }
+    interface Message {
+        [k: string]: unknown;
+    }
+    interface WhatIfPayload {
+        from_step?: FromStep;
+        quotes?: Quotes;
+        deprecate_entry_ids?: DeprecateEntryIds;
+        [k: string]: unknown;
+    }
+}
+type ChatSendPayload = ChatSendPayloadSchema.ChatSendPayload;
+declare namespace ChatStopPayloadSchema {
+    type SessionId = string;
+    interface ChatStopPayload {
+        session_id: SessionId;
+        [k: string]: unknown;
+    }
+}
+type ChatStopPayload = ChatStopPayloadSchema.ChatStopPayload;
+declare namespace ChatCompactPayloadSchema {
+    type SessionId = string;
+    interface ChatCompactPayload {
+        session_id: SessionId;
+        [k: string]: unknown;
+    }
+}
+type ChatCompactPayload = ChatCompactPayloadSchema.ChatCompactPayload;
+declare namespace SessionSubscribePayloadSchema {
+    type SessionId = string;
+    interface SessionSubscribePayload {
+        session_id: SessionId;
+        [k: string]: unknown;
+    }
+}
+type SessionSubscribePayload = SessionSubscribePayloadSchema.SessionSubscribePayload;
+declare namespace SessionUnsubscribePayloadSchema {
+    type SessionId = string;
+    interface SessionUnsubscribePayload {
+        session_id: SessionId;
+        [k: string]: unknown;
+    }
+}
+type SessionUnsubscribePayload = SessionUnsubscribePayloadSchema.SessionUnsubscribePayload;
+declare namespace ChatStartPayloadSchema {
+    type SessionId = (string | null);
+    interface ChatStartPayload {
+        session_id?: SessionId;
+        [k: string]: unknown;
+    }
+}
+type ChatStartPayload = ChatStartPayloadSchema.ChatStartPayload;
+declare namespace ChatEndPayloadSchema {
+    type SessionId = (string | null);
+    type Status = (string | null);
+    interface ChatEndPayload {
+        session_id?: SessionId;
+        status?: Status;
+        [k: string]: unknown;
+    }
+}
+type ChatEndPayload = ChatEndPayloadSchema.ChatEndPayload;
+declare namespace SessionUpdatedPayloadSchema {
+    type SessionId = string;
+    type Model = (string | null);
+    type ReplayState = ({
+        [k: string]: unknown;
+    } | null);
+    type Intent = (string | null);
+    interface SessionUpdatedPayload {
+        session_id: SessionId;
+        model?: Model;
+        replay_state?: ReplayState;
+        intent?: Intent;
+        [k: string]: unknown;
+    }
+}
+type SessionUpdatedPayload = SessionUpdatedPayloadSchema.SessionUpdatedPayload;
+declare namespace WorkspaceFilesChangedPayloadSchema {
+    type SessionId = string;
+    type FilePath = (string | null);
+    interface WorkspaceFilesChangedPayload {
+        session_id: SessionId;
+        file_path?: FilePath;
+        [k: string]: unknown;
+    }
+}
+type WorkspaceFilesChangedPayload = WorkspaceFilesChangedPayloadSchema.WorkspaceFilesChangedPayload;
+declare namespace SystemErrorPayloadSchema {
+    type Message = string;
+    type SessionId = (string | null);
+    type Code = (string | number | null);
+    interface SystemErrorPayload {
+        message: Message;
+        session_id?: SessionId;
+        code?: Code;
+        detail?: Detail;
+        [k: string]: unknown;
+    }
+    interface Detail {
+        [k: string]: unknown;
+    }
+}
+type SystemErrorPayload = SystemErrorPayloadSchema.SystemErrorPayload;
+declare namespace SystemNotificationPayloadSchema {
+    type SessionId = (string | null);
+    type NotificationType = string;
+    type Title = string;
+    type Detail = (string | null);
+    type Status = (string | null);
+    type Metadata = ({
+        [k: string]: unknown;
+    } | null);
+    interface SystemNotificationPayload {
+        session_id?: SessionId;
+        notification_type: NotificationType;
+        title: Title;
+        detail?: Detail;
+        status?: Status;
+        metadata?: Metadata;
+        [k: string]: unknown;
+    }
+}
+type SystemNotificationPayload = SystemNotificationPayloadSchema.SystemNotificationPayload;
+declare namespace TurnProjectionPayloadSchema {
+    type Id = string;
+    type Sequence = number;
+    type TurnId = string;
+    type LoopId = string;
+    type TurnKind = ("message" | "compaction");
+    type Role = ("user" | "assistant" | "system");
+    type Status = ("streaming" | "completed" | "paused" | "failed" | "interrupted");
+    type Type = ("text" | "thinking" | "tool_use" | "tool_result" | "tool_ui" | "tool_bridge" | "system_notification" | "mode_change" | "planning_enter" | "planning_exit" | "plan_status" | "ask_user_answer");
+    type Content = string;
+    type ToolCallId = (string | null);
+    type ToolName = (string | null);
+    type DisplayName = (string | null);
+    type Blocks = ContentBlock[];
+    type Id1 = string;
+    type ToolName1 = string;
+    type DisplayName1 = string;
+    type Arguments = string;
+    type Status1 = ("pending" | "done" | "error" | "cancelled" | "awaiting_answer");
+    type DurationMs = (number | null);
+    type ChildLoopName = string;
+    type ChildToolCallId = string;
+    type Description = (string | null);
+    type ToolCalls = ToolCallProjection[];
+    type Model = (string | null);
+    type Usage = ({
+        [k: string]: unknown;
+    } | null);
+    type DurationMs1 = number;
+    type StartedAt = (string | null);
+    type ContextWindow = number;
+    type MemoryRefs = (MemoryRef[] | null);
+    type Id2 = number;
+    type ContentPreview = string;
+    type SkillName = (string | null);
+    type ParentForkToolCallId = (string | null);
+    type CompactionId = (string | null);
+    type SummaryPreview = (string | null);
+    type SummaryFull = (string | null);
+    type ArchivedCount = (number | null);
+    type TokensBefore = (number | null);
+    type TokensAfter = (number | null);
+    type SavedRatio = (number | null);
+    type Trigger = (("auto" | "manual" | "forced_retry") | null);
+    type FailureReason = (string | null);
+    type FallbackApplied = (boolean | null);
+    type SessionId = string;
+    type SolutionId = (string | null);
+    type TemplateId = (string | null);
+    interface TurnProjectionPayload {
+        id: Id;
+        sequence: Sequence;
+        turn_id: TurnId;
+        loop_id: LoopId;
+        kind?: TurnKind;
+        role: Role;
+        status: Status;
+        blocks?: Blocks;
+        tool_calls?: ToolCalls;
+        model?: Model;
+        usage?: Usage;
+        duration_ms?: DurationMs1;
+        started_at?: StartedAt;
+        context_window?: ContextWindow;
+        memory_refs?: MemoryRefs;
+        parent_fork_tool_call_id?: ParentForkToolCallId;
+        compaction_id?: CompactionId;
+        summary_preview?: SummaryPreview;
+        summary_full?: SummaryFull;
+        archived_count?: ArchivedCount;
+        tokens_before?: TokensBefore;
+        tokens_after?: TokensAfter;
+        saved_ratio?: SavedRatio;
+        trigger?: Trigger;
+        failure_reason?: FailureReason;
+        fallback_applied?: FallbackApplied;
+        session_id: SessionId;
+        solution_id?: SolutionId;
+        template_id?: TemplateId;
+        [k: string]: unknown;
+    }
+    interface ContentBlock {
+        type: Type;
+        content?: Content;
+        tool_call_id?: ToolCallId;
+        tool_name?: ToolName;
+        display_name?: DisplayName;
+        [k: string]: unknown;
+    }
+    interface ToolCallProjection {
+        id: Id1;
+        tool_name: ToolName1;
+        display_name: DisplayName1;
+        arguments?: Arguments;
+        status?: Status1;
+        result?: Result;
+        duration_ms?: DurationMs;
+        pending_question_ref?: (PendingQuestionRef | null);
+        [k: string]: unknown;
+    }
+    interface Result {
+        [k: string]: unknown;
+    }
+    interface PendingQuestionRef {
+        child_loop_name: ChildLoopName;
+        child_tool_call_id: ChildToolCallId;
+        description?: Description;
+        [k: string]: unknown;
+    }
+    interface MemoryRef {
+        id: Id2;
+        content_preview: ContentPreview;
+        skill_name?: SkillName;
+        [k: string]: unknown;
+    }
+}
+type TurnProjectionPayload = TurnProjectionPayloadSchema.TurnProjectionPayload;
+declare namespace PatchEnvelopePayloadSchema {
+    type Sequence = number;
+    type TurnId = string;
+    type LoopId = string;
+    type PatchType = string;
+    type SessionId = string;
+    interface PatchEnvelopePayload {
+        sequence: Sequence;
+        turn_id: TurnId;
+        loop_id: LoopId;
+        patch_type: PatchType;
+        data?: Data;
+        session_id: SessionId;
+        [k: string]: unknown;
+    }
+    interface Data {
+        [k: string]: unknown;
+    }
+}
+type PatchEnvelopePayload = PatchEnvelopePayloadSchema.PatchEnvelopePayload;
+declare namespace AsrReadyPayloadSchema {
+    type RequestId = string;
+    type Provider = string;
+    interface AsrReadyPayload {
+        request_id: RequestId;
+        provider: Provider;
+        [k: string]: unknown;
+    }
+}
+type AsrReadyPayload = AsrReadyPayloadSchema.AsrReadyPayload;
+declare namespace AsrTextPayloadSchema {
+    type Text = string;
+    type RequestId = (string | null);
+    interface AsrTextPayload {
+        text: Text;
+        request_id?: RequestId;
+        [k: string]: unknown;
+    }
+}
+type AsrTextPayload = AsrTextPayloadSchema.AsrTextPayload;
+declare namespace AsrClosedPayloadSchema {
+    type RequestId = string;
+    interface AsrClosedPayload {
+        request_id: RequestId;
+        [k: string]: unknown;
+    }
+}
+type AsrClosedPayload = AsrClosedPayloadSchema.AsrClosedPayload;
+declare namespace AsrErrorPayloadSchema {
+    type Message = string;
+    type RequestId = (string | null);
+    interface AsrErrorPayload {
+        message: Message;
+        request_id?: RequestId;
+        [k: string]: unknown;
+    }
+}
+type AsrErrorPayload = AsrErrorPayloadSchema.AsrErrorPayload;
+declare namespace VibeLogsLinePayloadSchema {
+    type SessionId = string;
+    type Line = string;
+    interface VibeLogsLinePayload {
+        session_id: SessionId;
+        line: Line;
+        [k: string]: unknown;
+    }
+}
+type VibeLogsLinePayload = VibeLogsLinePayloadSchema.VibeLogsLinePayload;
+declare namespace VibeLogsEndPayloadSchema {
+    type SessionId = string;
+    interface VibeLogsEndPayload {
+        session_id: SessionId;
+        [k: string]: unknown;
+    }
+}
+type VibeLogsEndPayload = VibeLogsEndPayloadSchema.VibeLogsEndPayload;
+declare namespace ChatCompactAckSchema {
+    type Status = string;
+    type Message = (string | null);
+    type Code = (string | number | null);
+    interface ChatCompactAck {
+        status: Status;
+        message?: Message;
+        code?: Code;
+        [k: string]: unknown;
+    }
+}
+type ChatCompactAck = ChatCompactAckSchema.ChatCompactAck;
+interface ClientToServerEvents {
+    "chat:send": (payload: ChatSendPayload) => void;
+    "chat:stop": (payload: ChatStopPayload) => void;
+    "chat:compact": (payload: ChatCompactPayload, ack: (response: ChatCompactAck) => void) => void;
+    "session:subscribe": (payload: SessionSubscribePayload) => void;
+    "session:unsubscribe": (payload: SessionUnsubscribePayload) => void;
+    "asr:start": (payload: unknown) => void;
+    "asr:audio": (payload: AsrAudioPayload) => void;
+    "asr:stop": (payload: unknown) => void;
+    "vibe:logs:start": (payload: unknown) => void;
+    "vibe:logs:stop": (payload: unknown) => void;
+    "gis.event.analysis.request": (payload: unknown, ack: (response: unknown) => void) => void;
+}
+interface ServerToClientEvents {
+    "chat:start": (payload: ChatStartPayload) => void;
+    "chat:end": (payload: ChatEndPayload) => void;
+    "session:updated": (payload: SessionUpdatedPayload) => void;
+    "workspace:files_changed": (payload: WorkspaceFilesChangedPayload) => void;
+    "system:error": (payload: SystemErrorPayload) => void;
+    "system:notification": (payload: SystemNotificationPayload) => void;
+    "turn:start": (payload: TurnProjectionPayload) => void;
+    "turn:patch": (payload: PatchEnvelopePayload) => void;
+    "turn:end": (payload: TurnProjectionPayload) => void;
+    "task:updated": (payload: unknown) => void;
+    "task:synced": (payload: unknown) => void;
+    "artifact:created": (payload: unknown) => void;
+    "artifact:updated": (payload: unknown) => void;
+    "bg:started": (payload: unknown) => void;
+    "bg:tasks_completed": (payload: unknown) => void;
+    "skills:changed": (payload: unknown) => void;
+    "session:rewind": (payload: unknown) => void;
+    "asr:ready": (payload: AsrReadyPayload) => void;
+    "asr:partial": (payload: AsrTextPayload) => void;
+    "asr:final": (payload: AsrTextPayload) => void;
+    "asr:closed": (payload: AsrClosedPayload) => void;
+    "asr:error": (payload: AsrErrorPayload) => void;
+    "vibe:logs:line": (payload: VibeLogsLinePayload) => void;
+    "vibe:logs:end": (payload: VibeLogsEndPayload) => void;
+    "replay:input_mismatch": (payload: unknown) => void;
+}
+
+type TypedSocket = Socket<ServerToClientEvents, ClientToServerEvents>;
+interface CreateSocketOptions extends AuthOptions {
+    baseUrl: string;
+    path?: string;
+}
+declare function createSocket(options: CreateSocketOptions): TypedSocket;
+
+interface BladeClientOptions {
+    baseUrl: string;
+    token?: string | (() => string | null | undefined);
+    fetchImpl?: typeof fetch;
+    onRefreshSuccess?: () => void | Promise<void>;
+}
+declare class BladeClient {
+    private refreshPromise;
+    private socketInstance;
+    private storeRestTokenResolver;
+    private storeSocketTokenResolver;
+    readonly options: BladeClientOptions;
+    readonly apiKeys: ApiKeysResource;
+    readonly auth: AuthResource;
+    readonly gis: GisResource;
+    readonly licenses: LicensesResource;
+    readonly memories: MemoriesResource;
+    readonly models: ModelsResource;
+    readonly registry: RegistryResource;
+    readonly scenarios: ScenariosResource;
+    readonly sessions: SessionsResource;
+    readonly skills: SkillsResource;
+    readonly softwareFactory: SoftwareFactoryResource;
+    readonly solutions: SolutionsResource;
+    readonly userPreferences: UserPreferencesResource;
+    readonly vibeCoding: VibeCodingResource;
+    constructor(options: BladeClientOptions);
+    _attachStoreRestTokenResolver(fn: () => string | null | undefined): void;
+    _attachStoreSocketTokenResolver(fn: () => string | null | undefined): void;
+    setBaseUrl(baseUrl: string): void;
+    socket(): TypedSocket;
+    json<T>(method: HttpMethod, path: string, body?: unknown): Promise<T>;
+    jsonFromInit<T>(path: string, init?: RequestInit): Promise<T>;
+    text(method: HttpMethod, path: string): Promise<string>;
+    textFromInit(path: string, init?: RequestInit): Promise<string>;
+    responseFromInit(path: string, init?: RequestInit): Promise<Response>;
+    blob(method: HttpMethod, path: string): Promise<Blob>;
+    formData(method: HttpMethod, path: string, form: FormData, options?: {
+        expectOk?: boolean;
+    }): Promise<Response>;
+    fetch(method: HttpMethod, path: string, init?: BladeFetchInit, isRetry?: boolean): Promise<Response>;
+    buildAuthedUrl(path: string): string;
+    private buildHeaders;
+    private buildUrl;
+    private baseUrlWithTrailingSlash;
+    private toBaseRelativePath;
+    private isSameBackendUrl;
+    private shouldRefreshFor401;
+    private hasExplicitBearerToken;
+    private tryRefresh;
+    private resolveTokenForUrl;
+    private resolveRestToken;
+    private resolveSocketToken;
+    private resolveToken;
+}
+
+export { type PreviewUrlItem as $, type ApiKeyCreateResponse as A, BladeApiError as B, type CreateVibeCodingSessionResult as C, type DeviceUuidResponse as D, type CreateSoftwareFactorySharedFilePayload as E, type CreateSoftwareFactorySoftwarePayload as F, type FileEntry as G, GisResource as H, type GlobalSkillStats as I, type HistoryNode as J, type HttpMethod as K, LicensesResource as L, type ImportPreview as M, type ImportPreviewScenario as N, type ImportPreviewSkill as O, type PortMapping as P, MemoriesResource as Q, type Memory as R, type MemoryCreateBody as S, type MemoryListParams as T, type UploadLicenseResponse as U, VibeCodingResource as V, type MemoryListResponse as W, ModelOption as X, ModelsConfig as Y, ModelsResource as Z, type PaginatedSessionsResult as _, type LicenseStatusResponse as a, type StageSpec as a$, type ProvidersResponse as a0, type QuickScenario as a1, REGISTRY_PREFIX as a2, RegistryResource as a3, type ResourceApi as a4, ScenariosResource as a5, type ServerToClientEvents as a6, type SessionContextStats as a7, type SessionHistory as a8, type SessionUpdatedPayload as a9, type SkillDetail as aA, type SkillStats as aB, type SkillSummary as aC, type SkillSearchResult as aD, PartnerSkillInstallPayload as aE, PartnerSkillInstallResult as aF, type BackgroundTask as aG, type GisGoal as aH, type GisResource$1 as aI, type GisTarget as aJ, type GisMapCommand as aK, Task as aL, AgentDriver as aM, AgentResource as aN, DatabaseDriver as aO, DatabaseResource as aP, DifyKnowledgeConfig as aQ, type GisGoalStatus as aR, HttpToolConfig as aS, KnowledgeDriver as aT, KnowledgeResource as aU, McpToolConfig as aV, MysqlConfig as aW, type ParallelMode as aX, PartnerSkillFile as aY, PartnerSkillName as aZ, PostgresqlConfig as a_, SessionsResource as aa, type ShareLinkResult as ab, type SkillDevSession as ac, type SkillOrgListResponse as ad, type SkillOrgOption as ae, SkillsResource as af, type SoftwareFactoryModuleBlueprint as ag, SoftwareFactoryResource as ah, type SoftwareFactorySharedFile as ai, type SoftwareFactorySoftware as aj, type SoftwareFactoryTopic as ak, type SoftwareFactoryTopicModule as al, SolutionsResource as am, type SystemErrorPayload as an, type SystemNotificationPayload as ao, type TokenizeResult as ap, type TurnProjectionPayload as aq, type TypedSocket as ar, type UpdateQuickScenarioPayload as as, type UploadFileEntry as at, type UserInfo as au, UserPreferencesResource as av, createSocket as aw, normalizeResource as ax, type GisState as ay, type RuntimeConfig as az, type LicenseValidateResponse as b, type StepSpec as b0, TaskStatus as b1, ToolDriver as b2, ToolResource as b3, skillDisplayName as b4, type VibeCodingDeployStatus as c, type VibeCodingDebugSessionStatus as d, type VibeCodingSessionStatus as e, type VibeCodingDeployRecord as f, type VibeCodingSessionInfo as g, type CreateVibeCodingSessionParams as h, type DeployBumpMode as i, type ApiKeyPublic as j, ApiKeysResource as k, AuthResource as l, BladeClient as m, type BladeClientOptions as n, type BladeFetchInit as o, type BladeHubScenarioResource as p, type ChatEndPayload as q, type ChatSendPayload as r, type CheckpointNode as s, type ClientToServerEvents as t, type CodingTask as u, type CodingTaskTopic as v, type ContentPart as w, type CreateQuickScenarioPayload as x, type CreateSessionRequest as y, type CreateSocketOptions as z };