@kmlckj/aios-agent-server-sdk 0.0.0-stage → 0.0.2

package/dist/shared/plugin-market-api.d.ts

@@ -0,0 +1,120 @@
+export type PluginMarketKind = 'CLOUD' | 'LOCAL' | 'MCP' | 'OFFICIAL';
+export type PluginMarketScope = 'PLATFORM' | 'ENTERPRISE' | 'MINE';
+export interface PluginMarketCategory {
+    categoryId: string | null;
+    categoryCode: string;
+    categoryName: string;
+    sortNo: number;
+}
+export interface PluginMarketTag {
+    tagId: string;
+    name: string;
+}
+export interface PluginMarketItem {
+    recordId: string;
+    pluginId: string;
+    name: string;
+    summary: string;
+    iconUrl: string | null;
+    author: string;
+    isOfficial: boolean;
+    pluginKind: PluginMarketKind;
+    pluginKindLabel: string;
+    categoryCode: string | null;
+    categoryName: string | null;
+    version: string | null;
+    publishedAt: string | null;
+    tags: PluginMarketTag[];
+}
+export interface PluginMarketTool {
+    toolId: string;
+    name: string;
+    description: string | null;
+    functionName: string;
+    inputSchema: Record<string, unknown>;
+    outputSchema?: Record<string, unknown>;
+    exampleRequestJson?: string | null;
+    exampleResponseJson?: string | null;
+}
+export interface PluginMarketDetail extends PluginMarketItem {
+    description: string;
+    tools: PluginMarketTool[];
+    snapshotAvailable: boolean;
+}
+export interface PluginMarketListQuery {
+    scope?: Exclude<PluginMarketScope, 'MINE'>;
+    keyword?: string;
+    categoryCode?: string;
+    pluginKind?: PluginMarketKind;
+    page?: number;
+    pageSize?: number;
+}
+export interface PluginMarketListResult {
+    items: PluginMarketItem[];
+    total: number;
+}
+export type PluginAuthorizationComponentType = 'TEXT' | 'PASSWORD' | 'TOKEN' | 'URL' | 'EMAIL' | 'SELECT';
+export interface PluginAuthorizationFieldOption {
+    label?: string | null;
+    value: string;
+}
+export interface PluginAuthorizationField {
+    key: string;
+    label: string;
+    componentType: PluginAuthorizationComponentType;
+    valueType: 'SECRET';
+    required: boolean;
+    placeholder?: string | null;
+    helpText?: string | null;
+    validation?: Record<string, unknown> | null;
+    options?: PluginAuthorizationFieldOption[] | null;
+    order: number;
+}
+export interface PluginAuthorizationDefinition {
+    definitionId?: string | null;
+    namespace?: string | null;
+    mode: 'NONE' | 'USER_CREDENTIAL' | 'CALLBACK';
+    schemaVersion: number;
+    title?: string | null;
+    description?: string | null;
+    helpUrl?: string | null;
+    fields: PluginAuthorizationField[];
+    verificationToolKey?: string | null;
+    status?: string | null;
+}
+export type PluginAuthorizationStatusValue = 'NOT_REQUIRED' | 'UNSET' | 'ACTIVE' | 'UNVERIFIED' | 'INVALID' | 'EXPIRED' | 'NEEDS_UPDATE' | 'REVOKED';
+export interface PluginAuthorizationStatus {
+    callbackPageUrl?: string;
+    pluginId: string;
+    authorizationId?: string | null;
+    authorizationRequired: boolean;
+    entitled: boolean;
+    setupAllowed: boolean;
+    status: PluginAuthorizationStatusValue;
+    needsUpdate: boolean;
+    definition: PluginAuthorizationDefinition;
+    maskedFields: Record<string, string>;
+    lastVerifiedAt?: string | null;
+}
+export type PluginAuthorizationFieldOperation = {
+    operation: 'KEEP';
+} | {
+    operation: 'CLEAR';
+} | {
+    operation: 'SET';
+    value: string;
+};
+export interface PluginAuthorizationSaveRequest {
+    schemaVersion: number;
+    fields: Record<string, PluginAuthorizationFieldOperation>;
+}
+export interface PluginMarketApi {
+    listCategories: () => Promise<PluginMarketCategory[]>;
+    list: (query?: PluginMarketListQuery) => Promise<PluginMarketListResult>;
+    getDetail: (recordId: string) => Promise<PluginMarketDetail>;
+    prepare: (pluginId: string, recordId: string, resourceVersion: string) => Promise<PluginMarketDetail>;
+    getAuthorization: (pluginId: string) => Promise<PluginAuthorizationStatus>;
+    saveAuthorization: (pluginId: string, request: PluginAuthorizationSaveRequest) => Promise<PluginAuthorizationStatus>;
+    revokeAuthorization: (pluginId: string) => Promise<void>;
+    verifyAuthorization: (pluginId: string) => Promise<PluginAuthorizationStatus>;
+}

