@sequenceholdings/artifact-studio 0.10.1 → 0.11.0

package/dist/platform-client.d.ts

@@ -0,0 +1,838 @@
+import { type SequenceArtifactSdk, type SequenceApiUploadOptions } from './sdk.js';
+/**
+ * Browser bootstrap for the shared Platform SDK. Authentication and capability checks
+ * stay in the trusted Artifact host; no base URL, token, or service authority is accepted.
+ * Create again with a new sdk when the host/action scope changes.
+ */
+export declare function createArtifactPlatformClient({ sdk }?: {
+    sdk?: SequenceArtifactSdk;
+}): {
+    /** App-owned compatibility routes, still subject to the artifact manifest and live grants. */
+    api: import("./sdk.js").SequenceApi;
+    user: import("./sdk.js").SequenceUser;
+    env: import("./sdk.js").SequenceEnvironment;
+    auth: import("./sdk.js").SequenceAuth;
+    flags: import("./sdk.js").SequenceFlags;
+    host: import("./sdk.js").SequenceHost;
+    offline: import("./sdk.js").SequenceOffline;
+    functions: {
+        invoke: ({ id, params }: {
+            id: string;
+            params?: Record<string, unknown>;
+        }) => Promise<unknown>;
+        get: ({ id }: {
+            id: string;
+        }) => Promise<unknown>;
+    };
+    lattice: {
+        context: () => import("./sdk.js").SequenceLatticeContext;
+        runs: {
+            list: (query?: {
+                process_id?: string;
+                status?: string;
+                entity_type?: string;
+                entity_id?: string;
+                limit?: number;
+                archived?: boolean;
+            }) => Promise<unknown>;
+            get: ({ runId }: {
+                runId: string;
+            }) => Promise<unknown>;
+            start: (input: import("@sequenceholdings/platform/browser").PlatformRunStart) => Promise<{
+                run_id: string;
+                process_id: string;
+                process_version: string;
+                bundle_hash: string;
+                status: "pending" | "existing";
+                idempotent_replay: boolean;
+                outcome: "existing" | "created" | "replayed" | "unclaimed" | "queued";
+            }>;
+            advance: ({ runId, ...body }: import("@sequenceholdings/platform/browser").PlatformRunAdvance) => Promise<unknown>;
+        };
+        steps: {
+            get: ({ runId, stepId }: {
+                runId: string;
+                stepId: string;
+            }) => Promise<unknown>;
+            getContext: ({ runId, stepId }: {
+                runId: string;
+                stepId: string;
+            }) => Promise<unknown>;
+            assign: ({ runId, stepId, assignment }: {
+                runId: string;
+                stepId: string;
+                assignment: {
+                    users?: string[];
+                    groups?: string[];
+                };
+            }) => Promise<unknown>;
+        };
+        principals: {
+            search: (query?: {
+                q?: string;
+                limit?: number;
+                types?: string;
+                requireAppAccess?: string;
+            }) => Promise<unknown>;
+        };
+        processes: {
+            listRuns: ({ process, ...query }: {
+                process: string;
+                limit?: number;
+                offset?: number;
+                status?: string;
+                entity_type?: string;
+                entity_id?: string;
+            }) => Promise<unknown>;
+            getCompletion: ({ process, cycle }: {
+                process: string;
+                cycle: string;
+            }) => Promise<unknown>;
+            listSchedules: ({ process }: {
+                process: string;
+            }) => Promise<unknown>;
+            createSchedule: ({ process, schedule }: {
+                process: string;
+                schedule: Record<string, unknown>;
+            }) => Promise<unknown>;
+        };
+        legacyV2: {
+            listRuns: (query?: import("@sequenceholdings/platform/browser").PlatformQuery) => Promise<unknown>;
+            getRun: ({ runId }: {
+                runId: string;
+            }) => Promise<unknown>;
+            startRun: (input: import("@sequenceholdings/platform/browser").PlatformRunStart) => Promise<unknown>;
+            advanceRun: ({ runId, ...body }: import("@sequenceholdings/platform/browser").PlatformRunAdvance) => Promise<unknown>;
+        };
+    };
+    storage: {
+        preview: ((input: {
+            workspaceId: string;
+            fileId: string;
+            versionId: string;
+            filename: string;
+            mime: string;
+        }) => Promise<{
+            opened: true;
+        }>) | undefined;
+        workspace(id: string): {
+            uploads: {
+                put: (input: import("@sequenceholdings/storage").StartStorageUpload, file: Blob, options?: import("./sdk.js").SequenceStorageOptions) => Promise<{
+                    id: string;
+                    fileId: string;
+                    uploadUrl: string | null;
+                    expiresAt: string;
+                    state: "aborted" | "complete" | "pending";
+                    versionId: string | null;
+                    maxBytes: number;
+                }>;
+                resume: (uploadId: string, file: Blob, options?: import("./sdk.js").SequenceStorageOptions) => Promise<{
+                    id: string;
+                    fileId: string;
+                    uploadUrl: string | null;
+                    expiresAt: string;
+                    state: "aborted" | "complete" | "pending";
+                    versionId: string | null;
+                    maxBytes: number;
+                }>;
+                start: (input: import("@sequenceholdings/storage").StartStorageUpload) => Promise<{
+                    id: string;
+                    fileId: string;
+                    uploadUrl: string | null;
+                    expiresAt: string;
+                    state: "aborted" | "pending" | "complete";
+                    versionId: string | null;
+                    maxBytes: number;
+                }>;
+                get: (id: string) => Promise<{
+                    id: string;
+                    fileId: string;
+                    uploadUrl: string | null;
+                    expiresAt: string;
+                    state: "aborted" | "pending" | "complete";
+                    versionId: string | null;
+                    maxBytes: number;
+                }>;
+                complete: (id: string, input?: import("@sequenceholdings/storage").CompleteStorageUpload) => Promise<{
+                    id: string;
+                    fileId: string;
+                    uploadUrl: string | null;
+                    expiresAt: string;
+                    state: "aborted" | "pending" | "complete";
+                    versionId: string | null;
+                    maxBytes: number;
+                }>;
+                abort: (id: string) => Promise<{
+                    id: string;
+                    fileId: string;
+                    uploadUrl: string | null;
+                    expiresAt: string;
+                    state: "aborted" | "pending" | "complete";
+                    versionId: string | null;
+                    maxBytes: number;
+                }>;
+                startBatch: (items: import("@sequenceholdings/storage").StartStorageUpload[]) => Promise<{
+                    items: {
+                        id: string;
+                        fileId: string;
+                        uploadUrl: string | null;
+                        expiresAt: string;
+                        state: "aborted" | "pending" | "complete";
+                        versionId: string | null;
+                        maxBytes: number;
+                    }[];
+                }>;
+                list: () => Promise<{
+                    items: {
+                        id: string;
+                        fileId: string;
+                        name: string;
+                        state: "aborted" | "pending" | "complete";
+                        expiresAt: string;
+                        maxBytes: number;
+                        expectedSize: number | null;
+                        versionId: string | null;
+                    }[];
+                    limits: {
+                        perPrincipal: number;
+                        perWorkspace: number;
+                    };
+                }>;
+                reconcile: (input?: {
+                    abortIncomplete?: boolean;
+                }) => Promise<{
+                    completed: {
+                        id: string;
+                        fileId: string;
+                        name: string;
+                        state: "aborted" | "pending" | "complete";
+                        expiresAt: string;
+                        maxBytes: number;
+                        expectedSize: number | null;
+                        versionId: string | null;
+                        code: string;
+                        message: string;
+                    }[];
+                    aborted: {
+                        id: string;
+                        fileId: string;
+                        name: string;
+                        state: "aborted" | "pending" | "complete";
+                        expiresAt: string;
+                        maxBytes: number;
+                        expectedSize: number | null;
+                        versionId: string | null;
+                        code: string;
+                        message: string;
+                    }[];
+                    pending: {
+                        id: string;
+                        fileId: string;
+                        name: string;
+                        state: "aborted" | "pending" | "complete";
+                        expiresAt: string;
+                        maxBytes: number;
+                        expectedSize: number | null;
+                        versionId: string | null;
+                        code: string;
+                        message: string;
+                    }[];
+                }>;
+            };
+            get: () => Promise<{
+                id: string;
+                name: string;
+                description: string;
+                environment: string;
+                state: "active" | "trashed" | "purging";
+                revision: number;
+                createdAt: string;
+                role: "viewer" | "editor" | "admin" | "owner";
+                quotaBytes: number;
+                usedBytes: number;
+                reservedBytes: number;
+            }>;
+            delete: (expectedRevision: number) => Promise<{
+                id: string;
+                workspaceId: string;
+                targetId: string | null;
+                kind: "purge" | "delete_version";
+                status: "running" | "failed" | "queued" | "succeeded";
+                completed: number;
+                total: number;
+                error: string | null;
+                createdAt: string;
+                updatedAt: string;
+                canRetry: boolean;
+            }>;
+            list: (options?: import("@sequenceholdings/storage").StorageListOptions & {
+                parentId?: string | null;
+                trash?: boolean;
+            }) => Promise<{
+                items: {
+                    id: string;
+                    workspaceId: string;
+                    parentId: string | null;
+                    name: string;
+                    kind: "file" | "folder";
+                    state: "active" | "trashed" | "purging";
+                    restricted: boolean;
+                    revision: number;
+                    currentVersionId: string | null;
+                    metadata: Record<string, string>;
+                    createdAt: string;
+                    updatedAt: string;
+                    role: "viewer" | "editor" | "admin";
+                    size: number | null;
+                    contentType: string | null;
+                }[];
+                nextCursor: string | null;
+            }>;
+            getNode: (id: string) => Promise<{
+                id: string;
+                workspaceId: string;
+                parentId: string | null;
+                name: string;
+                kind: "file" | "folder";
+                state: "active" | "trashed" | "purging";
+                restricted: boolean;
+                revision: number;
+                currentVersionId: string | null;
+                metadata: Record<string, string>;
+                createdAt: string;
+                updatedAt: string;
+                role: "viewer" | "editor" | "admin";
+                size: number | null;
+                contentType: string | null;
+            }>;
+            getNodeWithAncestors: (id: string) => Promise<{
+                id: string;
+                workspaceId: string;
+                parentId: string | null;
+                name: string;
+                kind: "file" | "folder";
+                state: "active" | "trashed" | "purging";
+                restricted: boolean;
+                revision: number;
+                currentVersionId: string | null;
+                metadata: Record<string, string>;
+                createdAt: string;
+                updatedAt: string;
+                role: "viewer" | "editor" | "admin";
+                size: number | null;
+                contentType: string | null;
+                ancestors: {
+                    id: string;
+                    workspaceId: string;
+                    parentId: string | null;
+                    name: string;
+                    kind: "file" | "folder";
+                    state: "active" | "trashed" | "purging";
+                    restricted: boolean;
+                    revision: number;
+                    currentVersionId: string | null;
+                    metadata: Record<string, string>;
+                    createdAt: string;
+                    updatedAt: string;
+                    role: "viewer" | "editor" | "admin";
+                    size: number | null;
+                    contentType: string | null;
+                }[];
+            }>;
+            createFolder: (name: string, parentId?: string | null, { idempotencyKey, }?: {
+                idempotencyKey?: string;
+            }) => Promise<{
+                id: string;
+                workspaceId: string;
+                parentId: string | null;
+                name: string;
+                kind: "file" | "folder";
+                state: "active" | "trashed" | "purging";
+                restricted: boolean;
+                revision: number;
+                currentVersionId: string | null;
+                metadata: Record<string, string>;
+                createdAt: string;
+                updatedAt: string;
+                role: "viewer" | "editor" | "admin";
+                size: number | null;
+                contentType: string | null;
+            }>;
+            update: (id: string, input: import("zod").input<typeof import("@sequenceholdings/storage").updateNodeSchema>) => Promise<{
+                id: string;
+                workspaceId: string;
+                parentId: string | null;
+                name: string;
+                kind: "file" | "folder";
+                state: "active" | "trashed" | "purging";
+                restricted: boolean;
+                revision: number;
+                currentVersionId: string | null;
+                metadata: Record<string, string>;
+                createdAt: string;
+                updatedAt: string;
+                role: "viewer" | "editor" | "admin";
+                size: number | null;
+                contentType: string | null;
+            }>;
+            trash: (id: string, expectedRevision: number) => Promise<{
+                id: string;
+                workspaceId: string;
+                parentId: string | null;
+                name: string;
+                kind: "file" | "folder";
+                state: "active" | "trashed" | "purging";
+                restricted: boolean;
+                revision: number;
+                currentVersionId: string | null;
+                metadata: Record<string, string>;
+                createdAt: string;
+                updatedAt: string;
+                role: "viewer" | "editor" | "admin";
+                size: number | null;
+                contentType: string | null;
+            }>;
+            restore: (id: string, expectedRevision: number) => Promise<{
+                id: string;
+                workspaceId: string;
+                parentId: string | null;
+                name: string;
+                kind: "file" | "folder";
+                state: "active" | "trashed" | "purging";
+                restricted: boolean;
+                revision: number;
+                currentVersionId: string | null;
+                metadata: Record<string, string>;
+                createdAt: string;
+                updatedAt: string;
+                role: "viewer" | "editor" | "admin";
+                size: number | null;
+                contentType: string | null;
+            }>;
+            purge: (id: string, expectedRevision: number) => Promise<{
+                id: string;
+                workspaceId: string;
+                targetId: string | null;
+                kind: "purge" | "delete_version";
+                status: "running" | "failed" | "queued" | "succeeded";
+                completed: number;
+                total: number;
+                error: string | null;
+                createdAt: string;
+                updatedAt: string;
+                canRetry: boolean;
+            }>;
+            download: (id: string, options?: {
+                versionId?: string;
+                preview?: boolean;
+            }) => Promise<{
+                url: string;
+                expiresAt: string;
+                preview: boolean;
+            }>;
+            versions: (id: string, options?: {
+                before?: number;
+                limit?: number;
+            }) => Promise<{
+                items: {
+                    id: string;
+                    fileId: string;
+                    revision: number;
+                    size: number;
+                    checksum: string;
+                    contentType: string;
+                    createdAt: string;
+                    createdBy: string;
+                    state: "active" | "purging";
+                }[];
+                nextRevision: number | null;
+            }>;
+            restoreVersion: (id: string, versionId: string, expectedRevision: number) => Promise<{
+                id: string;
+                fileId: string;
+                revision: number;
+                size: number;
+                checksum: string;
+                contentType: string;
+                createdAt: string;
+                createdBy: string;
+                state: "active" | "purging";
+            }>;
+            deleteVersion: (id: string, versionId: string, expectedRevision: number) => Promise<{
+                id: string;
+                workspaceId: string;
+                targetId: string | null;
+                kind: "purge" | "delete_version";
+                status: "running" | "failed" | "queued" | "succeeded";
+                completed: number;
+                total: number;
+                error: string | null;
+                createdAt: string;
+                updatedAt: string;
+                canRetry: boolean;
+            }>;
+            access: (id?: string) => Promise<{
+                revision: number;
+                restricted: boolean;
+                grants: {
+                    type: "user" | "service_account" | "group" | "organization";
+                    id: string;
+                    role: "viewer" | "editor" | "admin";
+                }[];
+                owner: string | null;
+                inherited: boolean;
+                workspaceAdminOverride: true;
+                displayNames: Record<string, string>;
+            }>;
+            setAccess: (input: import("zod").input<typeof import("@sequenceholdings/storage").updateStorageAccessSchema>, id?: string) => Promise<{
+                revision: number;
+                restricted: boolean;
+                grants: {
+                    type: "user" | "service_account" | "group" | "organization";
+                    id: string;
+                    role: "viewer" | "editor" | "admin";
+                }[];
+                owner: string | null;
+                inherited: boolean;
+                workspaceAdminOverride: true;
+                displayNames: Record<string, string>;
+            }>;
+            transferOwner: (principal: {
+                type: "user" | "service_account";
+                id: string;
+            }, expectedRevision: number) => Promise<{
+                revision: number;
+                restricted: boolean;
+                grants: {
+                    type: "user" | "service_account" | "group" | "organization";
+                    id: string;
+                    role: "viewer" | "editor" | "admin";
+                }[];
+                owner: string | null;
+                inherited: boolean;
+                workspaceAdminOverride: true;
+                displayNames: Record<string, string>;
+            }>;
+            operations: (options?: {
+                before?: string;
+                limit?: number;
+                scope?: import("@sequenceholdings/storage").StorageOperationScope;
+            }) => Promise<{
+                items: {
+                    id: string;
+                    workspaceId: string;
+                    targetId: string | null;
+                    kind: "purge" | "delete_version";
+                    status: "running" | "failed" | "queued" | "succeeded";
+                    completed: number;
+                    total: number;
+                    error: string | null;
+                    createdAt: string;
+                    updatedAt: string;
+                    canRetry: boolean;
+                }[];
+                nextCursor: string | null;
+            }>;
+            retryOperation: (id: string) => Promise<{
+                id: string;
+                workspaceId: string;
+                targetId: string | null;
+                kind: "purge" | "delete_version";
+                status: "running" | "failed" | "queued" | "succeeded";
+                completed: number;
+                total: number;
+                error: string | null;
+                createdAt: string;
+                updatedAt: string;
+                canRetry: boolean;
+            }>;
+        };
+        capabilities: () => Promise<{
+            canProvision: boolean;
+            uploadMethods: string[];
+            pendingUploads: {
+                perPrincipal: number;
+                perWorkspace: number;
+            };
+            uploadBatchLimit: number;
+            importConcurrency: {
+                default: number;
+                max: number;
+            };
+        }>;
+        list: (options?: import("@sequenceholdings/storage").StorageListOptions) => Promise<{
+            items: {
+                id: string;
+                name: string;
+                description: string;
+                environment: string;
+                state: "active" | "trashed" | "purging";
+                revision: number;
+                createdAt: string;
+                role: "viewer" | "editor" | "admin" | "owner";
+                quotaBytes: number;
+                usedBytes: number;
+                reservedBytes: number;
+            }[];
+            nextCursor: string | null;
+        }>;
+        shared: (options?: import("@sequenceholdings/storage").StorageListOptions & {
+            trash?: boolean;
+        }) => Promise<{
+            items: {
+                id: string;
+                workspaceId: string;
+                parentId: string | null;
+                name: string;
+                kind: "file" | "folder";
+                state: "active" | "trashed" | "purging";
+                restricted: boolean;
+                revision: number;
+                currentVersionId: string | null;
+                metadata: Record<string, string>;
+                createdAt: string;
+                updatedAt: string;
+                role: "viewer" | "editor" | "admin";
+                size: number | null;
+                contentType: string | null;
+            }[];
+            nextCursor: string | null;
+        }>;
+        apply: (manifest: import("@sequenceholdings/storage").WorkspaceManifest) => Promise<{
+            id: string;
+            name: string;
+            description: string;
+            environment: string;
+            state: "active" | "trashed" | "purging";
+            revision: number;
+            createdAt: string;
+            role: "viewer" | "editor" | "admin" | "owner";
+            quotaBytes: number;
+            usedBytes: number;
+            reservedBytes: number;
+        }>;
+    };
+    agents: {
+        chat: (options: {
+            body: unknown;
+            headers?: Record<string, string>;
+        }) => Promise<Response>;
+        files: {
+            download: (input: {
+                fileId: string;
+            }) => Promise<Response>;
+            create: ({ file, agentId }: {
+                file: File;
+                agentId?: string;
+            }) => Promise<unknown>;
+            getUrl: ({ fileId, workflowId, shareId }: {
+                fileId: string;
+                workflowId?: string;
+                shareId?: string;
+            }) => Promise<unknown>;
+            delete: ({ fileId, agentId }: {
+                fileId: string;
+                agentId?: string;
+            }) => Promise<unknown>;
+            contentPath: ({ fileId, agentId, workflowId }: {
+                fileId: string;
+                agentId?: string;
+                workflowId?: string;
+            }) => string;
+        };
+        list: (query?: {
+            view?: "list";
+            limit?: number;
+            offset?: number;
+        }) => Promise<unknown>;
+        get: ({ agentId }: {
+            agentId: string;
+        }) => Promise<unknown>;
+        tools: {
+            execute: ({ server, tool, input }: {
+                server: string;
+                tool: string;
+                input: Record<string, unknown>;
+            }) => Promise<unknown>;
+        };
+        threads: {
+            create: (input: import("@sequenceholdings/platform/browser").PlatformAgentThreadInput) => Promise<unknown>;
+            get: ({ threadId }: {
+                threadId: string;
+            }) => Promise<unknown>;
+        };
+        jobs: {
+            create: (input: import("@sequenceholdings/platform/browser").PlatformAgentJobInput) => Promise<unknown>;
+            get: ({ jobId }: {
+                jobId: string;
+            }) => Promise<unknown>;
+            cancel: ({ jobId }: {
+                jobId: string;
+            }) => Promise<unknown>;
+        };
+        workflows: {
+            get: ({ workflowId }: {
+                workflowId: string;
+            }) => Promise<unknown>;
+            start: ({ workflowId, input, metadata, expectedIdentity, idempotencyKey }: import("@sequenceholdings/platform/browser").PlatformWorkflowRunInput) => Promise<unknown>;
+            createRun: ({ workflowId, input, metadata, expectedIdentity, idempotencyKey }: import("@sequenceholdings/platform/browser").PlatformWorkflowRunInput) => Promise<unknown>;
+            getRun: ({ runId }: {
+                runId: string;
+            }) => Promise<unknown>;
+            cancelRun: ({ runId }: {
+                runId: string;
+            }) => Promise<unknown>;
+        };
+    };
+    files: {
+        upload: ({ file, fields, options }: {
+            file: File | readonly File[];
+            fields?: Record<string, string>;
+            options?: SequenceApiUploadOptions;
+        }) => Promise<import("./sdk.js").SequenceApiFetchResponse<unknown>>;
+        download: (input: {
+            fileId: string;
+            download?: boolean;
+        }) => Promise<import("./sdk.js").SequenceApiFetchResponse<unknown>>;
+        speech: {
+            transcribe: ({ file, timeoutMs }: {
+                file: File;
+                timeoutMs?: number;
+            }) => Promise<import("./sdk.js").SequenceApiFetchResponse<unknown>>;
+            getConfiguration: () => Promise<unknown>;
+        };
+        get: ({ fileId }: {
+            fileId: string;
+        }) => Promise<unknown>;
+        downloadPath: ({ fileId, download }: {
+            fileId: string;
+            download?: boolean;
+        }) => string;
+    };
+    identity: {
+        me: () => Promise<unknown>;
+        permissions: () => Promise<unknown>;
+    };
+    groups: {
+        get: ({ groupId }: {
+            groupId: string;
+        }) => Promise<unknown>;
+    };
+    directory: {
+        list: (query?: {
+            limit?: number;
+            offset?: number;
+        }) => Promise<unknown>;
+    };
+    permissions: {
+        searchPrincipals: (query?: {
+            q?: string;
+            limit?: number;
+            types?: string;
+        }) => Promise<unknown>;
+    };
+    activity: {
+        getFormSchema: ({ runId }: {
+            runId: string;
+        }) => Promise<unknown>;
+        advance: ({ runId, ...body }: import("@sequenceholdings/platform/browser").PlatformRunAdvance) => Promise<unknown>;
+        claim: ({ runId }: {
+            runId: string;
+        }) => Promise<unknown>;
+        ownership: {
+            setPrimary: ({ runId, primarySub }: {
+                runId: string;
+                primarySub: string;
+            }) => Promise<unknown>;
+            handToQueue: ({ runId, queueGroupId }: {
+                runId: string;
+                queueGroupId: string;
+            }) => Promise<unknown>;
+            addWatchers: ({ runId, ...input }: {
+                runId: string;
+            } & import("@sequenceholdings/platform/browser").PlatformTicketWatchers) => Promise<unknown>;
+            removeWatchers: ({ runId, ...input }: {
+                runId: string;
+            } & import("@sequenceholdings/platform/browser").PlatformTicketWatchers) => Promise<unknown>;
+        };
+        comments: {
+            list: ({ runId, ...query }: {
+                runId: string;
+            } & import("@sequenceholdings/platform/browser").PlatformQuery) => Promise<unknown>;
+            create: ({ runId, comment }: {
+                runId: string;
+                comment: import("@sequenceholdings/platform/browser").PlatformActivityComment;
+            }) => Promise<unknown>;
+            createForStep: ({ runId, stepId, comment }: {
+                runId: string;
+                stepId: string;
+                comment: Pick<import("@sequenceholdings/platform/browser").PlatformActivityComment, "body">;
+            }) => Promise<unknown>;
+        };
+        drafts: {
+            save: ({ runId, stepId, values }: {
+                runId: string;
+                stepId: string;
+                values: Record<string, unknown>;
+            }) => Promise<unknown>;
+            delete: ({ runId, stepId }: {
+                runId: string;
+                stepId: string;
+            }) => Promise<unknown>;
+        };
+    };
+    legacyShowcase: {
+        listAgents: () => Promise<unknown>;
+        listAgentRuns: ({ agentId }: {
+            agentId: string;
+        }) => Promise<unknown>;
+        getRun: ({ runId }: {
+            runId: string;
+        }) => Promise<unknown>;
+    };
+    usage: {
+        record: (event: Record<string, unknown>) => Promise<unknown>;
+    };
+    legacyProcesses: {
+        types: {
+            list: (query?: {
+                publishedOnly?: boolean;
+            }) => Promise<unknown>;
+            get: ({ typeId }: {
+                typeId: string;
+            }) => Promise<unknown>;
+            ensureSystem: () => Promise<unknown>;
+        };
+        instances: {
+            get: ({ instanceId }: {
+                instanceId: string;
+            }) => Promise<unknown>;
+            create: (input: Record<string, unknown>) => Promise<unknown>;
+            getRoles: ({ instanceId }: {
+                instanceId: string;
+            }) => Promise<unknown>;
+            setRoles: ({ instanceId, roles }: {
+                instanceId: string;
+                roles: Record<string, unknown>;
+            }) => Promise<unknown>;
+            completeStage: ({ instanceId, stageId, completion }: {
+                instanceId: string;
+                stageId: string;
+                completion: Record<string, unknown>;
+            }) => Promise<unknown>;
+        };
+        stages: {
+            assigned: (query?: import("@sequenceholdings/platform/browser").PlatformQuery) => Promise<unknown>;
+        };
+        principals: {
+            search: (query?: import("@sequenceholdings/platform/browser").PlatformQuery) => Promise<unknown>;
+        };
+        data: {
+            query: (input: Record<string, unknown>) => Promise<unknown>;
+        };
+    };
+    health: {
+        get: () => Promise<unknown>;
+    };
+};
+export type ArtifactPlatformClient = ReturnType<typeof createArtifactPlatformClient>;