@dazl/api-client 1.0.44 → 1.0.46

package/src/internal/types.gen.ts

@@ -529,6 +529,531 @@ export type PurgeUserAccountInput = {
     dryRun?: boolean;
 };
 
+export type WorkflowInteractiveCapabilities = {
+    interactiveExecutionAvailable: boolean;
+};
+
+export type WorkflowConversationList = {
+    conversations: Array<WorkflowConversationSummary>;
+};
+
+export type WorkflowConversationSummary = {
+    id: string;
+    runId: string;
+    nodeKey: string;
+    chatId: string;
+    agentName: string;
+    role: 'work' | 'workspace' | 'personal';
+    ownerDazlUserId: string;
+    phaseVersion: number;
+    attempt: number;
+    draftRevision: number;
+    state: 'queued' | 'working' | 'waiting' | 'failed' | 'recovery-required' | 'completed' | 'superseded';
+    activeTurn: WorkflowTurnActiveRef;
+    canRead: boolean;
+    canPost: boolean;
+    canDecide: boolean;
+    canComplete: boolean;
+};
+
+export type WorkflowTurnActiveRef = {
+    turnId: string;
+    turnAttempt: number;
+    status: 'queued' | 'accepted' | 'succeeded' | 'failed' | 'cancelled' | 'recovery-required';
+} | null;
+
+export type WorkflowConversationForChat = {
+    conversation: WorkflowConversationSummary & ({
+        [key: string]: unknown;
+    } | null);
+};
+
+export type WorkflowConversationDetail = {
+    id: string;
+    runId: string;
+    nodeKey: string;
+    chatId: string;
+    agentName: string;
+    role: 'work' | 'workspace' | 'personal';
+    ownerDazlUserId: string;
+    phaseVersion: number;
+    attempt: number;
+    draftRevision: number;
+    state: 'queued' | 'working' | 'waiting' | 'failed' | 'recovery-required' | 'completed' | 'superseded';
+    activeTurn: WorkflowTurnActiveRef;
+    canRead: boolean;
+    canPost: boolean;
+    canDecide: boolean;
+    canComplete: boolean;
+    messages: Array<WorkflowConversationMessage>;
+    hasMore: boolean;
+    oldestSequence: string | null;
+    draft: {
+        text: string;
+        files?: Array<string>;
+        changes?: Array<{
+            dirName: string;
+            from: string;
+            to: string;
+            commits: number;
+            files: Array<string>;
+        }>;
+    } | WorkflowConversationReviewDraft | null;
+    draftValid: boolean;
+    error: string | null;
+};
+
+export type WorkflowConversationMessage = {
+    id: string;
+    sequence: string;
+    role: 'user' | 'assistant';
+    actorDazlUserId: string | null;
+    text: string;
+    createdAt: string;
+};
+
+export type WorkflowConversationReviewDraft = {
+    decision: 'approve' | 'object';
+    suggestions: Array<{
+        target: string;
+        suggestion: string;
+        rationale?: string;
+    }>;
+};
+
+export type WorkflowConversationPostedMessage = {
+    message: WorkflowConversationMessage;
+    turnId: string;
+    turnAttempt: number;
+};
+
+export type WorkflowConversationMessageInput = {
+    requestId: string;
+    text: string;
+    token: WorkflowConversationClaim;
+};
+
+export type WorkflowConversationClaim = {
+    phaseVersion: number;
+    attempt: number;
+};
+
+export type WorkflowConversationOk = {
+    ok: true;
+};
+
+export type WorkflowConversationCompleteInput = {
+    token: WorkflowConversationDraftClaim;
+};
+
+export type WorkflowConversationDraftClaim = {
+    phaseVersion: number;
+    attempt: number;
+    draftRevision: number;
+};
+
+export type WorkflowConversationDecisionInput = {
+    token: WorkflowConversationDraftClaim;
+    decision: 'approve' | 'reject';
+    comment?: string;
+    suggestions: Array<{
+        target: string;
+        suggestion: string;
+        rationale?: string;
+    }>;
+};
+
+export type WorkflowConversationActionResult = {
+    applied: boolean;
+};
+
+export type WorkflowTurnActionInput = {
+    token: WorkflowTurnActionClaim;
+};
+
+export type WorkflowTurnActionClaim = {
+    phaseVersion: number;
+    attempt: number;
+    turnId: string;
+    turnAttempt: number;
+};
+
+export type WorkflowTurnOfferList = {
+    turns: Array<WorkflowTurnOffer>;
+};
+
+export type WorkflowTurnOffer = {
+    runId: string;
+    projectId: string;
+    conversationId: string;
+    nodeKey: string;
+    role: 'work' | 'workspace' | 'personal';
+    turnId: string;
+    turnAttempt: number;
+};
+
+export type WorkflowWorkerSessionResult = {
+    reclaimed: number;
+};
+
+export type WorkflowWorkerSession = {
+    workerId: string;
+};
+
+export type WorkflowTurnAcceptance = {
+    accepted: false;
+} | {
+    accepted: true;
+    token: WorkflowTurnClaim;
+    payload: WorkflowTurnPayload;
+    input: WorkflowTurnInput;
+    leaseExpiresAt: string;
+    heartbeatMs: number;
+};
+
+export type WorkflowTurnClaim = {
+    phaseVersion: number;
+    attempt: number;
+    turnId: string;
+    turnAttempt: number;
+    workerId: string;
+};
+
+export type WorkflowTurnPayload = {
+    conversation: {
+        id: string;
+        runId: string;
+        projectId: string;
+        nodeKey: string;
+        chatId: string;
+    };
+    agent: {
+        schemaVersion?: '1';
+        meta: {
+            name: string;
+            description?: string;
+        };
+        systemPrompt: string;
+        harness: 'dazl' | 'claude' | 'codex' | 'grok' | 'opencode';
+        model?: string;
+        allowedMcpServers?: Array<string>;
+        rules?: Array<{
+            text: string;
+            owners?: Array<string>;
+            blocking?: boolean;
+        }>;
+    };
+    runInput: unknown;
+    upstream: Array<{
+        nodeKey: string;
+        title: string;
+        output: {
+            text: string;
+            files?: Array<string>;
+            changes?: Array<{
+                dirName: string;
+                from: string;
+                to: string;
+                commits: number;
+                files: Array<string>;
+            }>;
+        } | null;
+    }>;
+    history: Array<WorkflowConversationMessage>;
+    changeRequests: Array<WorkflowChangeRequest>;
+    harness: 'dazl' | 'claude' | 'codex' | 'grok' | 'opencode';
+    model?: string;
+    prompt?: string;
+    role: 'work' | 'workspace' | 'personal';
+};
+
+export type WorkflowChangeRequest = {
+    reviewerKey: string;
+    agentName: string;
+    comment?: string;
+    findings: Array<{
+        target: string;
+        suggestion: string;
+        rationale?: string;
+    }>;
+};
+
+export type WorkflowTurnInput = {
+    kind: 'initial';
+} | {
+    kind: 'message';
+    text: string;
+    messageId: string;
+};
+
+export type WorkflowTurnAcceptInput = {
+    workerId: string;
+};
+
+export type WorkflowTurnResultInput = {
+    token: WorkflowTurnClaim;
+    result: WorkflowTurnResult;
+};
+
+export type WorkflowTurnResult = {
+    status: 'succeeded' | 'failed' | 'cancelled';
+    assistantText: string;
+    output?: {
+        text: string;
+        files?: Array<string>;
+        changes?: Array<{
+            dirName: string;
+            from: string;
+            to: string;
+            commits: number;
+            files: Array<string>;
+        }>;
+    };
+    review?: WorkflowConversationReviewDraft;
+    draftValid: boolean;
+    error?: string;
+    execution?: WorkflowExecutionMetadata;
+    observedChanges?: Array<{
+        dirName: string;
+        from: string;
+        to: string;
+        commits: number;
+        files: Array<string>;
+    }>;
+};
+
+export type WorkflowExecutionMetadata = {
+    harness: 'dazl' | 'claude' | 'codex' | 'grok' | 'opencode';
+    model?: string;
+    assistantMessageId?: string;
+};
+
+export type WorkflowTurnHeartbeat = {
+    ok: boolean;
+    cancelRequested: boolean;
+    leaseExpiresAt: string | null;
+};
+
+export type WorkflowTurnClaimInput = {
+    token: WorkflowTurnClaim;
+};
+
+export type WorkflowRun = {
+    id: string;
+    workspaceId: string;
+    projectId: string;
+    chatId: string;
+    startedByDazlUserId: string;
+    status: 'running' | 'paused' | 'completed' | 'failed' | 'cancelled';
+    harness: 'dazl' | 'claude' | 'codex' | 'grok' | 'opencode';
+    model: string | null;
+    input?: unknown;
+    document?: unknown;
+    agents: {
+        [key: string]: unknown;
+    };
+    triggerId: string;
+    source: 'working-tree' | 'definition';
+    sourcePath: string | null;
+    phaseVersions: {
+        [key: string]: number;
+    };
+    reviewCycles: {
+        [key: string]: number;
+    };
+    startedAt: string;
+    finishedAt: string | null;
+};
+
+export type StartWorkflowRunInput = {
+    chatId: string;
+    triggerId: string;
+    source: 'working-tree';
+    sourcePath?: string;
+    harness?: 'dazl' | 'claude' | 'codex' | 'grok' | 'opencode';
+    model?: string;
+    input: unknown;
+    document: unknown;
+    agents: {
+        [key: string]: unknown;
+    };
+};
+
+export type WorkflowDispatchPayload = {
+    runId: string;
+    chatId: string;
+    projectId: string;
+    nodeKey: string;
+    kind: 'work' | 'reviewer';
+    harness: 'dazl' | 'claude' | 'codex' | 'grok' | 'opencode';
+    model?: string;
+    token: WorkflowNodeToken;
+    title: string;
+    agentName: string;
+    agent: {
+        schemaVersion?: '1';
+        meta: {
+            name: string;
+            description?: string;
+        };
+        systemPrompt: string;
+        harness: 'dazl' | 'claude' | 'codex' | 'grok' | 'opencode';
+        model?: string;
+        allowedMcpServers?: Array<string>;
+        rules?: Array<{
+            text: string;
+            owners?: Array<string>;
+            blocking?: boolean;
+        }>;
+    };
+    prompt?: string;
+    input?: unknown;
+    upstream: Array<{
+        nodeKey: string;
+        title: string;
+        output: {
+            text: string;
+            files?: Array<string>;
+            changes?: Array<{
+                dirName: string;
+                from: string;
+                to: string;
+                commits: number;
+                files: Array<string>;
+            }>;
+        } | null;
+    }>;
+    reviewNodeId?: string;
+    onBehalfOf?: string;
+};
+
+export type WorkflowNodeToken = {
+    phaseVersion: number;
+    attempt: number;
+};
+
+export type WorkflowNodeRun = {
+    id: string;
+    runId: string;
+    nodeKey: string;
+    status: 'pending' | 'running' | 'awaiting-callback' | 'paused-for-human' | 'success' | 'error' | 'skipped';
+    phaseVersion: number;
+    attempt: number;
+    output?: unknown;
+    error: string | null;
+    awaitingDazlUserIds: Array<string>;
+    escalationReason: string | null;
+    startedAt: string | null;
+    finishedAt: string | null;
+};
+
+export type WorkflowRunEvent = {
+    id: string;
+    runId: string;
+    nodeKey: string | null;
+    type: 'status-change' | 'human-decision' | 'dispatch' | 'callback' | 'error' | 'harness-selected';
+    message: string;
+    actorDazlUserId: string | null;
+    data?: unknown;
+    at: string;
+    sequence: string;
+};
+
+export type WorkflowReviewDecision = {
+    id: string;
+    runId: string;
+    nodeRunId: string;
+    reviewerKey: string;
+    agentName: string;
+    onBehalfOf: string | null;
+    reviewerDazlUserId: string | null;
+    target: string;
+    suggestion: string;
+    rationale: string | null;
+    disposition: 'pending' | 'approved' | 'rejected';
+    decidedByDazlUserId: string | null;
+    decidedAt: string | null;
+    phase: string;
+    phaseVersion: number;
+};
+
+export type WorkflowRunGraph = {
+    nodes: Array<{
+        key: string;
+        kind: 'trigger' | 'work' | 'review' | 'agentTask' | 'humanGate' | 'script';
+        dependsOn: Array<string>;
+        dependsOnReviewsOf?: string;
+        phase?: string;
+        agent?: string;
+    }>;
+    phases: Array<{
+        key: string;
+        gateKey: string;
+        opensAfter: Array<string>;
+        reopens: Array<string>;
+        reviewers: Array<{
+            key: string;
+            agent: string;
+            prompt?: string;
+            onBehalfOf?: string;
+        }>;
+    }>;
+};
+
+export type AcceptedWorkflowNode = {
+    accepted: false;
+} | {
+    accepted: true;
+    payload: WorkflowDispatchPayload;
+};
+
+export type AcceptWorkflowNodeInput = {
+    token: WorkflowNodeToken;
+};
+
+export type SetWorkflowHarnessInput = {
+    harness: 'dazl' | 'claude' | 'codex' | 'grok' | 'opencode';
+    model?: string | null;
+};
+
+export type WorkflowNodeResultInput = {
+    token: WorkflowNodeToken;
+    output?: {
+        text: string;
+        files?: Array<string>;
+        changes?: Array<{
+            dirName: string;
+            from: string;
+            to: string;
+            commits: number;
+            files: Array<string>;
+        }>;
+    };
+    error?: string;
+    execution?: WorkflowExecutionMetadata;
+};
+
+export type WorkflowReviewReportInput = {
+    token: WorkflowNodeToken;
+    decision: 'approve' | 'object';
+    execution?: {
+        harness: 'dazl';
+        model?: string;
+        assistantMessageId?: string;
+    };
+    suggestions: Array<{
+        target: string;
+        suggestion: string;
+        rationale?: string;
+    }>;
+};
+
+export type WorkflowHumanDecisionInput = {
+    token: WorkflowNodeToken;
+    decision: 'approve' | 'reject';
+    comment?: string;
+};
+
 export type FeatureToggle = {
     name: string;
     scope: 'RemoteAndEditor' | 'SiteAndEditor';
@@ -2432,7 +2957,7 @@ export type GetPullRequestsStatusData = {
             number: number;
         }>;
         /**
-         * Falls back to this user's own GitHub connection when the project's installation cannot mint a token
+         * Falls back to this user's own GitHub connection when the project's installation cannot mint a token. Must match x-user-id when both are sent; the caller must be able to see the project
          */
         actingUserDazlId?: string;
     };