package/dist/shared/profession-market-api.d.ts

@@ -0,0 +1,96 @@
+export type ProfessionForm = 'EXPERT' | 'EXPERT_TEAM';
+export type ProfessionPriceType = 'FREE' | 'PAID';
+export interface ProfessionMarketCategory {
+    categoryId: string;
+    categoryCode: string;
+    categoryName: string;
+    description: string;
+    iconUrl: string | null;
+    sortNo: number;
+    professionCount: number;
+}
+export interface ProfessionMarketItem {
+    professionId: string;
+    professionForm: ProfessionForm;
+    name: string;
+    summary: string;
+    iconUrl: string | null;
+    priceType: ProfessionPriceType;
+    priceLabel: string;
+    developerId: string;
+    developerName: string;
+    openSource: boolean;
+    official: boolean;
+    userCount: number;
+    userCountLabel: string;
+    categoryId: string | null;
+    categoryCode: string | null;
+    categoryName: string | null;
+}
+export interface ProfessionMarketSearchQuery {
+    professionForm: ProfessionForm;
+    keyword?: string;
+    categoryCode?: string;
+    pageNum?: number;
+    pageSize?: number;
+}
+export interface ProfessionMarketSearchResult {
+    items: ProfessionMarketItem[];
+    total: number;
+    pageNum: number;
+    pageSize: number;
+}
+export interface InstalledProfessionItem {
+    professionId: string;
+    professionForm: ProfessionForm;
+    name: string;
+    summary: string;
+    iconUrl: string | null;
+    categoryName: string | null;
+    enabled: boolean;
+    installedAt: string;
+}
+export interface ListInstalledProfessionsQuery {
+    professionForm: ProfessionForm;
+    enabled?: boolean;
+    pageNum?: number;
+    pageSize?: number;
+}
+export interface InstalledProfessionResult {
+    items: InstalledProfessionItem[];
+    total: number;
+    pageNum: number;
+    pageSize: number;
+}
+export interface ProfessionVersion {
+    versionId: string;
+    versionNo: string;
+    packageRef: string | null;
+    professionMd: string;
+    deployStatus: string;
+    changelog: string;
+}
+export interface UserProfessionState {
+    installed: boolean;
+    enabled: boolean;
+    canInstall: boolean;
+    canEnable: boolean;
+    canUse: boolean;
+    hasUsed: boolean;
+    actionScope: string;
+    actionDisabledReason: string | null;
+}
+export interface ProfessionMarketDetail extends ProfessionMarketItem {
+    coverUrl: string | null;
+    description: string;
+    currentVersion: ProfessionVersion | null;
+    userProfessionState: UserProfessionState | null;
+}
+export interface ProfessionMarketApi {
+    listCategories: (professionForm: ProfessionForm) => Promise<ProfessionMarketCategory[]>;
+    search: (query: ProfessionMarketSearchQuery) => Promise<ProfessionMarketSearchResult>;
+    getDetail: (professionId: string) => Promise<ProfessionMarketDetail>;
+    listInstalled: (query: ListInstalledProfessionsQuery) => Promise<InstalledProfessionResult>;
+    prepareForLocalTask: (professionId: string, versionId?: string) => Promise<import('./local-task-api.js').LocalTaskProfessionReference>;
+    recordUsage: (professionId: string) => Promise<void>;
+}

package/dist/shared/project-local-skill-api.d.ts

@@ -0,0 +1,8 @@
+export interface ReplaceProjectLocalSkillsRequest {
+    projectId: string;
+    folderNames: string[];
+}
+export interface ProjectLocalSkillApi {
+    list: (projectId: string) => Promise<string[]>;
+    replace: (request: ReplaceProjectLocalSkillsRequest) => Promise<string[]>;
+}

package/dist/shared/remote-connection-api.d.ts

