@sequenceholdings/artifact-studio 0.10.1 → 0.11.0

package/dist/server/platform-client.d.ts

@@ -0,0 +1,870 @@
+import { type ArtifactServerClient, type ArtifactServerClientOptions, type ArtifactServerContext } from './client.js';
+import type { ArtifactExternalAccept } from './external-context.js';
+type PlatformSource = Pick<ArtifactServerClient<ArtifactServerContext>, 'context' | 'principal' | 'mode' | 'log' | 'api' | 'agents' | 'storage' | 'functions' | 'processes' | 'groups' | 'flags' | 'audit'>;
+/** Shared endpoint clients are bound to the existing verified broker, never a bearer fallback. */
+export declare function createArtifactServerPlatformAdapter(client: PlatformSource): {
+    context: ArtifactServerContext;
+    principal: import("./principal.js").ArtifactPrincipal;
+    mode: "service" | "user";
+    log: {
+        info: (event: string, metadata?: import("./logger.js").ArtifactLogMetadata) => void;
+        warn: (event: string, metadata?: import("./logger.js").ArtifactLogMetadata) => void;
+        error: (event: string, metadata?: import("./logger.js").ArtifactLogMetadata) => void;
+    };
+    api: {
+        request: (path: string, options?: import("./api-client.js").ArtifactServerFetchOptions) => Promise<Response>;
+        fetch<TBody = unknown>(path: string, options?: import("./api-client.js").ArtifactServerFetchOptions): Promise<import("../sdk.js").SequenceApiFetchResponse<TBody>>;
+        streamResponse(path: string, options?: import("./api-client.js").ArtifactServerFetchOptions): Promise<Response>;
+        stream(path: string, options?: import("./api-client.js").ArtifactServerFetchOptions): Promise<ReadableStream<Uint8Array<ArrayBuffer>>>;
+        get: <T = unknown>(path: string) => Promise<T>;
+        post: <T = unknown>(path: string, body?: unknown) => Promise<T>;
+        put: <T = unknown>(path: string, body?: unknown) => Promise<T>;
+        patch: <T = unknown>(path: string, body?: unknown) => Promise<T>;
+        delete: <T = unknown>(path: string, body?: unknown) => Promise<T>;
+    };
+    /** Broker domains retain their narrower, manifest-declared operation contracts. */
+    agents: {
+        createJob(input: import("./agent-responses.js").ArtifactCreateAgentJob): Promise<import("./agent-responses.js").ArtifactCreatedAgentJob>;
+        createWorkflowJob(input: import("./agent-responses.js").ArtifactCreateWorkflowJob): Promise<import("./agent-responses.js").ArtifactCreatedWorkflowJob>;
+        getCurrentIdentity(query: {
+            kind: "agent" | "workflow";
+            id: string;
+        }): Promise<import("./agent-responses.js").ArtifactExecutionIdentity>;
+        getCompletedRun(query: {
+            agent: string;
+            runId: string;
+        }): Promise<import("./agent-responses.js").ArtifactCompletedAgentRun>;
+        captureCompletedRun(query: {
+            agent: string;
+            runId: string;
+        }): Promise<import("./agent-responses.js").ArtifactCompletedAgentSourceCapture>;
+        captureCompletedConversation(query: {
+            agent: string;
+            runId: string;
+        }): Promise<import("./agent-responses.js").ArtifactCompletedAgentConversationCapture>;
+        captureConversation(query: {
+            agent: string;
+            threadId: string;
+        }): Promise<import("./agent-responses.js").ArtifactAgentConversationSourceCapture>;
+        captureCompletedWorkflow(query: {
+            workflow: string;
+            runId: string;
+        }): Promise<import("./agent-responses.js").ArtifactCompletedWorkflowSourceCapture>;
+        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>;
+        };
+        files: {
+            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;
+        };
+        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>;
+        };
+    };
+    groups: {
+        list(query?: import("./groups.js").ArtifactGroupMembershipsQuery): Promise<import("./groups.js").ArtifactGroupMembershipsPage>;
+        resolve(groupIds: string[]): Promise<{
+            groups: Array<{
+                id: string;
+                name: string;
+            }>;
+        }>;
+        directory(query?: import("./group-directory.js").ArtifactGroupDirectoryQuery): Promise<import("./group-directory.js").ArtifactGroupDirectoryPage>;
+        get(groupId: string): Promise<import("./group-directory.js").ArtifactGroupDetail>;
+        changeMembers(groupId: string, change: import("./group-directory.js").ArtifactGroupMemberChange): Promise<import("./group-directory.js").ArtifactGroupDetail>;
+    };
+    functions: {
+        invoke: ({ id, params }: {
+            id: string;
+            params?: Record<string, unknown>;
+        }) => Promise<unknown>;
+        get: ({ id }: {
+            id: string;
+        }) => Promise<unknown>;
+    };
+    storage: {
+        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;
+        }>;
+        workspace(id: 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;
+            }>;
+            uploads: {
+                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;
+                    }[];
+                }>;
+                resume(id: string, source: import("@sequenceholdings/storage").StorageUploadSource, options?: import("@sequenceholdings/storage").StorageTransferOptions & {
+                    size?: number;
+                }): Promise<{
+                    id: string;
+                    fileId: string;
+                    uploadUrl: string | null;
+                    expiresAt: string;
+                    state: "aborted" | "pending" | "complete";
+                    versionId: string | null;
+                    maxBytes: number;
+                }>;
+                put(input: Omit<import("@sequenceholdings/storage").StartStorageUpload, "idempotencyKey"> & {
+                    idempotencyKey?: string;
+                }, source: import("@sequenceholdings/storage").StorageUploadSource, { keepSessionOnFailure, ...options }?: import("@sequenceholdings/storage").StorageTransferOptions & {
+                    keepSessionOnFailure?: boolean;
+                }): Promise<{
+                    id: string;
+                    fileId: string;
+                    uploadUrl: string | null;
+                    expiresAt: string;
+                    state: "aborted" | "pending" | "complete";
+                    versionId: string | null;
+                    maxBytes: number;
+                }>;
+            };
+        };
+    };
+    processes: import("./processes.js").ArtifactServerProcesses;
+    flags: import("./client.js").ArtifactServerFlags;
+    audit: import("./client.js").ArtifactServerAudit;
+    files: {
+        download: (input: {
+            fileId: string;
+            download?: boolean;
+        }) => Promise<import("../sdk.js").SequenceApiFetchResponse<unknown>>;
+        get: ({ fileId }: {
+            fileId: string;
+        }) => Promise<unknown>;
+        downloadPath: ({ fileId, download }: {
+            fileId: string;
+            download?: boolean;
+        }) => string;
+        speech: {
+            getConfiguration: () => Promise<unknown>;
+        };
+    };
+    identity: {
+        me: () => Promise<unknown>;
+        permissions: () => Promise<unknown>;
+    };
+    directory: {
+        list: (query?: {
+            limit?: number;
+            offset?: number;
+        }) => Promise<unknown>;
+    };
+    permissions: {
+        searchPrincipals: (query?: {
+            q?: string;
+            limit?: number;
+            types?: string;
+        }) => Promise<unknown>;
+    };
+    lattice: {
+        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>;
+        };
+    };
+    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 ArtifactServerPlatform = ReturnType<typeof createArtifactServerPlatformAdapter>;
+export type ArtifactServerPlatformClient = ArtifactServerPlatform & {
+    asService(): ArtifactServerPlatformClient;
+};
+/** One per Next.js request. Uses the same context verification and explicit service transition as the legacy factory. */
+export declare function createArtifactServerPlatformClient(options: ArtifactServerClientOptions & {
+    accept?: ArtifactExternalAccept;
+}): Promise<ArtifactServerPlatformClient>;
+export {};