@@ -3731,6 +4256,10 @@ export type GetProjectInitDataResponses = {
              */
             isWorkspaceRoot?: boolean;
         }>;
+        /**
+         * The session was created with no template and no repos: with no snapshot to restore, its root folder stays empty instead of receiving the default template app
+         */
+        startEmpty?: boolean;
     };
 };
 
@@ -6272,39 +6801,18 @@ export type AppendMessagesResponses = {
 
 export type AppendMessagesResponse = AppendMessagesResponses[keyof AppendMessagesResponses];
 
-export type GetUploadConfigurationData = {
-    body: {
-        /**
-         * File path within the project
-         */
-        path: string;
-        /**
-         * Project identifier (optional for account-level uploads)
-         */
-        projectId?: string;
-        /**
-         * MIME type of the file to upload
-         */
-        mimeType?: string;
-        /**
-         * Access control level for the file
-         */
-        acl?: 'public' | 'private';
-        /**
-         * Callback URL to notify after upload completion
-         */
-        callback?: string;
-        /**
-         * Upload protocol to use
-         */
-        protocol?: 'tus';
+export type ListSessionNotesData = {
+    body?: never;
+    path: {
+        projectId: string;
     };
-    path?: never;
-    query?: never;
-    url: '/media/upload-configuration';
+    query: {
+        ownerDazlId: string;
+    };
+    url: '/session-note/project/{projectId}';
 };
 
-export type GetUploadConfigurationErrors = {
+export type ListSessionNotesErrors = {
     /**
      * Bad request - Invalid parameters or malformed JSON
      */
@@ -6317,17 +6825,13 @@ export type GetUploadConfigurationErrors = {
      */
     401: ErrorResponse;
     /**
-     * Forbidden - Permission denied
+     * Forbidden
      */
-    403: {
-        message: string;
-    };
+    403: ErrorResponse;
     /**
-     * Not found
+     * Not Found
      */
-    404: {
-        message: string;
-    };
+    404: ErrorResponse;
     /**
      * Conflict
      */
@@ -6342,42 +6846,42 @@ export type GetUploadConfigurationErrors = {
     503: ErrorResponse;
 };
 
-export type GetUploadConfigurationError = GetUploadConfigurationErrors[keyof GetUploadConfigurationErrors];
+export type ListSessionNotesError = ListSessionNotesErrors[keyof ListSessionNotesErrors];
 
-export type GetUploadConfigurationResponses = {
+export type ListSessionNotesResponses = {
     /**
-     * Returns presigned upload URL and configuration
+     * Lists the session's notes (its shared summary), oldest first.
      */
-    200: UploadConfiguration;
+    200: {
+        notes: Array<{
+            id: string;
+            projectId: string;
+            content: string;
+            createdAt: string;
+            updatedAt: string;
+            createdByChatId: string | null;
+            updatedByChatId: string | null;
+            updatedByUserId: string;
+        }>;
+    };
 };
 
-export type GetUploadConfigurationResponse = GetUploadConfigurationResponses[keyof GetUploadConfigurationResponses];
+export type ListSessionNotesResponse = ListSessionNotesResponses[keyof ListSessionNotesResponses];
 
-export type ListFilesData = {
-    body?: never;
-    path?: never;
-    query: {
-        /**
-         * Project identifier
-         */
+export type CreateSessionNoteData = {
+    body: {
+        ownerDazlId: string;
+        content: string;
+        chatId?: string;
+    };
+    path: {
         projectId: string;
-        /**
-         * Filter by MIME type prefix (e.g., 'image/' for all images)
-         */
-        mimeType?: string;
-        /**
-         * Cursor token for fetching the next page of results
-         */
-        cursor?: string;
-        /**
-         * Number of items per page
-         */
-        pageSize?: number;
     };
-    url: '/media/list';
+    query?: never;
+    url: '/session-note/project/{projectId}';
 };
 
-export type ListFilesErrors = {
+export type CreateSessionNoteErrors = {
     /**
      * Bad request - Invalid parameters or malformed JSON
      */
@@ -6390,17 +6894,13 @@ export type ListFilesErrors = {
      */
     401: ErrorResponse;
     /**
-     * Forbidden - Permission denied
+     * Forbidden
      */
-    403: {
-        message: string;
-    };
+    403: ErrorResponse;
     /**
-     * Not found
+     * Not Found
      */
-    404: {
-        message: string;
-    };
+    404: ErrorResponse;
     /**
      * Conflict
      */
@@ -6415,56 +6915,41 @@ export type ListFilesErrors = {
     503: ErrorResponse;
 };
 
-export type ListFilesError = ListFilesErrors[keyof ListFilesErrors];
+export type CreateSessionNoteError = CreateSessionNoteErrors[keyof CreateSessionNoteErrors];
 
-export type ListFilesResponses = {
+export type CreateSessionNoteResponses = {
     /**
-     * Returns paginated list of files in the project
+     * Adds a note to the session summary.
      */
-    200: MediaFileList;
+    200: {
+        note: {
+            id: string;
+            projectId: string;
+            content: string;
+            createdAt: string;
+            updatedAt: string;
+            createdByChatId: string | null;
+            updatedByChatId: string | null;
+            updatedByUserId: string;
+        };
+    };
 };
 
-export type ListFilesResponse = ListFilesResponses[keyof ListFilesResponses];
+export type CreateSessionNoteResponse = CreateSessionNoteResponses[keyof CreateSessionNoteResponses];
 
-export type CreateMediaData = {
+export type DeleteSessionNoteData = {
     body: {
-        /**
-         * Unique identifier for the media file
-         */
-        id: string;
-        /**
-         * MIME type of the media file
-         */
-        mimeType: string;
-        /**
-         * URL where the media file is accessible
-         */
-        url: string;
-        /**
-         * User's Dazl ID (required for internal API calls)
-         */
-        dazlId?: string;
-        /**
-         * Associated project identifier
-         */
-        projectId?: string | null;
-        /**
-         * Git commit hash associated with this media
-         */
-        gitCommit?: string | null;
-        /**
-         * Additional metadata as key-value pairs
-         */
-        descriptor?: {
-            [key: string]: unknown;
-        } | null;
+        ownerDazlId: string;
+    };
+    path: {
+        projectId: string;
+        noteId: string;
     };
-    path?: never;
     query?: never;
-    url: '/media';
+    url: '/session-note/project/{projectId}/{noteId}';
 };
 
-export type CreateMediaErrors = {
+export type DeleteSessionNoteErrors = {
     /**
      * Bad request - Invalid parameters or malformed JSON
      */
@@ -6477,17 +6962,13 @@ export type CreateMediaErrors = {
      */
     401: ErrorResponse;
     /**
-     * Forbidden - Permission denied
+     * Forbidden
      */
-    403: {
-        message: string;
-    };
+    403: ErrorResponse;
     /**
-     * Not found
+     * Not Found
      */
-    404: {
-        message: string;
-    };
+    404: ErrorResponse;
     /**
      * Conflict
      */
@@ -6502,45 +6983,34 @@ export type CreateMediaErrors = {
     503: ErrorResponse;
 };
 
-export type CreateMediaError = CreateMediaErrors[keyof CreateMediaErrors];
+export type DeleteSessionNoteError = DeleteSessionNoteErrors[keyof DeleteSessionNoteErrors];
 
-export type CreateMediaResponses = {
+export type DeleteSessionNoteResponses = {
     /**
-     * Media record created successfully
+     * Removes a note from the session summary.
      */
-    200: unknown;
+    200: {
+        deleted: true;
+    };
 };
 
-export type SaveMediaData = {
+export type DeleteSessionNoteResponse = DeleteSessionNoteResponses[keyof DeleteSessionNoteResponses];
+
+export type UpdateSessionNoteData = {
     body: {
-        /**
-         * Media record identifier
-         */
-        id: string;
-        /**
-         * AI-generated metadata from vision processing
-         */
-        metadata: {
-            title: string;
-            caption: string;
-            labels: Array<string>;
-            tags: Array<string>;
-            objects: Array<{
-                name: string;
-                confidence: number;
-            }>;
-            scenes: Array<string>;
-            colors: Array<string>;
-            text: string | null;
-            description: string;
-        };
+        ownerDazlId: string;
+        content: string;
+        chatId?: string;
+    };
+    path: {
+        projectId: string;
+        noteId: string;
     };
-    path?: never;
     query?: never;
-    url: '/media/save';
+    url: '/session-note/project/{projectId}/{noteId}';
 };
 
-export type SaveMediaErrors = {
+export type UpdateSessionNoteErrors = {
     /**
      * Bad request - Invalid parameters or malformed JSON
      */
@@ -6553,17 +7023,13 @@ export type SaveMediaErrors = {
      */
     401: ErrorResponse;
     /**
-     * Forbidden - Permission denied
+     * Forbidden
      */
-    403: {
-        message: string;
-    };
+    403: ErrorResponse;
     /**
-     * Not found
+     * Not Found
      */
-    404: {
-        message: string;
-    };
+    404: ErrorResponse;
     /**
      * Conflict
      */
@@ -6578,72 +7044,61 @@ export type SaveMediaErrors = {
     503: ErrorResponse;
 };
 
-export type SaveMediaError = SaveMediaErrors[keyof SaveMediaErrors];
+export type UpdateSessionNoteError = UpdateSessionNoteErrors[keyof UpdateSessionNoteErrors];
 
-export type SaveMediaResponses = {
+export type UpdateSessionNoteResponses = {
     /**
-     * Media metadata saved successfully
+     * Replaces the content of a session note.
      */
-    200: unknown;
+    200: {
+        note: {
+            id: string;
+            projectId: string;
+            content: string;
+            createdAt: string;
+            updatedAt: string;
+            createdByChatId: string | null;
+            updatedByChatId: string | null;
+            updatedByUserId: string;
+        };
+    };
 };
 
-export type TakeScreenshotData = {
+export type UpdateSessionNoteResponse = UpdateSessionNoteResponses[keyof UpdateSessionNoteResponses];
+
+export type GetUploadConfigurationData = {
     body: {
         /**
-         * URL of the page to capture
-         */
-        url: string;
-        /**
-         * Viewport width in pixels
-         */
-        width?: number;
-        /**
-         * Viewport height in pixels
-         */
-        height?: number;
-        /**
-         * Capture the full scrollable page
-         */
-        fullPage?: boolean;
-        /**
-         * Screenshot image format
+         * File path within the project
          */
-        imageType?: 'png' | 'jpeg';
+        path: string;
         /**
-         * Project identifier
+         * Project identifier (optional for account-level uploads)
          */
         projectId?: string;
         /**
-         * Custom storage path for the screenshot
-         */
-        storagePath?: string;
-        /**
-         * Git commit hash to associate with the screenshot
-         */
-        commitHash?: string;
-        /**
-         * User's Dazl ID (required for internal API calls)
+         * MIME type of the file to upload
          */
-        dazlId?: string;
+        mimeType?: string;
         /**
-         * Request timeout in milliseconds (1000-360000). Defaults to server configured value.
+         * Access control level for the file
          */
-        timeout?: number;
+        acl?: 'public' | 'private';
         /**
-         * Number of retry attempts on failure (0-10). Defaults to server configured value.
+         * Callback URL to notify after upload completion
          */
-        retries?: number;
+        callback?: string;
         /**
-         * Minimum delay in milliseconds before the first retry (0-30000). Defaults to server configured value.
+         * Upload protocol to use
          */
-        retryDelay?: number;
+        protocol?: 'tus';
     };
     path?: never;
     query?: never;
-    url: '/capture/screenshot';
+    url: '/media/upload-configuration';
 };
 
-export type TakeScreenshotErrors = {
+export type GetUploadConfigurationErrors = {
     /**
      * Bad request - Invalid parameters or malformed JSON
      */
@@ -6681,96 +7136,2049 @@ export type TakeScreenshotErrors = {
     503: ErrorResponse;
 };
 
-export type TakeScreenshotError = TakeScreenshotErrors[keyof TakeScreenshotErrors];
+export type GetUploadConfigurationError = GetUploadConfigurationErrors[keyof GetUploadConfigurationErrors];
 
-export type TakeScreenshotResponses = {
+export type GetUploadConfigurationResponses = {
     /**
-     * Screenshot captured successfully
+     * Returns presigned upload URL and configuration
      */
-    200: {
+    200: UploadConfiguration;
+};
+
+export type GetUploadConfigurationResponse = GetUploadConfigurationResponses[keyof GetUploadConfigurationResponses];
+
+export type ListFilesData = {
+    body?: never;
+    path?: never;
+    query: {
         /**
-         * Whether the operation succeeded
+         * Project identifier
          */
-        success: boolean;
+        projectId: string;
         /**
-         * Unique identifier for the screenshot
+         * Filter by MIME type prefix (e.g., 'image/' for all images)
          */
-        screenshotId: string;
+        mimeType?: string;
         /**
-         * Public URL of the screenshot
+         * Cursor token for fetching the next page of results
          */
-        publicUrl: string;
+        cursor?: string;
         /**
-         * Screenshot metadata
+         * Number of items per page
          */
-        metadata: {
-            /**
-             * Original URL that was captured
-             */
-            sourceUrl: string;
-            /**
-             * Viewport width used
-             */
-            width?: number;
-            /**
-             * Viewport height used
-             */
-            height?: number;
-            /**
-             * Whether full page was captured
-             */
-            fullPage?: boolean;
-            /**
-             * Image format
-             */
-            imageType: 'png' | 'jpeg';
-            /**
-             * ISO timestamp of capture
-             */
-            timestamp: string;
-            /**
-             * Associated project ID
-             */
-            projectId: string;
-        };
+        pageSize?: number;
     };
+    url: '/media/list';
+};
+
+export type ListFilesErrors = {
+    /**
+     * Bad request - Invalid parameters or malformed JSON
+     */
+    400: {
+        message: string;
+        issues?: string;
+    };
+    /**
+     * Unauthorized
+     */
+    401: ErrorResponse;
+    /**
+     * Forbidden - Permission denied
+     */
+    403: {
+        message: string;
+    };
+    /**
+     * Not found
+     */
+    404: {
+        message: string;
+    };
+    /**
+     * Conflict
+     */
+    409: ErrorResponse;
+    /**
+     * Internal server error
+     */
+    500: ErrorResponse;
+    /**
+     * Service Unavailable
+     */
+    503: ErrorResponse;
+};
+
+export type ListFilesError = ListFilesErrors[keyof ListFilesErrors];
+
+export type ListFilesResponses = {
+    /**
+     * Returns paginated list of files in the project
+     */
+    200: MediaFileList;
+};
+
+export type ListFilesResponse = ListFilesResponses[keyof ListFilesResponses];
+
+export type CreateMediaData = {
+    body: {
+        /**
+         * Unique identifier for the media file
+         */
+        id: string;
+        /**
+         * MIME type of the media file
+         */
+        mimeType: string;
+        /**
+         * URL where the media file is accessible
+         */
+        url: string;
+        /**
+         * User's Dazl ID (required for internal API calls)
+         */
+        dazlId?: string;
+        /**
+         * Associated project identifier
+         */
+        projectId?: string | null;
+        /**
+         * Git commit hash associated with this media
+         */
+        gitCommit?: string | null;
+        /**
+         * Additional metadata as key-value pairs
+         */
+        descriptor?: {
+            [key: string]: unknown;
+        } | null;
+    };
+    path?: never;
+    query?: never;
+    url: '/media';
+};
+
+export type CreateMediaErrors = {
+    /**
+     * Bad request - Invalid parameters or malformed JSON
+     */
+    400: {
+        message: string;
+        issues?: string;
+    };
+    /**
+     * Unauthorized
+     */
+    401: ErrorResponse;
+    /**
+     * Forbidden - Permission denied
+     */
+    403: {
+        message: string;
+    };
+    /**
+     * Not found
+     */
+    404: {
+        message: string;
+    };
+    /**
+     * Conflict
+     */
+    409: ErrorResponse;
+    /**
+     * Internal server error
+     */
+    500: ErrorResponse;
+    /**
+     * Service Unavailable
+     */
+    503: ErrorResponse;
+};
+
+export type CreateMediaError = CreateMediaErrors[keyof CreateMediaErrors];
+
+export type CreateMediaResponses = {
+    /**
+     * Media record created successfully
+     */
+    200: unknown;
+};
+
+export type SaveMediaData = {
+    body: {
+        /**
+         * Media record identifier
+         */
+        id: string;
+        /**
+         * AI-generated metadata from vision processing
+         */
+        metadata: {
+            title: string;
+            caption: string;
+            labels: Array<string>;
+            tags: Array<string>;
+            objects: Array<{
+                name: string;
+                confidence: number;
+            }>;
+            scenes: Array<string>;
+            colors: Array<string>;
+            text: string | null;
+            description: string;
+        };
+    };
+    path?: never;
+    query?: never;
+    url: '/media/save';
+};
+
+export type SaveMediaErrors = {
+    /**
+     * Bad request - Invalid parameters or malformed JSON
+     */
+    400: {
+        message: string;
+        issues?: string;
+    };
+    /**
+     * Unauthorized
+     */
+    401: ErrorResponse;
+    /**
+     * Forbidden - Permission denied
+     */
+    403: {
+        message: string;
+    };
+    /**
+     * Not found
+     */
+    404: {
+        message: string;
+    };
+    /**
+     * Conflict
+     */
+    409: ErrorResponse;
+    /**
+     * Internal server error
+     */
+    500: ErrorResponse;
+    /**
+     * Service Unavailable
+     */
+    503: ErrorResponse;
+};
+
+export type SaveMediaError = SaveMediaErrors[keyof SaveMediaErrors];
+
+export type SaveMediaResponses = {
+    /**
+     * Media metadata saved successfully
+     */
+    200: unknown;
+};
+
+export type TakeScreenshotData = {
+    body: {
+        /**
+         * URL of the page to capture
+         */
+        url: string;
+        /**
+         * Viewport width in pixels
+         */
+        width?: number;
+        /**
+         * Viewport height in pixels
+         */
+        height?: number;
+        /**
+         * Capture the full scrollable page
+         */
+        fullPage?: boolean;
+        /**
+         * Screenshot image format
+         */
+        imageType?: 'png' | 'jpeg';
+        /**
+         * Project identifier
+         */
+        projectId?: string;
+        /**
+         * Custom storage path for the screenshot
+         */
+        storagePath?: string;
+        /**
+         * Git commit hash to associate with the screenshot
+         */
+        commitHash?: string;
+        /**
+         * User's Dazl ID (required for internal API calls)
+         */
+        dazlId?: string;
+        /**
+         * Request timeout in milliseconds (1000-360000). Defaults to server configured value.
+         */
+        timeout?: number;
+        /**
+         * Number of retry attempts on failure (0-10). Defaults to server configured value.
+         */
+        retries?: number;
+        /**
+         * Minimum delay in milliseconds before the first retry (0-30000). Defaults to server configured value.
+         */
+        retryDelay?: number;
+    };
+    path?: never;
+    query?: never;
+    url: '/capture/screenshot';
+};
+
+export type TakeScreenshotErrors = {
+    /**
+     * Bad request - Invalid parameters or malformed JSON
+     */
+    400: {
+        message: string;
+        issues?: string;
+    };
+    /**
+     * Unauthorized
+     */
+    401: ErrorResponse;
+    /**
+     * Forbidden - Permission denied
+     */
+    403: {
+        message: string;
+    };
+    /**
+     * Not found
+     */
+    404: {
+        message: string;
+    };
+    /**
+     * Conflict
+     */
+    409: ErrorResponse;
+    /**
+     * Internal server error
+     */
+    500: ErrorResponse;
+    /**
+     * Service Unavailable
+     */
+    503: ErrorResponse;
+};
+
+export type TakeScreenshotError = TakeScreenshotErrors[keyof TakeScreenshotErrors];
+
+export type TakeScreenshotResponses = {
+    /**
+     * Screenshot captured successfully
+     */
+    200: {
+        /**
+         * Whether the operation succeeded
+         */
+        success: boolean;
+        /**
+         * Unique identifier for the screenshot
+         */
+        screenshotId: string;
+        /**
+         * Public URL of the screenshot
+         */
+        publicUrl: string;
+        /**
+         * Screenshot metadata
+         */
+        metadata: {
+            /**
+             * Original URL that was captured
+             */
+            sourceUrl: string;
+            /**
+             * Viewport width used
+             */
+            width?: number;
+            /**
+             * Viewport height used
+             */
+            height?: number;
+            /**
+             * Whether full page was captured
+             */
+            fullPage?: boolean;
+            /**
+             * Image format
+             */
+            imageType: 'png' | 'jpeg';
+            /**
+             * ISO timestamp of capture
+             */
+            timestamp: string;
+            /**
+             * Associated project ID
+             */
+            projectId: string;
+        };
+    };
+};
+
+export type TakeScreenshotResponse = TakeScreenshotResponses[keyof TakeScreenshotResponses];
+
+export type ScrapePageContentData = {
+    body: {
+        /**
+         * URL of the page to scrape
+         */
+        url: string;
+        /**
+         * Only return the main content of the page excluding headers, navs, footers, etc.
+         */
+        onlyMainContent?: boolean;
+        /**
+         * Emulate scraping from a mobile device
+         */
+        mobile?: boolean;
+        /**
+         * Fetch external CSS stylesheets and inline them as <style> tags for fully self-contained HTML
+         */
+        inlineExternalCss?: boolean;
+        /**
+         * Include structured branding/design system data (colors, fonts, typography, spacing, components)
+         */
+        includeBranding?: boolean;
+        /**
+         * Request timeout in milliseconds (1000-360000). Defaults to server configured value.
+         */
+        timeout?: number;
+    };
+    path?: never;
+    query?: never;
+    url: '/capture/scrape';
+};
+
+export type ScrapePageContentErrors = {
+    /**
+     * Bad request - Invalid parameters or malformed JSON
+     */
+    400: {
+        message: string;
+        issues?: string;
+    };
+    /**
+     * Unauthorized
+     */
+    401: ErrorResponse;
+    /**
+     * Forbidden - Permission denied
+     */
+    403: {
+        message: string;
+    };
+    /**
+     * Not found
+     */
+    404: {
+        message: string;
+    };
+    /**
+     * Conflict
+     */
+    409: ErrorResponse;
+    /**
+     * Internal server error
+     */
+    500: ErrorResponse;
+    /**
+     * Service Unavailable
+     */
+    503: ErrorResponse;
+};
+
+export type ScrapePageContentError = ScrapePageContentErrors[keyof ScrapePageContentErrors];
+
+export type ScrapePageContentResponses = {
+    /**
+     * Page content scraped successfully
+     */
+    200: {
+        /**
+         * Whether the operation succeeded
+         */
+        success: boolean;
+        /**
+         * Cleaned HTML content of the page (processed for readability)
+         */
+        html: string;
+        /**
+         * Raw HTML content of the page as-is
+         */
+        rawHtml: string;
+        /**
+         * Page metadata
+         */
+        metadata?: {
+            title?: string;
+            description?: string;
+            language?: string;
+            sourceURL?: string;
+            keywords?: string;
+            ogLocaleAlternate?: Array<string>;
+            statusCode: number;
+            error?: string;
+        };
+        /**
+         * Structured branding/design system data (when includeBranding is true)
+         */
+        branding?: {
+            colorScheme?: 'light' | 'dark' | null;
+            logo?: string | null;
+            colors?: {
+                [key: string]: unknown;
+            } | null;
+            fonts?: Array<{
+                [key: string]: unknown;
+            }> | null;
+            typography?: {
+                [key: string]: unknown;
+            } | null;
+            spacing?: {
+                [key: string]: unknown;
+            } | null;
+            components?: {
+                [key: string]: unknown;
+            } | null;
+            images?: {
+                [key: string]: unknown;
+            } | null;
+            [key: string]: unknown;
+        };
+    };
+};
+
+export type ScrapePageContentResponse = ScrapePageContentResponses[keyof ScrapePageContentResponses];
+
+export type GetUserByDazlIdData = {
+    body?: never;
+    path: {
+        dazlId: string;
+    };
+    query?: never;
+    url: '/user/{dazlId}';
+};
+
+export type GetUserByDazlIdErrors = {
+    /**
+     * Bad request - Invalid parameters or malformed JSON
+     */
+    400: {
+        message: string;
+        issues?: string;
+    };
+    /**
+     * Unauthorized
+     */
+    401: ErrorResponse;
+    /**
+     * Forbidden
+     */
+    403: ErrorResponse;
+    /**
+     * Not Found
+     */
+    404: ErrorResponse;
+    /**
+     * Conflict
+     */
+    409: ErrorResponse;
+    /**
+     * Internal server error
+     */
+    500: ErrorResponse;
+    /**
+     * Service Unavailable
+     */
+    503: ErrorResponse;
+};
+
+export type GetUserByDazlIdError = GetUserByDazlIdErrors[keyof GetUserByDazlIdErrors];
+
+export type GetUserByDazlIdResponses = {
+    /**
+     * Returns the requested user
+     */
+    200: {
+        user: UserRaw;
+    };
+};
+
+export type GetUserByDazlIdResponse = GetUserByDazlIdResponses[keyof GetUserByDazlIdResponses];
+
+export type UpdateUserData = {
+    body: {
+        picture?: string | null;
+        name?: string;
+        jobRole?: string | null;
+    };
+    path: {
+        dazlId: string;
+    };
+    query?: never;
+    url: '/user/{dazlId}';
+};
+
+export type UpdateUserErrors = {
+    /**
+     * Bad request - Invalid parameters or malformed JSON
+     */
+    400: {
+        message: string;
+        issues?: string;
+    };
+    /**
+     * Unauthorized
+     */
+    401: ErrorResponse;
+    /**
+     * Forbidden
+     */
+    403: ErrorResponse;
+    /**
+     * Not Found
+     */
+    404: ErrorResponse;
+    /**
+     * Conflict
+     */
+    409: ErrorResponse;
+    /**
+     * Internal server error
+     */
+    500: ErrorResponse;
+    /**
+     * Service Unavailable
+     */
+    503: ErrorResponse;
+};
+
+export type UpdateUserError = UpdateUserErrors[keyof UpdateUserErrors];
+
+export type UpdateUserResponses = {
+    /**
+     * Updates user information
+     */
+    200: {
+        user: UserRaw;
+    };
+};
+
+export type UpdateUserResponse = UpdateUserResponses[keyof UpdateUserResponses];
+
+export type GetUsersByDazlIdsData = {
+    body: {
+        dazlIds: Array<string>;
+    };
+    path?: never;
+    query?: never;
+    url: '/user/list-by-dazl-ids';
+};
+
+export type GetUsersByDazlIdsErrors = {
+    /**
+     * Bad request - Invalid parameters or malformed JSON
+     */
+    400: {
+        message: string;
+        issues?: string;
+    };
+    /**
+     * Unauthorized
+     */
+    401: ErrorResponse;
+    /**
+     * Forbidden
+     */
+    403: ErrorResponse;
+    /**
+     * Not Found
+     */
+    404: ErrorResponse;
+    /**
+     * Conflict
+     */
+    409: ErrorResponse;
+    /**
+     * Internal server error
+     */
+    500: ErrorResponse;
+    /**
+     * Service Unavailable
+     */
+    503: ErrorResponse;
+};
+
+export type GetUsersByDazlIdsError = GetUsersByDazlIdsErrors[keyof GetUsersByDazlIdsErrors];
+
+export type GetUsersByDazlIdsResponses = {
+    /**
+     * Returns the requested users
+     */
+    200: {
+        users: Array<UserDisplayInfoResponse>;
+    };
+};
+
+export type GetUsersByDazlIdsResponse = GetUsersByDazlIdsResponses[keyof GetUsersByDazlIdsResponses];
+
+export type GetUsersByEmailsData = {
+    body: {
+        emails: Array<string>;
+    };
+    path?: never;
+    query?: never;
+    url: '/user/list-by-emails';
+};
+
+export type GetUsersByEmailsErrors = {
+    /**
+     * Bad request - Invalid parameters or malformed JSON
+     */
+    400: {
+        message: string;
+        issues?: string;
+    };
+    /**
+     * Unauthorized
+     */
+    401: ErrorResponse;
+    /**
+     * Forbidden
+     */
+    403: ErrorResponse;
+    /**
+     * Not Found
+     */
+    404: ErrorResponse;
+    /**
+     * Conflict
+     */
+    409: ErrorResponse;
+    /**
+     * Internal server error
+     */
+    500: ErrorResponse;
+    /**
+     * Service Unavailable
+     */
+    503: ErrorResponse;
+};
+
+export type GetUsersByEmailsError = GetUsersByEmailsErrors[keyof GetUsersByEmailsErrors];
+
+export type GetUsersByEmailsResponses = {
+    /**
+     * Returns the requested users
+     */
+    200: {
+        users: Array<UserDisplayInfoResponse>;
+    };
+};
+
+export type GetUsersByEmailsResponse = GetUsersByEmailsResponses[keyof GetUsersByEmailsResponses];
+
+export type CreateUserData = {
+    body: {
+        dazlId: string;
+        name: string;
+        email: string;
+        authSub: string;
+        picture?: string | null;
+        jobRole?: string | null;
+    };
+    path?: never;
+    query?: never;
+    url: '/user/create';
+};
+
+export type CreateUserErrors = {
+    /**
+     * Bad request - Invalid parameters or malformed JSON
+     */
+    400: {
+        message: string;
+        issues?: string;
+    };
+    /**
+     * Unauthorized
+     */
+    401: ErrorResponse;
+    /**
+     * Forbidden
+     */
+    403: ErrorResponse;
+    /**
+     * Not Found
+     */
+    404: ErrorResponse;
+    /**
+     * Conflict
+     */
+    409: ErrorResponse;
+    /**
+     * Internal server error
+     */
+    500: ErrorResponse;
+    /**
+     * Service Unavailable
+     */
+    503: ErrorResponse;
+};
+
+export type CreateUserError = CreateUserErrors[keyof CreateUserErrors];
+
+export type CreateUserResponses = {
+    /**
+     * Creates a new user with billing customer
+     */
+    200: {
+        user: UserRaw;
+    };
+};
+
+export type CreateUserResponse = CreateUserResponses[keyof CreateUserResponses];
+
+export type SearchWebData = {
+    body: {
+        /**
+         * Search query
+         */
+        query: string;
+        /**
+         * Maximum number of results to return
+         */
+        limit?: number;
+        /**
+         * Location parameter for search results
+         */
+        location?: string;
+        /**
+         * Timeout for the search in milliseconds
+         */
+        timeout?: number;
+        /**
+         * Options for scraping search results
+         */
+        scrapeOptions?: {
+            /**
+             * Formats to return
+             */
+            formats?: Array<'summary' | 'json' | {
+                type: 'json';
+                prompt: string;
+                schema?: {
+                    [key: string]: unknown;
+                };
+            } | {
+                type: 'summary' | 'json';
+            }>;
+            /**
+             * Maximum age of cached content
+             */
+            maxAge?: number;
+            /**
+             * Timeout for scraping each document in milliseconds
+             */
+            timeout?: number;
+            /**
+             * Parsers to use for content extraction
+             */
+            parsers?: Array<string | {
+                type: 'pdf';
+                maxPages?: number;
+            }>;
+        };
+    };
+    path?: never;
+    query?: never;
+    url: '/search/web';
+};
+
+export type SearchWebErrors = {
+    /**
+     * Bad request - Invalid parameters or malformed JSON
+     */
+    400: {
+        message: string;
+        issues?: string;
+    };
+    /**
+     * Unauthorized
+     */
+    401: ErrorResponse;
+    /**
+     * Forbidden
+     */
+    403: ErrorResponse;
+    /**
+     * Not Found
+     */
+    404: ErrorResponse;
+    /**
+     * Conflict
+     */
+    409: ErrorResponse;
+    /**
+     * Internal server error
+     */
+    500: ErrorResponse;
+    /**
+     * Service Unavailable
+     */
+    503: ErrorResponse;
+};
+
+export type SearchWebError = SearchWebErrors[keyof SearchWebErrors];
+
+export type SearchWebResponses = {
+    /**
+     * Search results organized by source type
+     */
+    200: {
+        web?: Array<{
+            url: string;
+            title?: string;
+            description?: string;
+            json?: unknown;
+            summary?: string;
+            metadata?: {
+                creditsUsed?: number;
+            };
+        }>;
+    };
+};
+
+export type SearchWebResponse = SearchWebResponses[keyof SearchWebResponses];
+
+export type AdminDeleteProjectData = {
+    body: DeleteProjectInput;
+    path: {
+        projectId: string;
+    };
+    query?: never;
+    url: '/admin/project/{projectId}';
+};
+
+export type AdminDeleteProjectErrors = {
+    /**
+     * Bad request - Invalid parameters or malformed JSON
+     */
+    400: {
+        message: string;
+        issues?: string;
+    };
+    /**
+     * Unauthorized
+     */
+    401: ErrorResponse;
+    /**
+     * Forbidden
+     */
+    403: ErrorResponse;
+    /**
+     * Not Found
+     */
+    404: ErrorResponse;
+    /**
+     * Conflict
+     */
+    409: ErrorResponse;
+    /**
+     * Internal server error
+     */
+    500: ErrorResponse;
+    /**
+     * Service Unavailable
+     */
+    503: ErrorResponse;
+};
+
+export type AdminDeleteProjectError = AdminDeleteProjectErrors[keyof AdminDeleteProjectErrors];
+
+export type AdminDeleteProjectResponses = {
+    /**
+     * Project deleted successfully
+     */
+    200: {
+        success: boolean;
+        projectId: string;
+    };
+};
+
+export type AdminDeleteProjectResponse = AdminDeleteProjectResponses[keyof AdminDeleteProjectResponses];
+
+export type AdminCloneProjectCreateData = {
+    body: CloneProjectCreateInput;
+    path?: never;
+    query?: never;
+    url: '/admin/project/clone';
+};
+
+export type AdminCloneProjectCreateErrors = {
+    /**
+     * Bad request - Invalid parameters or malformed JSON
+     */
+    400: {
+        message: string;
+        issues?: string;
+    };
+    /**
+     * Unauthorized
+     */
+    401: ErrorResponse;
+    /**
+     * Forbidden
+     */
+    403: ErrorResponse;
+    /**
+     * Not Found
+     */
+    404: ErrorResponse;
+    /**
+     * Conflict
+     */
+    409: ErrorResponse;
+    /**
+     * Internal server error
+     */
+    500: ErrorResponse;
+    /**
+     * Service Unavailable
+     */
+    503: ErrorResponse;
+};
+
+export type AdminCloneProjectCreateError = AdminCloneProjectCreateErrors[keyof AdminCloneProjectCreateErrors];
+
+export type AdminCloneProjectCreateResponses = {
+    /**
+     * Returns the ID of the newly created clone project record
+     */
+    200: {
+        newProjectId: string;
+    };
+};
+
+export type AdminCloneProjectCreateResponse = AdminCloneProjectCreateResponses[keyof AdminCloneProjectCreateResponses];
+
+export type AdminCloneProjectLogData = {
+    body: CloneProjectLogInput;
+    path?: never;
+    query?: never;
+    url: '/admin/project/clone/log';
+};
+
+export type AdminCloneProjectLogErrors = {
+    /**
+     * Bad request - Invalid parameters or malformed JSON
+     */
+    400: {
+        message: string;
+        issues?: string;
+    };
+    /**
+     * Unauthorized
+     */
+    401: ErrorResponse;
+    /**
+     * Forbidden
+     */
+    403: ErrorResponse;
+    /**
+     * Not Found
+     */
+    404: ErrorResponse;
+    /**
+     * Conflict
+     */
+    409: ErrorResponse;
+    /**
+     * Internal server error
+     */
+    500: ErrorResponse;
+    /**
+     * Service Unavailable
+     */
+    503: ErrorResponse;
+};
+
+export type AdminCloneProjectLogError = AdminCloneProjectLogErrors[keyof AdminCloneProjectLogErrors];
+
+export type AdminCloneProjectLogResponses = {
+    /**
+     * Admin action logged successfully
+     */
+    200: {
+        success: boolean;
+    };
+};
+
+export type AdminCloneProjectLogResponse = AdminCloneProjectLogResponses[keyof AdminCloneProjectLogResponses];
+
+export type AdminCleanupProjectData = {
+    body: CleanupProjectInput;
+    path?: never;
+    query?: never;
+    url: '/admin/project/cleanup';
+};
+
+export type AdminCleanupProjectErrors = {
+    /**
+     * Bad request - Invalid parameters or malformed JSON
+     */
+    400: {
+        message: string;
+        issues?: string;
+    };
+    /**
+     * Unauthorized
+     */
+    401: ErrorResponse;
+    /**
+     * Forbidden
+     */
+    403: ErrorResponse;
+    /**
+     * Not Found
+     */
+    404: ErrorResponse;
+    /**
+     * Conflict
+     */
+    409: ErrorResponse;
+    /**
+     * Internal server error
+     */
+    500: ErrorResponse;
+    /**
+     * Service Unavailable
+     */
+    503: ErrorResponse;
+};
+
+export type AdminCleanupProjectError = AdminCleanupProjectErrors[keyof AdminCleanupProjectErrors];
+
+export type AdminCleanupProjectResponses = {
+    /**
+     * Project cleaned up successfully
+     */
+    200: {
+        success: boolean;
+    };
+};
+
+export type AdminCleanupProjectResponse = AdminCleanupProjectResponses[keyof AdminCleanupProjectResponses];
+
+export type AdminUpdateCreditsData = {
+    body: UpdateCreditsInput;
+    path?: never;
+    query?: never;
+    url: '/admin/credits';
+};
+
+export type AdminUpdateCreditsErrors = {
+    /**
+     * Bad request - Invalid parameters or malformed JSON
+     */
+    400: {
+        message: string;
+        issues?: string;
+    };
+    /**
+     * Unauthorized
+     */
+    401: ErrorResponse;
+    /**
+     * Forbidden
+     */
+    403: ErrorResponse;
+    /**
+     * Not Found
+     */
+    404: ErrorResponse;
+    /**
+     * Conflict
+     */
+    409: ErrorResponse;
+    /**
+     * Internal server error
+     */
+    500: ErrorResponse;
+    /**
+     * Service Unavailable
+     */
+    503: ErrorResponse;
+};
+
+export type AdminUpdateCreditsError = AdminUpdateCreditsErrors[keyof AdminUpdateCreditsErrors];
+
+export type AdminUpdateCreditsResponses = {
+    /**
+     * Credits updated successfully
+     */
+    200: {
+        success: boolean;
+        newBalance: number;
+    };
+};
+
+export type AdminUpdateCreditsResponse = AdminUpdateCreditsResponses[keyof AdminUpdateCreditsResponses];
+
+export type AdminLogActionData = {
+    body: {
+        action: string;
+        /**
+         * The target user's Dazl ID
+         */
+        targetDazlUserId?: string;
+        targetProjectId?: string;
+        message: string;
+        reason?: string;
+    } & {
+        /**
+         * The admin user's Dazl ID
+         */
+        adminDazlUserId: string;
+    };
+    path?: never;
+    query?: never;
+    url: '/admin/action/log';
+};
+
+export type AdminLogActionErrors = {
+    /**
+     * Bad request - Invalid parameters or malformed JSON
+     */
+    400: {
+        message: string;
+        issues?: string;
+    };
+    /**
+     * Unauthorized
+     */
+    401: ErrorResponse;
+    /**
+     * Forbidden
+     */
+    403: ErrorResponse;
+    /**
+     * Not Found
+     */
+    404: ErrorResponse;
+    /**
+     * Conflict
+     */
+    409: ErrorResponse;
+    /**
+     * Internal server error
+     */
+    500: ErrorResponse;
+    /**
+     * Service Unavailable
+     */
+    503: ErrorResponse;
+};
+
+export type AdminLogActionError = AdminLogActionErrors[keyof AdminLogActionErrors];
+
+export type AdminLogActionResponses = {
+    /**
+     * Admin action logged successfully
+     */
+    200: {
+        success: boolean;
+    };
+};
+
+export type AdminLogActionResponse = AdminLogActionResponses[keyof AdminLogActionResponses];
+
+export type OpenFeatureToggleData = {
+    body: {
+        name: string;
+        scope: 'RemoteAndEditor' | 'SiteAndEditor';
+    };
+    path?: never;
+    query?: never;
+    url: '/env-config/open';
+};
+
+export type OpenFeatureToggleErrors = {
+    /**
+     * Bad request - Invalid parameters or malformed JSON
+     */
+    400: {
+        message: string;
+        issues?: string;
+    };
+    /**
+     * Unauthorized
+     */
+    401: ErrorResponse;
+    /**
+     * Forbidden
+     */
+    403: ErrorResponse;
+    /**
+     * Not Found
+     */
+    404: ErrorResponse;
+    /**
+     * Conflict
+     */
+    409: ErrorResponse;
+    /**
+     * Internal server error
+     */
+    500: ErrorResponse;
+    /**
+     * Service Unavailable
+     */
+    503: ErrorResponse;
+};
+
+export type OpenFeatureToggleError = OpenFeatureToggleErrors[keyof OpenFeatureToggleErrors];
+
+export type OpenFeatureToggleResponses = {
+    /**
+     * Opens a feature toggle
+     */
+    200: {
+        success: boolean;
+    };
+};
+
+export type OpenFeatureToggleResponse = OpenFeatureToggleResponses[keyof OpenFeatureToggleResponses];
+
+export type CloseFeatureToggleData = {
+    body: {
+        name: string;
+    };
+    path?: never;
+    query?: never;
+    url: '/env-config/close';
+};
+
+export type CloseFeatureToggleErrors = {
+    /**
+     * Bad request - Invalid parameters or malformed JSON
+     */
+    400: {
+        message: string;
+        issues?: string;
+    };
+    /**
+     * Unauthorized
+     */
+    401: ErrorResponse;
+    /**
+     * Forbidden
+     */
+    403: ErrorResponse;
+    /**
+     * Not Found
+     */
+    404: ErrorResponse;
+    /**
+     * Conflict
+     */
+    409: ErrorResponse;
+    /**
+     * Internal server error
+     */
+    500: ErrorResponse;
+    /**
+     * Service Unavailable
+     */
+    503: ErrorResponse;
+};
+
+export type CloseFeatureToggleError = CloseFeatureToggleErrors[keyof CloseFeatureToggleErrors];
+
+export type CloseFeatureToggleResponses = {
+    /**
+     * Closes a feature toggle
+     */
+    200: {
+        success: boolean;
+    };
+};
+
+export type CloseFeatureToggleResponse = CloseFeatureToggleResponses[keyof CloseFeatureToggleResponses];
+
+export type PurgeUserAccountData = {
+    body: PurgeUserAccountInput;
+    path?: never;
+    query?: never;
+    url: '/purge/user-account';
+};
+
+export type PurgeUserAccountErrors = {
+    /**
+     * Bad request - Invalid parameters or malformed JSON
+     */
+    400: {
+        message: string;
+        issues?: string;
+    };
+    /**
+     * Unauthorized
+     */
+    401: ErrorResponse;
+    /**
+     * Forbidden
+     */
+    403: ErrorResponse;
+    /**
+     * Not Found
+     */
+    404: ErrorResponse;
+    /**
+     * Conflict
+     */
+    409: ErrorResponse;
+    /**
+     * Internal server error
+     */
+    500: ErrorResponse;
+    /**
+     * Service Unavailable
+     */
+    503: ErrorResponse;
+};
+
+export type PurgeUserAccountError = PurgeUserAccountErrors[keyof PurgeUserAccountErrors];
+
+export type PurgeUserAccountResponses = {
+    /**
+     * User account purged from all systems
+     */
+    200: {
+        success: boolean;
+        results: {
+            [key: string]: {
+                discovered: Array<string>;
+                deleted: Array<string>;
+            };
+        };
+    };
+};
+
+export type PurgeUserAccountResponse = PurgeUserAccountResponses[keyof PurgeUserAccountResponses];
+
+export type GetValuesData = {
+    body?: never;
+    path: {
+        dazlUserId: string;
+    };
+    query?: {
+        /**
+         * Filter results to this category
+         */
+        categ?: string;
+    };
+    url: '/user-key-value/{dazlUserId}/values';
+};
+
+export type GetValuesErrors = {
+    /**
+     * Bad request - Invalid parameters or malformed JSON
+     */
+    400: {
+        message: string;
+        issues?: string;
+    };
+    /**
+     * Unauthorized
+     */
+    401: ErrorResponse;
+    /**
+     * Forbidden
+     */
+    403: ErrorResponse;
+    /**
+     * Not Found
+     */
+    404: ErrorResponse;
+    /**
+     * Conflict
+     */
+    409: ErrorResponse;
+    /**
+     * Internal server error
+     */
+    500: ErrorResponse;
+    /**
+     * Service Unavailable
+     */
+    503: ErrorResponse;
+};
+
+export type GetValuesError = GetValuesErrors[keyof GetValuesErrors];
+
+export type GetValuesResponses = {
+    /**
+     * Returns key values for the user
+     */
+    200: {
+        values: Array<{
+            id: string;
+            dazlUserId: string;
+            category: string;
+            name: string;
+            strVal: string | null;
+            encryptedValId: string | null;
+            createdAt: string;
+            updatedAt: string;
+            encryptedValue: string | null;
+        }>;
+    };
+};
+
+export type GetValuesResponse = GetValuesResponses[keyof GetValuesResponses];
+
+export type SetValueData = {
+    body: {
+        value: string;
+        isSecret?: boolean;
+    };
+    path: {
+        dazlUserId: string;
+        categ: string;
+        name: string;
+    };
+    query?: never;
+    url: '/user-key-value/{dazlUserId}/values/{categ}/{name}';
+};
+
+export type SetValueErrors = {
+    /**
+     * Bad request - Invalid parameters or malformed JSON
+     */
+    400: {
+        message: string;
+        issues?: string;
+    };
+    /**
+     * Unauthorized
+     */
+    401: ErrorResponse;
+    /**
+     * Forbidden
+     */
+    403: ErrorResponse;
+    /**
+     * Not Found
+     */
+    404: ErrorResponse;
+    /**
+     * Conflict
+     */
+    409: ErrorResponse;
+    /**
+     * Internal server error
+     */
+    500: ErrorResponse;
+    /**
+     * Service Unavailable
+     */
+    503: ErrorResponse;
+};
+
+export type SetValueError = SetValueErrors[keyof SetValueErrors];
+
+export type SetValueResponses = {
+    /**
+     * Sets a single key value and returns its id
+     */
+    200: {
+        id: string;
+    };
+};
+
+export type SetValueResponse = SetValueResponses[keyof SetValueResponses];
+
+export type DeleteCategValuesData = {
+    body?: never;
+    path: {
+        dazlUserId: string;
+        categ: string;
+    };
+    query?: never;
+    url: '/user-key-value/{dazlUserId}/values/{categ}';
+};
+
+export type DeleteCategValuesErrors = {
+    /**
+     * Bad request - Invalid parameters or malformed JSON
+     */
+    400: {
+        message: string;
+        issues?: string;
+    };
+    /**
+     * Unauthorized
+     */
+    401: ErrorResponse;
+    /**
+     * Forbidden
+     */
+    403: ErrorResponse;
+    /**
+     * Not Found
+     */
+    404: ErrorResponse;
+    /**
+     * Conflict
+     */
+    409: ErrorResponse;
+    /**
+     * Internal server error
+     */
+    500: ErrorResponse;
+    /**
+     * Service Unavailable
+     */
+    503: ErrorResponse;
+};
+
+export type DeleteCategValuesError = DeleteCategValuesErrors[keyof DeleteCategValuesErrors];
+
+export type DeleteCategValuesResponses = {
+    /**
+     * Deletes all values for the category
+     */
+    200: {
+        categ: string;
+    };
+};
+
+export type DeleteCategValuesResponse = DeleteCategValuesResponses[keyof DeleteCategValuesResponses];
+
+export type ReplaceCategValuesData = {
+    body: {
+        values: Array<{
+            name: string;
+            value: string;
+            isSecret?: boolean;
+        }>;
+    };
+    path: {
+        dazlUserId: string;
+        categ: string;
+    };
+    query?: never;
+    url: '/user-key-value/{dazlUserId}/values/{categ}';
+};
+
+export type ReplaceCategValuesErrors = {
+    /**
+     * Bad request - Invalid parameters or malformed JSON
+     */
+    400: {
+        message: string;
+        issues?: string;
+    };
+    /**
+     * Unauthorized
+     */
+    401: ErrorResponse;
+    /**
+     * Forbidden
+     */
+    403: ErrorResponse;
+    /**
+     * Not Found
+     */
+    404: ErrorResponse;
+    /**
+     * Conflict
+     */
+    409: ErrorResponse;
+    /**
+     * Internal server error
+     */
+    500: ErrorResponse;
+    /**
+     * Service Unavailable
+     */
+    503: ErrorResponse;
+};
+
+export type ReplaceCategValuesError = ReplaceCategValuesErrors[keyof ReplaceCategValuesErrors];
+
+export type ReplaceCategValuesResponses = {
+    /**
+     * Replaces all values for the category and returns the upserted rows
+     */
+    200: {
+        values: Array<{
+            id: string;
+            name: string;
+        }>;
+        replaced: boolean;
+    };
+};
+
+export type ReplaceCategValuesResponse = ReplaceCategValuesResponses[keyof ReplaceCategValuesResponses];
+
+export type IsPromotionOpenData = {
+    body?: never;
+    path: {
+        promotionName: 'GEMINI_CREDITS_6_26' | 'PRO_FEATURE_SET_BY_ADMIN';
+    };
+    query?: never;
+    url: '/promotions/is-open/{promotionName}';
+};
+
+export type IsPromotionOpenErrors = {
+    /**
+     * Bad request - Invalid parameters or malformed JSON
+     */
+    400: {
+        message: string;
+        issues?: string;
+    };
+    /**
+     * Unauthorized
+     */
+    401: ErrorResponse;
+    /**
+     * Forbidden
+     */
+    403: ErrorResponse;
+    /**
+     * Not Found
+     */
+    404: ErrorResponse;
+    /**
+     * Conflict
+     */
+    409: ErrorResponse;
+    /**
+     * Internal server error
+     */
+    500: ErrorResponse;
+    /**
+     * Service Unavailable
+     */
+    503: ErrorResponse;
+};
+
+export type IsPromotionOpenError = IsPromotionOpenErrors[keyof IsPromotionOpenErrors];
+
+export type IsPromotionOpenResponses = {
+    /**
+     * Checks if the promotion is currently open based on its start and end dates
+     */
+    200: {
+        isOpen: boolean;
+    };
+};
+
+export type IsPromotionOpenResponse = IsPromotionOpenResponses[keyof IsPromotionOpenResponses];
+
+export type DeactivateUserPromotionData = {
+    body?: never;
+    path: {
+        dazlUserId: string;
+        promotionName: 'GEMINI_CREDITS_6_26' | 'PRO_FEATURE_SET_BY_ADMIN';
+    };
+    query?: never;
+    url: '/promotions/{dazlUserId}/{promotionName}';
+};
+
+export type DeactivateUserPromotionErrors = {
+    /**
+     * Bad request - Invalid parameters or malformed JSON
+     */
+    400: {
+        message: string;
+        issues?: string;
+    };
+    /**
+     * Unauthorized
+     */
+    401: ErrorResponse;
+    /**
+     * Forbidden
+     */
+    403: ErrorResponse;
+    /**
+     * Not Found
+     */
+    404: ErrorResponse;
+    /**
+     * Conflict
+     */
+    409: ErrorResponse;
+    /**
+     * Internal server error
+     */
+    500: ErrorResponse;
+    /**
+     * Service Unavailable
+     */
+    503: ErrorResponse;
+};
+
+export type DeactivateUserPromotionError = DeactivateUserPromotionErrors[keyof DeactivateUserPromotionErrors];
+
+export type DeactivateUserPromotionResponses = {
+    /**
+     * Deactivates the user promotion
+     */
+    200: {
+        [key: string]: unknown;
+    };
+};
+
+export type DeactivateUserPromotionResponse = DeactivateUserPromotionResponses[keyof DeactivateUserPromotionResponses];
+
+export type AddUserToPromotionData = {
+    body?: never;
+    path: {
+        dazlUserId: string;
+        promotionName: 'GEMINI_CREDITS_6_26' | 'PRO_FEATURE_SET_BY_ADMIN';
+    };
+    query?: never;
+    url: '/promotions/{dazlUserId}/{promotionName}';
+};
+
+export type AddUserToPromotionErrors = {
+    /**
+     * Bad request - Invalid parameters or malformed JSON
+     */
+    400: {
+        message: string;
+        issues?: string;
+    };
+    /**
+     * Unauthorized
+     */
+    401: ErrorResponse;
+    /**
+     * Forbidden
+     */
+    403: ErrorResponse;
+    /**
+     * Not Found
+     */
+    404: ErrorResponse;
+    /**
+     * Conflict
+     */
+    409: ErrorResponse;
+    /**
+     * Internal server error
+     */
+    500: ErrorResponse;
+    /**
+     * Service Unavailable
+     */
+    503: ErrorResponse;
+};
+
+export type AddUserToPromotionError = AddUserToPromotionErrors[keyof AddUserToPromotionErrors];
+
+export type AddUserToPromotionResponses = {
+    /**
+     * Adds the user to the promotion and returns whether the promotion was granted
+     */
+    200: {
+        granted: boolean;
+    };
+};
+
+export type AddUserToPromotionResponse = AddUserToPromotionResponses[keyof AddUserToPromotionResponses];
+
+export type GetUserActivePromotionsData = {
+    body?: never;
+    path: {
+        dazlUserId: string;
+    };
+    query?: never;
+    url: '/promotions/{dazlUserId}/active';
+};
+
+export type GetUserActivePromotionsErrors = {
+    /**
+     * Bad request - Invalid parameters or malformed JSON
+     */
+    400: {
+        message: string;
+        issues?: string;
+    };
+    /**
+     * Unauthorized
+     */
+    401: ErrorResponse;
+    /**
+     * Forbidden
+     */
+    403: ErrorResponse;
+    /**
+     * Not Found
+     */
+    404: ErrorResponse;
+    /**
+     * Conflict
+     */
+    409: ErrorResponse;
+    /**
+     * Internal server error
+     */
+    500: ErrorResponse;
+    /**
+     * Service Unavailable
+     */
+    503: ErrorResponse;
+};
+
+export type GetUserActivePromotionsError = GetUserActivePromotionsErrors[keyof GetUserActivePromotionsErrors];
+
+export type GetUserActivePromotionsResponses = {
+    /**
+     * Returns a list of the user's active promotions
+     */
+    200: {
+        activePromotions: Array<'GEMINI_CREDITS_6_26' | 'PRO_FEATURE_SET_BY_ADMIN'>;
+    };
+};
+
+export type GetUserActivePromotionsResponse = GetUserActivePromotionsResponses[keyof GetUserActivePromotionsResponses];
+
+export type GetWorkflowInteractiveCapabilitiesData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/workflow/capabilities';
+};
+
+export type GetWorkflowInteractiveCapabilitiesErrors = {
+    /**
+     * Bad request - Invalid parameters or malformed JSON
+     */
+    400: {
+        message: string;
+        issues?: string;
+    };
+    /**
+     * Unauthorized
+     */
+    401: ErrorResponse;
+    /**
+     * Forbidden
+     */
+    403: ErrorResponse;
+    /**
+     * Not Found
+     */
+    404: ErrorResponse;
+    /**
+     * Conflict
+     */
+    409: ErrorResponse;
+    /**
+     * Internal server error
+     */
+    500: ErrorResponse;
+    /**
+     * Service Unavailable
+     */
+    503: ErrorResponse;
+};
+
+export type GetWorkflowInteractiveCapabilitiesError = GetWorkflowInteractiveCapabilitiesErrors[keyof GetWorkflowInteractiveCapabilitiesErrors];
+
+export type GetWorkflowInteractiveCapabilitiesResponses = {
+    /**
+     * Whether this backend can run interactive workflow steps
+     */
+    200: WorkflowInteractiveCapabilities;
+};
+
+export type GetWorkflowInteractiveCapabilitiesResponse = GetWorkflowInteractiveCapabilitiesResponses[keyof GetWorkflowInteractiveCapabilitiesResponses];
+
+export type ListWorkflowConversationsData = {
+    body?: never;
+    path: {
+        runId: string;
+    };
+    query?: never;
+    url: '/workflow/runs/{runId}/conversations';
+};
+
+export type ListWorkflowConversationsErrors = {
+    /**
+     * Bad request - Invalid parameters or malformed JSON
+     */
+    400: {
+        message: string;
+        issues?: string;
+    };
+    /**
+     * Unauthorized
+     */
+    401: ErrorResponse;
+    /**
+     * Forbidden
+     */
+    403: ErrorResponse;
+    /**
+     * Not Found
+     */
+    404: ErrorResponse;
+    /**
+     * Conflict
+     */
+    409: ErrorResponse;
+    /**
+     * Internal server error
+     */
+    500: ErrorResponse;
+    /**
+     * Service Unavailable
+     */
+    503: ErrorResponse;
+};
+
+export type ListWorkflowConversationsError = ListWorkflowConversationsErrors[keyof ListWorkflowConversationsErrors];
+
+export type ListWorkflowConversationsResponses = {
+    /**
+     * Safe summaries of a run's conversations: identity, position and permissions, never content
+     */
+    200: WorkflowConversationList;
 };
 
-export type TakeScreenshotResponse = TakeScreenshotResponses[keyof TakeScreenshotResponses];
+export type ListWorkflowConversationsResponse = ListWorkflowConversationsResponses[keyof ListWorkflowConversationsResponses];
 
-export type ScrapePageContentData = {
-    body: {
-        /**
-         * URL of the page to scrape
-         */
-        url: string;
-        /**
-         * Only return the main content of the page excluding headers, navs, footers, etc.
-         */
-        onlyMainContent?: boolean;
-        /**
-         * Emulate scraping from a mobile device
-         */
-        mobile?: boolean;
-        /**
-         * Fetch external CSS stylesheets and inline them as <style> tags for fully self-contained HTML
-         */
-        inlineExternalCss?: boolean;
-        /**
-         * Include structured branding/design system data (colors, fonts, typography, spacing, components)
-         */
-        includeBranding?: boolean;
-        /**
-         * Request timeout in milliseconds (1000-360000). Defaults to server configured value.
-         */
-        timeout?: number;
+export type GetWorkflowConversationForChatData = {
+    body?: never;
+    path: {
+        chatId: string;
     };
-    path?: never;
     query?: never;
-    url: '/capture/scrape';
+    url: '/workflow/chats/{chatId}/conversation';
 };
 
-export type ScrapePageContentErrors = {
+export type GetWorkflowConversationForChatErrors = {
     /**
      * Bad request - Invalid parameters or malformed JSON
      */
@@ -6783,17 +9191,13 @@ export type ScrapePageContentErrors = {
      */
     401: ErrorResponse;
     /**
-     * Forbidden - Permission denied
+     * Forbidden
      */
-    403: {
-        message: string;
-    };
+    403: ErrorResponse;
     /**
-     * Not found
+     * Not Found
      */
-    404: {
-        message: string;
-    };
+    404: ErrorResponse;
     /**
      * Conflict
      */
@@ -6808,79 +9212,30 @@ export type ScrapePageContentErrors = {
     503: ErrorResponse;
 };
 
-export type ScrapePageContentError = ScrapePageContentErrors[keyof ScrapePageContentErrors];
+export type GetWorkflowConversationForChatError = GetWorkflowConversationForChatErrors[keyof GetWorkflowConversationForChatErrors];
 
-export type ScrapePageContentResponses = {
+export type GetWorkflowConversationForChatResponses = {
     /**
-     * Page content scraped successfully
+     * The conversation this chat belongs to, or null for an ordinary chat or one the caller may not read
      */
-    200: {
-        /**
-         * Whether the operation succeeded
-         */
-        success: boolean;
-        /**
-         * Cleaned HTML content of the page (processed for readability)
-         */
-        html: string;
-        /**
-         * Raw HTML content of the page as-is
-         */
-        rawHtml: string;
-        /**
-         * Page metadata
-         */
-        metadata?: {
-            title?: string;
-            description?: string;
-            language?: string;
-            sourceURL?: string;
-            keywords?: string;
-            ogLocaleAlternate?: Array<string>;
-            statusCode: number;
-            error?: string;
-        };
-        /**
-         * Structured branding/design system data (when includeBranding is true)
-         */
-        branding?: {
-            colorScheme?: 'light' | 'dark' | null;
-            logo?: string | null;
-            colors?: {
-                [key: string]: unknown;
-            } | null;
-            fonts?: Array<{
-                [key: string]: unknown;
-            }> | null;
-            typography?: {
-                [key: string]: unknown;
-            } | null;
-            spacing?: {
-                [key: string]: unknown;
-            } | null;
-            components?: {
-                [key: string]: unknown;
-            } | null;
-            images?: {
-                [key: string]: unknown;
-            } | null;
-            [key: string]: unknown;
-        };
-    };
+    200: WorkflowConversationForChat;
 };
 
-export type ScrapePageContentResponse = ScrapePageContentResponses[keyof ScrapePageContentResponses];
+export type GetWorkflowConversationForChatResponse = GetWorkflowConversationForChatResponses[keyof GetWorkflowConversationForChatResponses];
 
-export type GetUserByDazlIdData = {
+export type GetWorkflowConversationData = {
     body?: never;
     path: {
-        dazlId: string;
+        conversationId: string;
     };
-    query?: never;
-    url: '/user/{dazlId}';
+    query?: {
+        limit?: number;
+        before?: string;
+    };
+    url: '/workflow/conversations/{conversationId}';
 };
 
-export type GetUserByDazlIdErrors = {
+export type GetWorkflowConversationErrors = {
     /**
      * Bad request - Invalid parameters or malformed JSON
      */
@@ -6914,33 +9269,27 @@ export type GetUserByDazlIdErrors = {
     503: ErrorResponse;
 };
 
-export type GetUserByDazlIdError = GetUserByDazlIdErrors[keyof GetUserByDazlIdErrors];
+export type GetWorkflowConversationError = GetWorkflowConversationErrors[keyof GetWorkflowConversationErrors];
 
-export type GetUserByDazlIdResponses = {
+export type GetWorkflowConversationResponses = {
     /**
-     * Returns the requested user
+     * One page of a conversation the caller is authorized to read
      */
-    200: {
-        user: UserRaw;
-    };
+    200: WorkflowConversationDetail;
 };
 
-export type GetUserByDazlIdResponse = GetUserByDazlIdResponses[keyof GetUserByDazlIdResponses];
+export type GetWorkflowConversationResponse = GetWorkflowConversationResponses[keyof GetWorkflowConversationResponses];
 
-export type UpdateUserData = {
-    body: {
-        picture?: string | null;
-        name?: string;
-        jobRole?: string | null;
-    };
+export type PostWorkflowConversationMessageData = {
+    body: WorkflowConversationMessageInput;
     path: {
-        dazlId: string;
+        conversationId: string;
     };
     query?: never;
-    url: '/user/{dazlId}';
+    url: '/workflow/conversations/{conversationId}/messages';
 };
 
-export type UpdateUserErrors = {
+export type PostWorkflowConversationMessageErrors = {
     /**
      * Bad request - Invalid parameters or malformed JSON
      */
@@ -6974,29 +9323,27 @@ export type UpdateUserErrors = {
     503: ErrorResponse;
 };
 
-export type UpdateUserError = UpdateUserErrors[keyof UpdateUserErrors];
+export type PostWorkflowConversationMessageError = PostWorkflowConversationMessageErrors[keyof PostWorkflowConversationMessageErrors];
 
-export type UpdateUserResponses = {
+export type PostWorkflowConversationMessageResponses = {
     /**
-     * Updates user information
+     * Records the caller's message and queues the agent turn that answers it
      */
-    200: {
-        user: UserRaw;
-    };
+    200: WorkflowConversationPostedMessage;
 };
 
-export type UpdateUserResponse = UpdateUserResponses[keyof UpdateUserResponses];
+export type PostWorkflowConversationMessageResponse = PostWorkflowConversationMessageResponses[keyof PostWorkflowConversationMessageResponses];
 
-export type GetUsersByDazlIdsData = {
-    body: {
-        dazlIds: Array<string>;
+export type CompleteWorkflowConversationData = {
+    body: WorkflowConversationCompleteInput;
+    path: {
+        conversationId: string;
     };
-    path?: never;
     query?: never;
-    url: '/user/list-by-dazl-ids';
+    url: '/workflow/conversations/{conversationId}/complete';
 };
 
-export type GetUsersByDazlIdsErrors = {
+export type CompleteWorkflowConversationErrors = {
     /**
      * Bad request - Invalid parameters or malformed JSON
      */
@@ -7030,29 +9377,27 @@ export type GetUsersByDazlIdsErrors = {
     503: ErrorResponse;
 };
 
-export type GetUsersByDazlIdsError = GetUsersByDazlIdsErrors[keyof GetUsersByDazlIdsErrors];
+export type CompleteWorkflowConversationError = CompleteWorkflowConversationErrors[keyof CompleteWorkflowConversationErrors];
 
-export type GetUsersByDazlIdsResponses = {
+export type CompleteWorkflowConversationResponses = {
     /**
-     * Returns the requested users
+     * Marks an interactive work step done with the draft the caller was shown
      */
-    200: {
-        users: Array<UserDisplayInfoResponse>;
-    };
+    200: WorkflowConversationOk;
 };
 
-export type GetUsersByDazlIdsResponse = GetUsersByDazlIdsResponses[keyof GetUsersByDazlIdsResponses];
+export type CompleteWorkflowConversationResponse = CompleteWorkflowConversationResponses[keyof CompleteWorkflowConversationResponses];
 
-export type GetUsersByEmailsData = {
-    body: {
-        emails: Array<string>;
+export type DecideWorkflowConversationData = {
+    body: WorkflowConversationDecisionInput;
+    path: {
+        conversationId: string;
     };
-    path?: never;
     query?: never;
-    url: '/user/list-by-emails';
+    url: '/workflow/conversations/{conversationId}/decide';
 };
 
-export type GetUsersByEmailsErrors = {
+export type DecideWorkflowConversationErrors = {
     /**
      * Bad request - Invalid parameters or malformed JSON
      */
@@ -7086,34 +9431,27 @@ export type GetUsersByEmailsErrors = {
     503: ErrorResponse;
 };
 
-export type GetUsersByEmailsError = GetUsersByEmailsErrors[keyof GetUsersByEmailsErrors];
+export type DecideWorkflowConversationError = DecideWorkflowConversationErrors[keyof DecideWorkflowConversationErrors];
 
-export type GetUsersByEmailsResponses = {
+export type DecideWorkflowConversationResponses = {
     /**
-     * Returns the requested users
+     * One reviewer entry's own human decision and the findings it publishes
      */
-    200: {
-        users: Array<UserDisplayInfoResponse>;
-    };
+    200: WorkflowConversationOk;
 };
 
-export type GetUsersByEmailsResponse = GetUsersByEmailsResponses[keyof GetUsersByEmailsResponses];
+export type DecideWorkflowConversationResponse = DecideWorkflowConversationResponses[keyof DecideWorkflowConversationResponses];
 
-export type CreateUserData = {
-    body: {
-        dazlId: string;
-        name: string;
-        email: string;
-        authSub: string;
-        picture?: string | null;
-        jobRole?: string | null;
+export type StopWorkflowConversationTurnData = {
+    body: WorkflowTurnActionInput;
+    path: {
+        turnId: string;
     };
-    path?: never;
     query?: never;
-    url: '/user/create';
+    url: '/workflow/conversation-turns/{turnId}/stop';
 };
 
-export type CreateUserErrors = {
+export type StopWorkflowConversationTurnErrors = {
     /**
      * Bad request - Invalid parameters or malformed JSON
      */
@@ -7147,76 +9485,27 @@ export type CreateUserErrors = {
     503: ErrorResponse;
 };
 
-export type CreateUserError = CreateUserErrors[keyof CreateUserErrors];
+export type StopWorkflowConversationTurnError = StopWorkflowConversationTurnErrors[keyof StopWorkflowConversationTurnErrors];
 
-export type CreateUserResponses = {
+export type StopWorkflowConversationTurnResponses = {
     /**
-     * Creates a new user with billing customer
+     * Cancels a queued turn, or asks the worker holding an accepted one to stop; advisory until confirmed
      */
-    200: {
-        user: UserRaw;
-    };
+    200: WorkflowConversationActionResult;
 };
 
-export type CreateUserResponse = CreateUserResponses[keyof CreateUserResponses];
+export type StopWorkflowConversationTurnResponse = StopWorkflowConversationTurnResponses[keyof StopWorkflowConversationTurnResponses];
 
-export type SearchWebData = {
-    body: {
-        /**
-         * Search query
-         */
-        query: string;
-        /**
-         * Maximum number of results to return
-         */
-        limit?: number;
-        /**
-         * Location parameter for search results
-         */
-        location?: string;
-        /**
-         * Timeout for the search in milliseconds
-         */
-        timeout?: number;
-        /**
-         * Options for scraping search results
-         */
-        scrapeOptions?: {
-            /**
-             * Formats to return
-             */
-            formats?: Array<'summary' | 'json' | {
-                type: 'json';
-                prompt: string;
-                schema?: {
-                    [key: string]: unknown;
-                };
-            } | {
-                type: 'summary' | 'json';
-            }>;
-            /**
-             * Maximum age of cached content
-             */
-            maxAge?: number;
-            /**
-             * Timeout for scraping each document in milliseconds
-             */
-            timeout?: number;
-            /**
-             * Parsers to use for content extraction
-             */
-            parsers?: Array<string | {
-                type: 'pdf';
-                maxPages?: number;
-            }>;
-        };
+export type RetryWorkflowConversationTurnData = {
+    body: WorkflowTurnActionInput;
+    path: {
+        turnId: string;
     };
-    path?: never;
     query?: never;
-    url: '/search/web';
+    url: '/workflow/conversation-turns/{turnId}/retry';
 };
 
-export type SearchWebErrors = {
+export type RetryWorkflowConversationTurnErrors = {
     /**
      * Bad request - Invalid parameters or malformed JSON
      */
@@ -7250,38 +9539,27 @@ export type SearchWebErrors = {
     503: ErrorResponse;
 };
 
-export type SearchWebError = SearchWebErrors[keyof SearchWebErrors];
+export type RetryWorkflowConversationTurnError = RetryWorkflowConversationTurnErrors[keyof RetryWorkflowConversationTurnErrors];
 
-export type SearchWebResponses = {
+export type RetryWorkflowConversationTurnResponses = {
     /**
-     * Search results organized by source type
+     * Runs a settled turn again under a new attempt
      */
-    200: {
-        web?: Array<{
-            url: string;
-            title?: string;
-            description?: string;
-            json?: unknown;
-            summary?: string;
-            metadata?: {
-                creditsUsed?: number;
-            };
-        }>;
-    };
+    200: WorkflowConversationActionResult;
 };
 
-export type SearchWebResponse = SearchWebResponses[keyof SearchWebResponses];
+export type RetryWorkflowConversationTurnResponse = RetryWorkflowConversationTurnResponses[keyof RetryWorkflowConversationTurnResponses];
 
-export type AdminDeleteProjectData = {
-    body: DeleteProjectInput;
+export type ListWorkflowQueuedTurnsData = {
+    body?: never;
     path: {
         projectId: string;
     };
     query?: never;
-    url: '/admin/project/{projectId}';
+    url: '/workflow/projects/{projectId}/conversation-turns';
 };
 
-export type AdminDeleteProjectErrors = {
+export type ListWorkflowQueuedTurnsErrors = {
     /**
      * Bad request - Invalid parameters or malformed JSON
      */
@@ -7315,28 +9593,27 @@ export type AdminDeleteProjectErrors = {
     503: ErrorResponse;
 };
 
-export type AdminDeleteProjectError = AdminDeleteProjectErrors[keyof AdminDeleteProjectErrors];
+export type ListWorkflowQueuedTurnsError = ListWorkflowQueuedTurnsErrors[keyof ListWorkflowQueuedTurnsErrors];
 
-export type AdminDeleteProjectResponses = {
+export type ListWorkflowQueuedTurnsResponses = {
     /**
-     * Project deleted successfully
+     * Queue metadata for a project's claimable turns; carries no transcript
      */
-    200: {
-        success: boolean;
-        projectId: string;
-    };
+    200: WorkflowTurnOfferList;
 };
 
-export type AdminDeleteProjectResponse = AdminDeleteProjectResponses[keyof AdminDeleteProjectResponses];
+export type ListWorkflowQueuedTurnsResponse = ListWorkflowQueuedTurnsResponses[keyof ListWorkflowQueuedTurnsResponses];
 
-export type AdminCloneProjectCreateData = {
-    body: CloneProjectCreateInput;
-    path?: never;
+export type AnnounceWorkflowWorkerSessionData = {
+    body: WorkflowWorkerSession;
+    path: {
+        projectId: string;
+    };
     query?: never;
-    url: '/admin/project/clone';
+    url: '/workflow/projects/{projectId}/worker-sessions';
 };
 
-export type AdminCloneProjectCreateErrors = {
+export type AnnounceWorkflowWorkerSessionErrors = {
     /**
      * Bad request - Invalid parameters or malformed JSON
      */
@@ -7370,27 +9647,27 @@ export type AdminCloneProjectCreateErrors = {
     503: ErrorResponse;
 };
 
-export type AdminCloneProjectCreateError = AdminCloneProjectCreateErrors[keyof AdminCloneProjectCreateErrors];
+export type AnnounceWorkflowWorkerSessionError = AnnounceWorkflowWorkerSessionErrors[keyof AnnounceWorkflowWorkerSessionErrors];
 
-export type AdminCloneProjectCreateResponses = {
+export type AnnounceWorkflowWorkerSessionResponses = {
     /**
-     * Returns the ID of the newly created clone project record
+     * Declares this worker as the project's current one and settles the turns its predecessor left behind
      */
-    200: {
-        newProjectId: string;
-    };
+    200: WorkflowWorkerSessionResult;
 };
 
-export type AdminCloneProjectCreateResponse = AdminCloneProjectCreateResponses[keyof AdminCloneProjectCreateResponses];
+export type AnnounceWorkflowWorkerSessionResponse = AnnounceWorkflowWorkerSessionResponses[keyof AnnounceWorkflowWorkerSessionResponses];
 
-export type AdminCloneProjectLogData = {
-    body: CloneProjectLogInput;
-    path?: never;
+export type AcceptWorkflowConversationTurnData = {
+    body: WorkflowTurnAcceptInput;
+    path: {
+        turnId: string;
+    };
     query?: never;
-    url: '/admin/project/clone/log';
+    url: '/workflow/conversation-turns/{turnId}/accept';
 };
 
-export type AdminCloneProjectLogErrors = {
+export type AcceptWorkflowConversationTurnErrors = {
     /**
      * Bad request - Invalid parameters or malformed JSON
      */
@@ -7424,27 +9701,27 @@ export type AdminCloneProjectLogErrors = {
     503: ErrorResponse;
 };
 
-export type AdminCloneProjectLogError = AdminCloneProjectLogErrors[keyof AdminCloneProjectLogErrors];
+export type AcceptWorkflowConversationTurnError = AcceptWorkflowConversationTurnErrors[keyof AcceptWorkflowConversationTurnErrors];
 
-export type AdminCloneProjectLogResponses = {
+export type AcceptWorkflowConversationTurnResponses = {
     /**
-     * Admin action logged successfully
+     * Claims this conversation's next queued turn and returns its lease
      */
-    200: {
-        success: boolean;
-    };
+    200: WorkflowTurnAcceptance;
 };
 
-export type AdminCloneProjectLogResponse = AdminCloneProjectLogResponses[keyof AdminCloneProjectLogResponses];
+export type AcceptWorkflowConversationTurnResponse = AcceptWorkflowConversationTurnResponses[keyof AcceptWorkflowConversationTurnResponses];
 
-export type AdminCleanupProjectData = {
-    body: CleanupProjectInput;
-    path?: never;
+export type ReportWorkflowConversationTurnResultData = {
+    body: WorkflowTurnResultInput;
+    path: {
+        turnId: string;
+    };
     query?: never;
-    url: '/admin/project/cleanup';
+    url: '/workflow/conversation-turns/{turnId}/result';
 };
 
-export type AdminCleanupProjectErrors = {
+export type ReportWorkflowConversationTurnResultErrors = {
     /**
      * Bad request - Invalid parameters or malformed JSON
      */
@@ -7478,27 +9755,27 @@ export type AdminCleanupProjectErrors = {
     503: ErrorResponse;
 };
 
-export type AdminCleanupProjectError = AdminCleanupProjectErrors[keyof AdminCleanupProjectErrors];
+export type ReportWorkflowConversationTurnResultError = ReportWorkflowConversationTurnResultErrors[keyof ReportWorkflowConversationTurnResultErrors];
 
-export type AdminCleanupProjectResponses = {
+export type ReportWorkflowConversationTurnResultResponses = {
     /**
-     * Project cleaned up successfully
+     * Records the outcome of the turn this worker holds
      */
-    200: {
-        success: boolean;
-    };
+    200: WorkflowConversationActionResult;
 };
 
-export type AdminCleanupProjectResponse = AdminCleanupProjectResponses[keyof AdminCleanupProjectResponses];
+export type ReportWorkflowConversationTurnResultResponse = ReportWorkflowConversationTurnResultResponses[keyof ReportWorkflowConversationTurnResultResponses];
 
-export type AdminUpdateCreditsData = {
-    body: UpdateCreditsInput;
-    path?: never;
+export type HeartbeatWorkflowConversationTurnData = {
+    body: WorkflowTurnClaimInput;
+    path: {
+        turnId: string;
+    };
     query?: never;
-    url: '/admin/credits';
+    url: '/workflow/conversation-turns/{turnId}/heartbeat';
 };
 
-export type AdminUpdateCreditsErrors = {
+export type HeartbeatWorkflowConversationTurnErrors = {
     /**
      * Bad request - Invalid parameters or malformed JSON
      */
@@ -7532,42 +9809,27 @@ export type AdminUpdateCreditsErrors = {
     503: ErrorResponse;
 };
 
-export type AdminUpdateCreditsError = AdminUpdateCreditsErrors[keyof AdminUpdateCreditsErrors];
+export type HeartbeatWorkflowConversationTurnError = HeartbeatWorkflowConversationTurnErrors[keyof HeartbeatWorkflowConversationTurnErrors];
 
-export type AdminUpdateCreditsResponses = {
+export type HeartbeatWorkflowConversationTurnResponses = {
     /**
-     * Credits updated successfully
+     * Renews this turn's lease and reports whether a person asked it to stop
      */
-    200: {
-        success: boolean;
-        newBalance: number;
-    };
+    200: WorkflowTurnHeartbeat;
 };
 
-export type AdminUpdateCreditsResponse = AdminUpdateCreditsResponses[keyof AdminUpdateCreditsResponses];
+export type HeartbeatWorkflowConversationTurnResponse = HeartbeatWorkflowConversationTurnResponses[keyof HeartbeatWorkflowConversationTurnResponses];
 
-export type AdminLogActionData = {
-    body: {
-        action: string;
-        /**
-         * The target user's Dazl ID
-         */
-        targetDazlUserId?: string;
-        targetProjectId?: string;
-        message: string;
-        reason?: string;
-    } & {
-        /**
-         * The admin user's Dazl ID
-         */
-        adminDazlUserId: string;
+export type AcknowledgeWorkflowConversationTurnStoppedData = {
+    body: WorkflowTurnClaimInput;
+    path: {
+        turnId: string;
     };
-    path?: never;
     query?: never;
-    url: '/admin/action/log';
+    url: '/workflow/conversation-turns/{turnId}/stopped';
 };
 
-export type AdminLogActionErrors = {
+export type AcknowledgeWorkflowConversationTurnStoppedErrors = {
     /**
      * Bad request - Invalid parameters or malformed JSON
      */
@@ -7601,30 +9863,27 @@ export type AdminLogActionErrors = {
     503: ErrorResponse;
 };
 
-export type AdminLogActionError = AdminLogActionErrors[keyof AdminLogActionErrors];
+export type AcknowledgeWorkflowConversationTurnStoppedError = AcknowledgeWorkflowConversationTurnStoppedErrors[keyof AcknowledgeWorkflowConversationTurnStoppedErrors];
 
-export type AdminLogActionResponses = {
+export type AcknowledgeWorkflowConversationTurnStoppedResponses = {
     /**
-     * Admin action logged successfully
+     * The worker's confirmation that it stopped, which is what makes a retry safe
      */
-    200: {
-        success: boolean;
-    };
+    200: WorkflowConversationActionResult;
 };
 
-export type AdminLogActionResponse = AdminLogActionResponses[keyof AdminLogActionResponses];
+export type AcknowledgeWorkflowConversationTurnStoppedResponse = AcknowledgeWorkflowConversationTurnStoppedResponses[keyof AcknowledgeWorkflowConversationTurnStoppedResponses];
 
-export type OpenFeatureToggleData = {
-    body: {
-        name: string;
-        scope: 'RemoteAndEditor' | 'SiteAndEditor';
+export type ListWorkflowRunsData = {
+    body?: never;
+    path: {
+        projectId: string;
     };
-    path?: never;
     query?: never;
-    url: '/env-config/open';
+    url: '/workflow/projects/{projectId}/runs';
 };
 
-export type OpenFeatureToggleErrors = {
+export type ListWorkflowRunsErrors = {
     /**
      * Bad request - Invalid parameters or malformed JSON
      */
@@ -7658,29 +9917,29 @@ export type OpenFeatureToggleErrors = {
     503: ErrorResponse;
 };
 
-export type OpenFeatureToggleError = OpenFeatureToggleErrors[keyof OpenFeatureToggleErrors];
+export type ListWorkflowRunsError = ListWorkflowRunsErrors[keyof ListWorkflowRunsErrors];
 
-export type OpenFeatureToggleResponses = {
+export type ListWorkflowRunsResponses = {
     /**
-     * Opens a feature toggle
+     * Lists a project's workflow runs, most recent first
      */
     200: {
-        success: boolean;
+        runs: Array<WorkflowRun>;
     };
 };
 
-export type OpenFeatureToggleResponse = OpenFeatureToggleResponses[keyof OpenFeatureToggleResponses];
+export type ListWorkflowRunsResponse = ListWorkflowRunsResponses[keyof ListWorkflowRunsResponses];
 
-export type CloseFeatureToggleData = {
-    body: {
-        name: string;
+export type StartWorkflowRunData = {
+    body: StartWorkflowRunInput;
+    path: {
+        projectId: string;
     };
-    path?: never;
     query?: never;
-    url: '/env-config/close';
+    url: '/workflow/projects/{projectId}/runs';
 };
 
-export type CloseFeatureToggleErrors = {
+export type StartWorkflowRunErrors = {
     /**
      * Bad request - Invalid parameters or malformed JSON
      */
@@ -7714,27 +9973,29 @@ export type CloseFeatureToggleErrors = {
     503: ErrorResponse;
 };
 
-export type CloseFeatureToggleError = CloseFeatureToggleErrors[keyof CloseFeatureToggleErrors];
+export type StartWorkflowRunError = StartWorkflowRunErrors[keyof StartWorkflowRunErrors];
 
-export type CloseFeatureToggleResponses = {
+export type StartWorkflowRunResponses = {
     /**
-     * Closes a feature toggle
+     * Starts a run from a working-tree workflow document
      */
     200: {
-        success: boolean;
+        run: WorkflowRun;
     };
 };
 
-export type CloseFeatureToggleResponse = CloseFeatureToggleResponses[keyof CloseFeatureToggleResponses];
+export type StartWorkflowRunResponse = StartWorkflowRunResponses[keyof StartWorkflowRunResponses];
 
-export type PurgeUserAccountData = {
-    body: PurgeUserAccountInput;
-    path?: never;
+export type ListWorkflowOffersData = {
+    body?: never;
+    path: {
+        projectId: string;
+    };
     query?: never;
-    url: '/purge/user-account';
+    url: '/workflow/projects/{projectId}/offers';
 };
 
-export type PurgeUserAccountErrors = {
+export type ListWorkflowOffersErrors = {
     /**
      * Bad request - Invalid parameters or malformed JSON
      */
@@ -7768,40 +10029,29 @@ export type PurgeUserAccountErrors = {
     503: ErrorResponse;
 };
 
-export type PurgeUserAccountError = PurgeUserAccountErrors[keyof PurgeUserAccountErrors];
+export type ListWorkflowOffersError = ListWorkflowOffersErrors[keyof ListWorkflowOffersErrors];
 
-export type PurgeUserAccountResponses = {
+export type ListWorkflowOffersResponses = {
     /**
-     * User account purged from all systems
+     * Lists the nodes offered to a container polling this project
      */
     200: {
-        success: boolean;
-        results: {
-            [key: string]: {
-                discovered: Array<string>;
-                deleted: Array<string>;
-            };
-        };
+        offers: Array<WorkflowDispatchPayload>;
     };
 };
 
-export type PurgeUserAccountResponse = PurgeUserAccountResponses[keyof PurgeUserAccountResponses];
+export type ListWorkflowOffersResponse = ListWorkflowOffersResponses[keyof ListWorkflowOffersResponses];
 
-export type GetValuesData = {
+export type GetWorkflowRunData = {
     body?: never;
     path: {
-        dazlUserId: string;
-    };
-    query?: {
-        /**
-         * Filter results to this category
-         */
-        categ?: string;
+        runId: string;
     };
-    url: '/user-key-value/{dazlUserId}/values';
+    query?: never;
+    url: '/workflow/runs/{runId}';
 };
 
-export type GetValuesErrors = {
+export type GetWorkflowRunErrors = {
     /**
      * Bad request - Invalid parameters or malformed JSON
      */
@@ -7835,44 +10085,34 @@ export type GetValuesErrors = {
     503: ErrorResponse;
 };
 
-export type GetValuesError = GetValuesErrors[keyof GetValuesErrors];
+export type GetWorkflowRunError = GetWorkflowRunErrors[keyof GetWorkflowRunErrors];
 
-export type GetValuesResponses = {
+export type GetWorkflowRunResponses = {
     /**
-     * Returns key values for the user
+     * Returns a run's full detail: the run row, its nodes, events, review decisions and projected graph
      */
     200: {
-        values: Array<{
-            id: string;
-            dazlUserId: string;
-            category: string;
-            name: string;
-            strVal: string | null;
-            encryptedValId: string | null;
-            createdAt: string;
-            updatedAt: string;
-            encryptedValue: string | null;
-        }>;
+        run: WorkflowRun;
+        nodes: Array<WorkflowNodeRun>;
+        events: Array<WorkflowRunEvent>;
+        decisions: Array<WorkflowReviewDecision>;
+        graph: WorkflowRunGraph;
     };
 };
 
-export type GetValuesResponse = GetValuesResponses[keyof GetValuesResponses];
+export type GetWorkflowRunResponse = GetWorkflowRunResponses[keyof GetWorkflowRunResponses];
 
-export type SetValueData = {
-    body: {
-        value: string;
-        isSecret?: boolean;
-    };
+export type AcceptWorkflowNodeData = {
+    body: AcceptWorkflowNodeInput;
     path: {
-        dazlUserId: string;
-        categ: string;
-        name: string;
+        runId: string;
+        nodeKey: string;
     };
     query?: never;
-    url: '/user-key-value/{dazlUserId}/values/{categ}/{name}';
+    url: '/workflow/runs/{runId}/nodes/{nodeKey}/accept';
 };
 
-export type SetValueErrors = {
+export type AcceptWorkflowNodeErrors = {
     /**
      * Bad request - Invalid parameters or malformed JSON
      */
@@ -7906,30 +10146,27 @@ export type SetValueErrors = {
     503: ErrorResponse;
 };
 
-export type SetValueError = SetValueErrors[keyof SetValueErrors];
+export type AcceptWorkflowNodeError = AcceptWorkflowNodeErrors[keyof AcceptWorkflowNodeErrors];
 
-export type SetValueResponses = {
+export type AcceptWorkflowNodeResponses = {
     /**
-     * Sets a single key value and returns its id
+     * Accepts an offered node and returns its authoritative execution payload
      */
-    200: {
-        id: string;
-    };
+    200: AcceptedWorkflowNode;
 };
 
-export type SetValueResponse = SetValueResponses[keyof SetValueResponses];
+export type AcceptWorkflowNodeResponse = AcceptWorkflowNodeResponses[keyof AcceptWorkflowNodeResponses];
 
-export type DeleteCategValuesData = {
-    body?: never;
+export type SetWorkflowHarnessData = {
+    body: SetWorkflowHarnessInput;
     path: {
-        dazlUserId: string;
-        categ: string;
+        runId: string;
     };
     query?: never;
-    url: '/user-key-value/{dazlUserId}/values/{categ}';
+    url: '/workflow/runs/{runId}/harness';
 };
 
-export type DeleteCategValuesErrors = {
+export type SetWorkflowHarnessErrors = {
     /**
      * Bad request - Invalid parameters or malformed JSON
      */
@@ -7963,36 +10200,30 @@ export type DeleteCategValuesErrors = {
     503: ErrorResponse;
 };
 
-export type DeleteCategValuesError = DeleteCategValuesErrors[keyof DeleteCategValuesErrors];
+export type SetWorkflowHarnessError = SetWorkflowHarnessErrors[keyof SetWorkflowHarnessErrors];
 
-export type DeleteCategValuesResponses = {
+export type SetWorkflowHarnessResponses = {
     /**
-     * Deletes all values for the category
+     * Changes a live run's selected harness
      */
     200: {
-        categ: string;
+        applied: boolean;
     };
 };
 
-export type DeleteCategValuesResponse = DeleteCategValuesResponses[keyof DeleteCategValuesResponses];
+export type SetWorkflowHarnessResponse = SetWorkflowHarnessResponses[keyof SetWorkflowHarnessResponses];
 
-export type ReplaceCategValuesData = {
-    body: {
-        values: Array<{
-            name: string;
-            value: string;
-            isSecret?: boolean;
-        }>;
-    };
+export type ReportWorkflowNodeResultData = {
+    body: WorkflowNodeResultInput;
     path: {
-        dazlUserId: string;
-        categ: string;
+        runId: string;
+        nodeKey: string;
     };
     query?: never;
-    url: '/user-key-value/{dazlUserId}/values/{categ}';
+    url: '/workflow/runs/{runId}/nodes/{nodeKey}/result';
 };
 
-export type ReplaceCategValuesErrors = {
+export type ReportWorkflowNodeResultErrors = {
     /**
      * Bad request - Invalid parameters or malformed JSON
      */
@@ -8026,33 +10257,30 @@ export type ReplaceCategValuesErrors = {
     503: ErrorResponse;
 };
 
-export type ReplaceCategValuesError = ReplaceCategValuesErrors[keyof ReplaceCategValuesErrors];
+export type ReportWorkflowNodeResultError = ReportWorkflowNodeResultErrors[keyof ReportWorkflowNodeResultErrors];
 
-export type ReplaceCategValuesResponses = {
+export type ReportWorkflowNodeResultResponses = {
     /**
-     * Replaces all values for the category and returns the upserted rows
+     * Records a work node's terminal result
      */
     200: {
-        values: Array<{
-            id: string;
-            name: string;
-        }>;
-        replaced: boolean;
+        applied: boolean;
     };
 };
 
-export type ReplaceCategValuesResponse = ReplaceCategValuesResponses[keyof ReplaceCategValuesResponses];
+export type ReportWorkflowNodeResultResponse = ReportWorkflowNodeResultResponses[keyof ReportWorkflowNodeResultResponses];
 
-export type IsPromotionOpenData = {
-    body?: never;
+export type ReportWorkflowReviewData = {
+    body: WorkflowReviewReportInput;
     path: {
-        promotionName: 'GEMINI_CREDITS_6_26' | 'PRO_FEATURE_SET_BY_ADMIN';
+        runId: string;
+        nodeKey: string;
     };
     query?: never;
-    url: '/promotions/is-open/{promotionName}';
+    url: '/workflow/runs/{runId}/nodes/{nodeKey}/review';
 };
 
-export type IsPromotionOpenErrors = {
+export type ReportWorkflowReviewErrors = {
     /**
      * Bad request - Invalid parameters or malformed JSON
      */
@@ -8086,30 +10314,30 @@ export type IsPromotionOpenErrors = {
     503: ErrorResponse;
 };
 
-export type IsPromotionOpenError = IsPromotionOpenErrors[keyof IsPromotionOpenErrors];
+export type ReportWorkflowReviewError = ReportWorkflowReviewErrors[keyof ReportWorkflowReviewErrors];
 
-export type IsPromotionOpenResponses = {
+export type ReportWorkflowReviewResponses = {
     /**
-     * Checks if the promotion is currently open based on its start and end dates
+     * Records a reviewer's approval or objection
      */
     200: {
-        isOpen: boolean;
+        applied: boolean;
     };
 };
 
-export type IsPromotionOpenResponse = IsPromotionOpenResponses[keyof IsPromotionOpenResponses];
+export type ReportWorkflowReviewResponse = ReportWorkflowReviewResponses[keyof ReportWorkflowReviewResponses];
 
-export type DeactivateUserPromotionData = {
-    body?: never;
+export type DecideWorkflowReviewData = {
+    body: WorkflowHumanDecisionInput;
     path: {
-        dazlUserId: string;
-        promotionName: 'GEMINI_CREDITS_6_26' | 'PRO_FEATURE_SET_BY_ADMIN';
+        runId: string;
+        nodeKey: string;
     };
     query?: never;
-    url: '/promotions/{dazlUserId}/{promotionName}';
+    url: '/workflow/runs/{runId}/nodes/{nodeKey}/decide';
 };
 
-export type DeactivateUserPromotionErrors = {
+export type DecideWorkflowReviewErrors = {
     /**
      * Bad request - Invalid parameters or malformed JSON
      */
@@ -8143,30 +10371,30 @@ export type DeactivateUserPromotionErrors = {
     503: ErrorResponse;
 };
 
-export type DeactivateUserPromotionError = DeactivateUserPromotionErrors[keyof DeactivateUserPromotionErrors];
+export type DecideWorkflowReviewError = DecideWorkflowReviewErrors[keyof DecideWorkflowReviewErrors];
 
-export type DeactivateUserPromotionResponses = {
+export type DecideWorkflowReviewResponses = {
     /**
-     * Deactivates the user promotion
+     * A person's approve/reject decision on an objection parked for them
      */
     200: {
-        [key: string]: unknown;
+        ok: true;
     };
 };
 
-export type DeactivateUserPromotionResponse = DeactivateUserPromotionResponses[keyof DeactivateUserPromotionResponses];
+export type DecideWorkflowReviewResponse = DecideWorkflowReviewResponses[keyof DecideWorkflowReviewResponses];
 
-export type AddUserToPromotionData = {
+export type RetryWorkflowNodeData = {
     body?: never;
     path: {
-        dazlUserId: string;
-        promotionName: 'GEMINI_CREDITS_6_26' | 'PRO_FEATURE_SET_BY_ADMIN';
+        runId: string;
+        nodeKey: string;
     };
     query?: never;
-    url: '/promotions/{dazlUserId}/{promotionName}';
+    url: '/workflow/runs/{runId}/nodes/{nodeKey}/retry';
 };
 
-export type AddUserToPromotionErrors = {
+export type RetryWorkflowNodeErrors = {
     /**
      * Bad request - Invalid parameters or malformed JSON
      */
@@ -8200,29 +10428,29 @@ export type AddUserToPromotionErrors = {
     503: ErrorResponse;
 };
 
-export type AddUserToPromotionError = AddUserToPromotionErrors[keyof AddUserToPromotionErrors];
+export type RetryWorkflowNodeError = RetryWorkflowNodeErrors[keyof RetryWorkflowNodeErrors];
 
-export type AddUserToPromotionResponses = {
+export type RetryWorkflowNodeResponses = {
     /**
-     * Adds the user to the promotion and returns whether the promotion was granted
+     * Puts an errored node back in play
      */
     200: {
-        granted: boolean;
+        applied: boolean;
     };
 };
 
-export type AddUserToPromotionResponse = AddUserToPromotionResponses[keyof AddUserToPromotionResponses];
+export type RetryWorkflowNodeResponse = RetryWorkflowNodeResponses[keyof RetryWorkflowNodeResponses];
 
-export type GetUserActivePromotionsData = {
+export type CancelWorkflowRunData = {
     body?: never;
     path: {
-        dazlUserId: string;
+        runId: string;
     };
     query?: never;
-    url: '/promotions/{dazlUserId}/active';
+    url: '/workflow/runs/{runId}/cancel';
 };
 
-export type GetUserActivePromotionsErrors = {
+export type CancelWorkflowRunErrors = {
     /**
      * Bad request - Invalid parameters or malformed JSON
      */
@@ -8256,18 +10484,18 @@ export type GetUserActivePromotionsErrors = {
     503: ErrorResponse;
 };
 
-export type GetUserActivePromotionsError = GetUserActivePromotionsErrors[keyof GetUserActivePromotionsErrors];
+export type CancelWorkflowRunError = CancelWorkflowRunErrors[keyof CancelWorkflowRunErrors];
 
-export type GetUserActivePromotionsResponses = {
+export type CancelWorkflowRunResponses = {
     /**
-     * Returns a list of the user's active promotions
+     * Cancels a live run
      */
     200: {
-        activePromotions: Array<'GEMINI_CREDITS_6_26' | 'PRO_FEATURE_SET_BY_ADMIN'>;
+        applied: boolean;
     };
 };
 
-export type GetUserActivePromotionsResponse = GetUserActivePromotionsResponses[keyof GetUserActivePromotionsResponses];
+export type CancelWorkflowRunResponse = CancelWorkflowRunResponses[keyof CancelWorkflowRunResponses];
 
 export type GetFeatureTogglesData = {
     body?: never;