@@ -0,0 +1,97 @@
+import type { RemoteAuthenticationPrompt, RemoteConnectionProfile, RemoteConnectionState, RemoteEndpoint, RemoteInstallMode, RemoteProbe, RemoteProbeEndpoint } from './remote-connection.js';
+import type { WorkspaceRef } from './execution-target.js';
+import type { TargetBridgeInfo } from './target-bridge-protocol.js';
+export interface ConnectionInput {
+    id?: string;
+    name: string;
+    endpoint: RemoteEndpoint;
+    installMode: RemoteInstallMode;
+    installRoot: string;
+    dataRoot: string;
+}
+export interface ConnectionSnapshot {
+    connectionId: string;
+    state: RemoteConnectionState;
+    generation: number;
+    operationId?: string;
+    target?: TargetBridgeInfo;
+    error?: {
+        code: string;
+        message: string;
+    };
+    retryAt?: string;
+}
+export interface ConnectionOperation {
+    id: string;
+    connectionId: string;
+    status: 'running' | 'completed' | 'failed' | 'cancelled';
+    error?: ConnectionSnapshot['error'];
+}
+export interface TargetCredentialChoice {
+    kind: 'system' | 'vault' | 'session';
+    secret?: string;
+}
+export interface RemoteDirectoryPage {
+    canonicalPath: string;
+    parentPath: string;
+    items: Array<{
+        name: string;
+        path: string;
+        symbolicLink: boolean;
+    }>;
+    total: number;
+    revision: string;
+    nextCursor?: string;
+}
+export interface RemoteConnectionsApi {
+    readonly supportedKinds: readonly RemoteEndpoint['kind'][];
+    resolveEndpoint(endpoint: RemoteProbeEndpoint): Promise<RemoteProbeEndpoint>;
+    selectIdentityFile(): Promise<string | null>;
+    discover(kind: 'ssh' | 'docker' | 'wsl'): Promise<Array<{
+        name: string;
+        endpoint: RemoteEndpoint;
+        running?: boolean;
+    }>>;
+    startContainer(endpoint: Extract<RemoteEndpoint, {
+        kind: 'docker';
+    }>): Promise<void>;
+    list(): Promise<Array<{
+        profile: RemoteConnectionProfile;
+        connection: ConnectionSnapshot;
+    }>>;
+    get(id: string): Promise<RemoteConnectionProfile>;
+    save(input: ConnectionInput, expectedRevision?: string): Promise<RemoteConnectionProfile>;
+    /** SSH input is staged for verification; saving the connection persists verified credentials using OS encryption. */
+    test(endpoint: RemoteProbeEndpoint, sshSecret?: string): Promise<RemoteProbe>;
+    connect(id: string, credentials?: TargetCredentialChoice): Promise<ConnectionOperation>;
+    /** Finish the wizard, reusing an existing connection with the same endpoint and directory. */
+    complete(id: string): Promise<RemoteConnectionProfile>;
+    disconnect(id: string): Promise<ConnectionSnapshot>;
+    revokeAuthorization(id: string): Promise<void>;
+    remove(id: string, expectedRevision: string): Promise<{
+        removed: string;
+        targetDataPreserved: true;
+    }>;
+    operationStatus(id: string): Promise<ConnectionOperation>;
+    cancelOperation(id: string): Promise<ConnectionOperation>;
+    pendingPrompts(): Promise<RemoteAuthenticationPrompt[]>;
+    answerPrompt(id: string, answer: string | null): Promise<void>;
+    listDirectories(id: string, query: {
+        path?: string;
+        cursor?: string;
+        limit?: number;
+    }): Promise<RemoteDirectoryPage>;
+    resolveDirectory(id: string, path: string): Promise<{
+        canonicalPath: string;
+        name: string;
+    }>;
+    registerWorkspace(id: string, request: {
+        path: string;
+        name?: string;
+    }): Promise<RemoteConnectionProfile>;
+    listWorkspaces(id: string): Promise<WorkspaceRef[]>;
+    removeWorkspace(id: string, workspaceId: string): Promise<RemoteConnectionProfile>;
+    onChanged(listener: (snapshot: ConnectionSnapshot) => void): () => void;
+    onPrompt(listener: (prompt: RemoteAuthenticationPrompt) => void): () => void;
+    onPromptsChanged(listener: (prompts: RemoteAuthenticationPrompt[]) => void): () => void;
+}

package/dist/shared/remote-connection.d.ts

@@ -0,0 +1,62 @@
+import type { ExecutionTargetIdentity, OwnerPrincipal, WorkspaceRef } from './execution-target.js';
+export type RemoteInstallMode = 'local-download-upload' | 'remote-download';
+export type RemoteEndpoint = {
+    kind: 'ssh';
+    host: string;
+    port?: number;
+    username?: string;
+    identityFile?: string;
+    authentication?: 'password' | 'key';
+    system: 'posix' | 'windows';
+} | {
+    kind: 'docker';
+    context: string;
+    endpoint: string;
+    daemonId: string;
+    containerId: string;
+    user?: string;
+} | {
+    kind: 'wsl';
+    distribution: string;
+    user?: string;
+};
+/** Automatic detection is a probe input, never a persisted execution endpoint. */
+export type RemoteProbeEndpoint = Exclude<RemoteEndpoint, {
+    kind: 'ssh';
+}> | (Omit<Extract<RemoteEndpoint, {
+    kind: 'ssh';
+}>, 'system'> & {
+    system: 'auto' | 'posix' | 'windows';
+});
+export interface RemoteConnectionProfile {
+    id: string;
+    name: string;
+    owner: OwnerPrincipal;
+    endpoint: RemoteEndpoint;
+    installMode: RemoteInstallMode;
+    /** Target-native absolute paths. Never passed to the controlling host's fs. */
+    installRoot: string;
+    dataRoot: string;
+    target?: ExecutionTargetIdentity;
+    workspaces: WorkspaceRef[];
+    revision: string;
+}
+export type RemoteConnectionState = 'disconnected' | 'connecting' | 'provisioning' | 'ready' | 'reconnecting' | 'needs_action';
+export interface RemoteAuthenticationPrompt {
+    id: string;
+    connectionId: string;
+    kind: 'host-trust' | 'password' | 'key-passphrase' | 'interactive' | 'vault-unlock';
+    text: string;
+}
+export interface RemoteProbe {
+    platform: 'darwin' | 'linux' | 'win32';
+    arch: 'x64' | 'arm64';
+    user: string;
+    home: string;
+    libc?: 'glibc';
+    tools: {
+        tar: boolean;
+        curl: boolean;
+        sha256: boolean;
+    };
+}

package/dist/shared/remote-installation-api.d.ts

@@ -0,0 +1,50 @@
+import type { RemoteProbe, RemoteInstallMode } from './remote-connection.js';
+export interface InstallationProgress {
+    id: string;
+    connectionId: string;
+    owner: string;
+    phase: 'prepared' | 'downloading' | 'uploading' | 'installing' | 'completed' | 'failed' | 'cancelled' | 'interrupted';
+    version: string;
+    target: string;
+    totalBytes: number;
+    transferredBytes: number;
+    stage: string;
+    createdAt: string;
+    error?: string;
+    clientAuthGeneration: number;
+    tenantId: string;
+    targetCleanupPending?: boolean;
+    transferTotalBytes?: number;
+    activity?: string;
+    logs?: Array<{
+        at: string;
+        level: 'info' | 'success' | 'error';
+        message: string;
+    }>;
+}
+export interface InstallationPlan extends InstallationProgress {
+    fingerprint: string;
+    installMode: RemoteInstallMode;
+    installRoot: string;
+    dataRoot: string;
+    probe: RemoteProbe;
+    previousVersion?: string;
+}
+export interface ManagedCliInstallation {
+    version: string;
+    previousVersion?: string;
+    target: string;
+    revision: string;
+}
+export interface RemoteInstallationApi {
+    inspect(connectionId: string): Promise<ManagedCliInstallation | null>;
+    manage(connectionId: string, action: 'rollback' | 'stop' | 'uninstall', expectedRevision: string): Promise<{
+        action: string;
+        result: unknown;
+    }>;
+    prepare(connectionId: string): Promise<InstallationPlan>;
+    install(operationId: string, fingerprint: string): Promise<InstallationProgress>;
+    status(operationId: string): Promise<InstallationProgress>;
+    cancel(operationId: string): Promise<InstallationProgress>;
+    onProgress(listener: (progress: InstallationProgress) => void): () => void;
+}

package/dist/shared/remote-tasks-api.d.ts

@@ -0,0 +1,118 @@
+import type { TaskRef, WorkspaceRef } from './execution-target.js';
+import type { CreateLocalTaskRequest, LocalTask } from './local-task-api.js';
+import type { LocalTaskStateCursor } from './local-task-projection.js';
+export interface RemoteWorkspaceQuery {
+    includeArchived?: boolean;
+    pinnedOnly?: boolean;
+    query?: string;
+    limit?: number;
+    cursor?: string;
+}
+export interface RemoteTaskPage {
+    items: LocalTask[];
+    total: number;
+    canonicalPath: string;
+    nextCursor?: string;
+}
+export interface RemoteAgentIdentity {
+    runId: string;
+    sourceThreadId: string;
+    teamRunId?: string;
+    memberRunId?: string;
+}
+export interface RemoteAgentEventPage {
+    status: 'available' | 'missing';
+    data: Uint8Array;
+    nextCursor?: string;
+}
+export interface RemoteAgentMember {
+    identity: RemoteAgentIdentity;
+    kind: 'team' | 'sub_agent';
+    displayName: string;
+    status: string;
+    eventId: string;
+    updatedAt: string;
+    parentThreadId?: string;
+    resultEventId?: string;
+}
+export interface RemoteAgentMemberPage {
+    items: RemoteAgentMember[];
+    total: number;
+    revision: string;
+    nextCursor?: string;
+}
+export interface RemoteFileQuery {
+    path?: string;
+    worktreeId?: string;
+    cursor?: string;
+    limit?: number;
+}
+export interface RemoteFilePage {
+    entries: Array<{
+        name: string;
+        path: string;
+        nodeType: 'folder' | 'file' | 'link';
+        sizeBytes: number;
+        modifiedAt: string;
+    }>;
+    path: string;
+    revision: string;
+    nextCursor: string | null;
+}
+export interface RemoteTasksApi {
+    artifactPage(task: TaskRef, query: Omit<import('./local-task-api.js').ListLocalTaskArtifactsRequest, 'taskId'> & {
+        cursor?: string;
+    }): Promise<{
+        items: import('./local-task-api.js').LocalTaskArtifact[];
+        total: number;
+        nextCursor?: string;
+    }>;
+    creationStatus(connectionId: string, workspace: WorkspaceRef, operationId: string): Promise<{
+        state: 'not_found' | 'running' | 'completed' | 'failed' | 'interrupted';
+        error?: string;
+    }>;
+    abandonCreation(connectionId: string, workspace: WorkspaceRef, operationId: string, request: CreateLocalTaskRequest): ReturnType<RemoteTasksApi['creationStatus']>;
+    environment<K extends keyof import('./target-environments.js').TargetEnvironmentMethods>(connectionId: string, method: K, args: Parameters<import('./target-environments.js').TargetEnvironmentMethods[K]>): Promise<Awaited<ReturnType<import('./target-environments.js').TargetEnvironmentMethods[K]>>>;
+    prepareExpertSync(scope: import('./target-resources.js').TargetResourceScope, expertId: string): Promise<import('./target-resources.js').TargetExpertSyncPlan>;
+    syncExpert(planId: string, autoUpdates?: boolean): Promise<import('./my-expert-api.js').MyExpertPublishResult>;
+    openPortForward(task: TaskRef, port: number): Promise<{
+        id: string;
+        url: string;
+        targetPort: number;
+    }>;
+    closePortForward(task: TaskRef, id: string): Promise<void>;
+    prepareSkillSync(scope: import('./target-resources.js').TargetResourceScope, reference: string): Promise<import('./target-resources.js').TargetSkillSyncPlan>;
+    syncSkill(planId: string, folderName: string, autoUpdates?: boolean): Promise<import('./local-skill-api.js').LocalSkillDefinition>;
+    fileDirectory(task: TaskRef, query: RemoteFileQuery): Promise<RemoteFilePage>;
+    subscribeFiles(task: TaskRef, query: RemoteFileQuery): Promise<{
+        subscriptionId: string;
+        sequence: number;
+        snapshot: RemoteFilePage;
+    }>;
+    acknowledgeFiles(subscriptionId: string, sequence: number): Promise<void>;
+    unsubscribeFiles(subscriptionId: string): Promise<void>;
+    onFilesChanged(listener: (change: {
+        subscriptionId: string;
+        error?: {
+            code: string;
+            message: string;
+        };
+    }) => void): () => void;
+    agentEventPage(task: TaskRef, identity: RemoteAgentIdentity, cursor?: string): Promise<RemoteAgentEventPage>;
+    agentMembers(task: TaskRef, cursor?: string): Promise<RemoteAgentMemberPage>;
+    resources: import('./target-resources.js').TargetResourcesApi['invoke'];
+    list(connectionId: string, workspace: WorkspaceRef, query?: RemoteWorkspaceQuery): Promise<RemoteTaskPage>;
+    subscribeList(connectionId: string, workspace: WorkspaceRef, query?: RemoteWorkspaceQuery): Promise<{
+        subscriptionId: string;
+        page: RemoteTaskPage;
+        cursor: LocalTaskStateCursor;
+    }>;
+    acknowledgeList(subscriptionId: string, cursor: LocalTaskStateCursor): Promise<void>;
+    unsubscribeList(subscriptionId: string): Promise<void>;
+    onListChanged(listener: (change: {
+        subscriptionId: string;
+        workspace: WorkspaceRef;
+    }) => void): () => void;
+    create(connectionId: string, workspace: WorkspaceRef, request: CreateLocalTaskRequest, operationId: string): Promise<LocalTask>;
+    get(ref: TaskRef): Promise<LocalTask>;
+}

package/dist/shared/runtime-tuning.d.ts

@@ -0,0 +1,44 @@
+export interface CompactionPolicy {
+    /** Fraction of the context window; still bounded by the model's input limit. */
+    triggerRatio?: number;
+    triggerTokens?: number;
+    instructions?: string;
+    /** Prompt target, not an enforced truncation of the model's summary. */
+    summaryTargetTokens?: number;
+    /** Maximum characters in the structured task handoff, independent of native history retention. */
+    handoffCharacters?: number;
+}
+export interface GenerationOptions {
+    temperature?: number;
+    topP?: number;
+    maxOutputTokens?: number;
+    responseFormat?: {
+        name: string;
+        schema: Record<string, unknown>;
+        strict?: boolean;
+    };
+}
+export type GenerationCapabilities = Partial<Record<keyof GenerationOptions, boolean>>;
+export declare function validateGenerationCapabilities(value: unknown): asserts value is GenerationCapabilities;
+export declare function supportedGeneration(options: GenerationOptions | undefined, capabilities: GenerationCapabilities | undefined): GenerationOptions | undefined;
+export interface RuntimeTuning {
+    compaction?: CompactionPolicy;
+    generation?: GenerationOptions;
+}
+export interface AppliedRuntimeTuning {
+    requested: RuntimeTuning;
+    effectiveGeneration?: GenerationOptions;
+    thresholdTokens?: number;
+    handoffCharacters: number;
+    summaryBudget: 'model_target';
+    nativeHistoryRetention: 'runtime_default';
+}
+export declare function appliedRuntimeTuning(requested: RuntimeTuning | undefined, thresholdTokens: number | undefined, maxOutputTokens?: number): AppliedRuntimeTuning;
+export interface RuntimeTuningState {
+    configured?: RuntimeTuning;
+    applied?: AppliedRuntimeTuning;
+    model?: string;
+    updatedAt?: string;
+}
+export declare function parseRuntimeTuning(value: unknown): RuntimeTuning;
+export declare function compactionPrompt(policy?: CompactionPolicy): string | undefined;

package/dist/shared/scene-case-api.d.ts

@@ -0,0 +1,42 @@
+export type SceneCaseCategoryCode = 'WORKING' | 'CODING' | 'DESIGN';
+export type SceneCaseBindingType = 'LOCAL_SKILL' | 'INTERNAL_TOOL' | 'EXPERT' | 'EXPERT_TEAM' | 'EXTERNAL_SERVICE';
+export interface SceneCaseCategory {
+    code: SceneCaseCategoryCode;
+    name: string;
+    sortNo: number;
+}
+export interface SceneCasePrompt {
+    id: string;
+    title: string;
+    content: string;
+    sortNo: number;
+}
+export interface SceneCaseBinding {
+    id: string;
+    type: SceneCaseBindingType;
+    key: string;
+    name: string;
+    description: string | null;
+    required: boolean;
+    sortNo: number;
+}
+export interface SceneCase {
+    id: string;
+    code: string;
+    categoryCode: SceneCaseCategoryCode;
+    categoryName: string;
+    name: string;
+    summary: string;
+    iconUrl: string | null;
+    sortNo: number;
+    prompts: SceneCasePrompt[];
+    bindings: SceneCaseBinding[];
+}
+export interface SceneCaseListQuery {
+    categoryCode?: SceneCaseCategoryCode;
+}
+export interface SceneCaseApi {
+    listCategories: () => Promise<SceneCaseCategory[]>;
+    list: (query?: SceneCaseListQuery) => Promise<SceneCase[]>;
+    getDetail: (sceneCaseId: string) => Promise<SceneCase>;
+}