@dazl/api-client 1.0.43 → 1.0.45

package/src/internal/types.gen.ts

@@ -195,6 +195,9 @@ export type PendingGeneration = {
     messageId: string;
     model?: string;
     enabledIntegrationNames?: Array<string>;
+    harness?: string;
+    harnessModel?: string;
+    agentEffort?: string;
 };
 
 export type UserDisplayInfoResponse = {
@@ -526,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';
@@ -8266,6 +8794,1440 @@ export type GetUserActivePromotionsResponses = {
 
 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 ListWorkflowConversationsResponse = ListWorkflowConversationsResponses[keyof ListWorkflowConversationsResponses];
+
+export type GetWorkflowConversationForChatData = {
+    body?: never;
+    path: {
+        chatId: string;
+    };
+    query?: never;
+    url: '/workflow/chats/{chatId}/conversation';
+};
+
+export type GetWorkflowConversationForChatErrors = {
+    /**
+     * 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 GetWorkflowConversationForChatError = GetWorkflowConversationForChatErrors[keyof GetWorkflowConversationForChatErrors];
+
+export type GetWorkflowConversationForChatResponses = {
+    /**
+     * The conversation this chat belongs to, or null for an ordinary chat or one the caller may not read
+     */
+    200: WorkflowConversationForChat;
+};
+
+export type GetWorkflowConversationForChatResponse = GetWorkflowConversationForChatResponses[keyof GetWorkflowConversationForChatResponses];
+
+export type GetWorkflowConversationData = {
+    body?: never;
+    path: {
+        conversationId: string;
+    };
+    query?: {
+        limit?: number;
+        before?: string;
+    };
+    url: '/workflow/conversations/{conversationId}';
+};
+
+export type GetWorkflowConversationErrors = {
+    /**
+     * 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 GetWorkflowConversationError = GetWorkflowConversationErrors[keyof GetWorkflowConversationErrors];
+
+export type GetWorkflowConversationResponses = {
+    /**
+     * One page of a conversation the caller is authorized to read
+     */
+    200: WorkflowConversationDetail;
+};
+
+export type GetWorkflowConversationResponse = GetWorkflowConversationResponses[keyof GetWorkflowConversationResponses];
+
+export type PostWorkflowConversationMessageData = {
+    body: WorkflowConversationMessageInput;
+    path: {
+        conversationId: string;
+    };
+    query?: never;
+    url: '/workflow/conversations/{conversationId}/messages';
+};
+
+export type PostWorkflowConversationMessageErrors = {
+    /**
+     * 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 PostWorkflowConversationMessageError = PostWorkflowConversationMessageErrors[keyof PostWorkflowConversationMessageErrors];
+
+export type PostWorkflowConversationMessageResponses = {
+    /**
+     * Records the caller's message and queues the agent turn that answers it
+     */
+    200: WorkflowConversationPostedMessage;
+};
+
+export type PostWorkflowConversationMessageResponse = PostWorkflowConversationMessageResponses[keyof PostWorkflowConversationMessageResponses];
+
+export type CompleteWorkflowConversationData = {
+    body: WorkflowConversationCompleteInput;
+    path: {
+        conversationId: string;
+    };
+    query?: never;
+    url: '/workflow/conversations/{conversationId}/complete';
+};
+
+export type CompleteWorkflowConversationErrors = {
+    /**
+     * 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 CompleteWorkflowConversationError = CompleteWorkflowConversationErrors[keyof CompleteWorkflowConversationErrors];
+
+export type CompleteWorkflowConversationResponses = {
+    /**
+     * Marks an interactive work step done with the draft the caller was shown
+     */
+    200: WorkflowConversationOk;
+};
+
+export type CompleteWorkflowConversationResponse = CompleteWorkflowConversationResponses[keyof CompleteWorkflowConversationResponses];
+
+export type DecideWorkflowConversationData = {
+    body: WorkflowConversationDecisionInput;
+    path: {
+        conversationId: string;
+    };
+    query?: never;
+    url: '/workflow/conversations/{conversationId}/decide';
+};
+
+export type DecideWorkflowConversationErrors = {
+    /**
+     * 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 DecideWorkflowConversationError = DecideWorkflowConversationErrors[keyof DecideWorkflowConversationErrors];
+
+export type DecideWorkflowConversationResponses = {
+    /**
+     * One reviewer entry's own human decision and the findings it publishes
+     */
+    200: WorkflowConversationOk;
+};
+
+export type DecideWorkflowConversationResponse = DecideWorkflowConversationResponses[keyof DecideWorkflowConversationResponses];
+
+export type StopWorkflowConversationTurnData = {
+    body: WorkflowTurnActionInput;
+    path: {
+        turnId: string;
+    };
+    query?: never;
+    url: '/workflow/conversation-turns/{turnId}/stop';
+};
+
+export type StopWorkflowConversationTurnErrors = {
+    /**
+     * 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 StopWorkflowConversationTurnError = StopWorkflowConversationTurnErrors[keyof StopWorkflowConversationTurnErrors];
+
+export type StopWorkflowConversationTurnResponses = {
+    /**
+     * Cancels a queued turn, or asks the worker holding an accepted one to stop; advisory until confirmed
+     */
+    200: WorkflowConversationActionResult;
+};
+
+export type StopWorkflowConversationTurnResponse = StopWorkflowConversationTurnResponses[keyof StopWorkflowConversationTurnResponses];
+
+export type RetryWorkflowConversationTurnData = {
+    body: WorkflowTurnActionInput;
+    path: {
+        turnId: string;
+    };
+    query?: never;
+    url: '/workflow/conversation-turns/{turnId}/retry';
+};
+
+export type RetryWorkflowConversationTurnErrors = {
+    /**
+     * 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 RetryWorkflowConversationTurnError = RetryWorkflowConversationTurnErrors[keyof RetryWorkflowConversationTurnErrors];
+
+export type RetryWorkflowConversationTurnResponses = {
+    /**
+     * Runs a settled turn again under a new attempt
+     */
+    200: WorkflowConversationActionResult;
+};
+
+export type RetryWorkflowConversationTurnResponse = RetryWorkflowConversationTurnResponses[keyof RetryWorkflowConversationTurnResponses];
+
+export type ListWorkflowQueuedTurnsData = {
+    body?: never;
+    path: {
+        projectId: string;
+    };
+    query?: never;
+    url: '/workflow/projects/{projectId}/conversation-turns';
+};
+
+export type ListWorkflowQueuedTurnsErrors = {
+    /**
+     * 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 ListWorkflowQueuedTurnsError = ListWorkflowQueuedTurnsErrors[keyof ListWorkflowQueuedTurnsErrors];
+
+export type ListWorkflowQueuedTurnsResponses = {
+    /**
+     * Queue metadata for a project's claimable turns; carries no transcript
+     */
+    200: WorkflowTurnOfferList;
+};
+
+export type ListWorkflowQueuedTurnsResponse = ListWorkflowQueuedTurnsResponses[keyof ListWorkflowQueuedTurnsResponses];
+
+export type AnnounceWorkflowWorkerSessionData = {
+    body: WorkflowWorkerSession;
+    path: {
+        projectId: string;
+    };
+    query?: never;
+    url: '/workflow/projects/{projectId}/worker-sessions';
+};
+
+export type AnnounceWorkflowWorkerSessionErrors = {
+    /**
+     * 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 AnnounceWorkflowWorkerSessionError = AnnounceWorkflowWorkerSessionErrors[keyof AnnounceWorkflowWorkerSessionErrors];
+
+export type AnnounceWorkflowWorkerSessionResponses = {
+    /**
+     * Declares this worker as the project's current one and settles the turns its predecessor left behind
+     */
+    200: WorkflowWorkerSessionResult;
+};
+
+export type AnnounceWorkflowWorkerSessionResponse = AnnounceWorkflowWorkerSessionResponses[keyof AnnounceWorkflowWorkerSessionResponses];
+
+export type AcceptWorkflowConversationTurnData = {
+    body: WorkflowTurnAcceptInput;
+    path: {
+        turnId: string;
+    };
+    query?: never;
+    url: '/workflow/conversation-turns/{turnId}/accept';
+};
+
+export type AcceptWorkflowConversationTurnErrors = {
+    /**
+     * 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 AcceptWorkflowConversationTurnError = AcceptWorkflowConversationTurnErrors[keyof AcceptWorkflowConversationTurnErrors];
+
+export type AcceptWorkflowConversationTurnResponses = {
+    /**
+     * Claims this conversation's next queued turn and returns its lease
+     */
+    200: WorkflowTurnAcceptance;
+};
+
+export type AcceptWorkflowConversationTurnResponse = AcceptWorkflowConversationTurnResponses[keyof AcceptWorkflowConversationTurnResponses];
+
+export type ReportWorkflowConversationTurnResultData = {
+    body: WorkflowTurnResultInput;
+    path: {
+        turnId: string;
+    };
+    query?: never;
+    url: '/workflow/conversation-turns/{turnId}/result';
+};
+
+export type ReportWorkflowConversationTurnResultErrors = {
+    /**
+     * 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 ReportWorkflowConversationTurnResultError = ReportWorkflowConversationTurnResultErrors[keyof ReportWorkflowConversationTurnResultErrors];
+
+export type ReportWorkflowConversationTurnResultResponses = {
+    /**
+     * Records the outcome of the turn this worker holds
+     */
+    200: WorkflowConversationActionResult;
+};
+
+export type ReportWorkflowConversationTurnResultResponse = ReportWorkflowConversationTurnResultResponses[keyof ReportWorkflowConversationTurnResultResponses];
+
+export type HeartbeatWorkflowConversationTurnData = {
+    body: WorkflowTurnClaimInput;
+    path: {
+        turnId: string;
+    };
+    query?: never;
+    url: '/workflow/conversation-turns/{turnId}/heartbeat';
+};
+
+export type HeartbeatWorkflowConversationTurnErrors = {
+    /**
+     * 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 HeartbeatWorkflowConversationTurnError = HeartbeatWorkflowConversationTurnErrors[keyof HeartbeatWorkflowConversationTurnErrors];
+
+export type HeartbeatWorkflowConversationTurnResponses = {
+    /**
+     * Renews this turn's lease and reports whether a person asked it to stop
+     */
+    200: WorkflowTurnHeartbeat;
+};
+
+export type HeartbeatWorkflowConversationTurnResponse = HeartbeatWorkflowConversationTurnResponses[keyof HeartbeatWorkflowConversationTurnResponses];
+
+export type AcknowledgeWorkflowConversationTurnStoppedData = {
+    body: WorkflowTurnClaimInput;
+    path: {
+        turnId: string;
+    };
+    query?: never;
+    url: '/workflow/conversation-turns/{turnId}/stopped';
+};
+
+export type AcknowledgeWorkflowConversationTurnStoppedErrors = {
+    /**
+     * 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 AcknowledgeWorkflowConversationTurnStoppedError = AcknowledgeWorkflowConversationTurnStoppedErrors[keyof AcknowledgeWorkflowConversationTurnStoppedErrors];
+
+export type AcknowledgeWorkflowConversationTurnStoppedResponses = {
+    /**
+     * The worker's confirmation that it stopped, which is what makes a retry safe
+     */
+    200: WorkflowConversationActionResult;
+};
+
+export type AcknowledgeWorkflowConversationTurnStoppedResponse = AcknowledgeWorkflowConversationTurnStoppedResponses[keyof AcknowledgeWorkflowConversationTurnStoppedResponses];
+
+export type ListWorkflowRunsData = {
+    body?: never;
+    path: {
+        projectId: string;
+    };
+    query?: never;
+    url: '/workflow/projects/{projectId}/runs';
+};
+
+export type ListWorkflowRunsErrors = {
+    /**
+     * 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 ListWorkflowRunsError = ListWorkflowRunsErrors[keyof ListWorkflowRunsErrors];
+
+export type ListWorkflowRunsResponses = {
+    /**
+     * Lists a project's workflow runs, most recent first
+     */
+    200: {
+        runs: Array<WorkflowRun>;
+    };
+};
+
+export type ListWorkflowRunsResponse = ListWorkflowRunsResponses[keyof ListWorkflowRunsResponses];
+
+export type StartWorkflowRunData = {
+    body: StartWorkflowRunInput;
+    path: {
+        projectId: string;
+    };
+    query?: never;
+    url: '/workflow/projects/{projectId}/runs';
+};
+
+export type StartWorkflowRunErrors = {
+    /**
+     * 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 StartWorkflowRunError = StartWorkflowRunErrors[keyof StartWorkflowRunErrors];
+
+export type StartWorkflowRunResponses = {
+    /**
+     * Starts a run from a working-tree workflow document
+     */
+    200: {
+        run: WorkflowRun;
+    };
+};
+
+export type StartWorkflowRunResponse = StartWorkflowRunResponses[keyof StartWorkflowRunResponses];
+
+export type ListWorkflowOffersData = {
+    body?: never;
+    path: {
+        projectId: string;
+    };
+    query?: never;
+    url: '/workflow/projects/{projectId}/offers';
+};
+
+export type ListWorkflowOffersErrors = {
+    /**
+     * 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 ListWorkflowOffersError = ListWorkflowOffersErrors[keyof ListWorkflowOffersErrors];
+
+export type ListWorkflowOffersResponses = {
+    /**
+     * Lists the nodes offered to a container polling this project
+     */
+    200: {
+        offers: Array<WorkflowDispatchPayload>;
+    };
+};
+
+export type ListWorkflowOffersResponse = ListWorkflowOffersResponses[keyof ListWorkflowOffersResponses];
+
+export type GetWorkflowRunData = {
+    body?: never;
+    path: {
+        runId: string;
+    };
+    query?: never;
+    url: '/workflow/runs/{runId}';
+};
+
+export type GetWorkflowRunErrors = {
+    /**
+     * 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 GetWorkflowRunError = GetWorkflowRunErrors[keyof GetWorkflowRunErrors];
+
+export type GetWorkflowRunResponses = {
+    /**
+     * Returns a run's full detail: the run row, its nodes, events, review decisions and projected graph
+     */
+    200: {
+        run: WorkflowRun;
+        nodes: Array<WorkflowNodeRun>;
+        events: Array<WorkflowRunEvent>;
+        decisions: Array<WorkflowReviewDecision>;
+        graph: WorkflowRunGraph;
+    };
+};
+
+export type GetWorkflowRunResponse = GetWorkflowRunResponses[keyof GetWorkflowRunResponses];
+
+export type AcceptWorkflowNodeData = {
+    body: AcceptWorkflowNodeInput;
+    path: {
+        runId: string;
+        nodeKey: string;
+    };
+    query?: never;
+    url: '/workflow/runs/{runId}/nodes/{nodeKey}/accept';
+};
+
+export type AcceptWorkflowNodeErrors = {
+    /**
+     * 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 AcceptWorkflowNodeError = AcceptWorkflowNodeErrors[keyof AcceptWorkflowNodeErrors];
+
+export type AcceptWorkflowNodeResponses = {
+    /**
+     * Accepts an offered node and returns its authoritative execution payload
+     */
+    200: AcceptedWorkflowNode;
+};
+
+export type AcceptWorkflowNodeResponse = AcceptWorkflowNodeResponses[keyof AcceptWorkflowNodeResponses];
+
+export type SetWorkflowHarnessData = {
+    body: SetWorkflowHarnessInput;
+    path: {
+        runId: string;
+    };
+    query?: never;
+    url: '/workflow/runs/{runId}/harness';
+};
+
+export type SetWorkflowHarnessErrors = {
+    /**
+     * 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 SetWorkflowHarnessError = SetWorkflowHarnessErrors[keyof SetWorkflowHarnessErrors];
+
+export type SetWorkflowHarnessResponses = {
+    /**
+     * Changes a live run's selected harness
+     */
+    200: {
+        applied: boolean;
+    };
+};
+
+export type SetWorkflowHarnessResponse = SetWorkflowHarnessResponses[keyof SetWorkflowHarnessResponses];
+
+export type ReportWorkflowNodeResultData = {
+    body: WorkflowNodeResultInput;
+    path: {
+        runId: string;
+        nodeKey: string;
+    };
+    query?: never;
+    url: '/workflow/runs/{runId}/nodes/{nodeKey}/result';
+};
+
+export type ReportWorkflowNodeResultErrors = {
+    /**
+     * 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 ReportWorkflowNodeResultError = ReportWorkflowNodeResultErrors[keyof ReportWorkflowNodeResultErrors];
+
+export type ReportWorkflowNodeResultResponses = {
+    /**
+     * Records a work node's terminal result
+     */
+    200: {
+        applied: boolean;
+    };
+};
+
+export type ReportWorkflowNodeResultResponse = ReportWorkflowNodeResultResponses[keyof ReportWorkflowNodeResultResponses];
+
+export type ReportWorkflowReviewData = {
+    body: WorkflowReviewReportInput;
+    path: {
+        runId: string;
+        nodeKey: string;
+    };
+    query?: never;
+    url: '/workflow/runs/{runId}/nodes/{nodeKey}/review';
+};
+
+export type ReportWorkflowReviewErrors = {
+    /**
+     * 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 ReportWorkflowReviewError = ReportWorkflowReviewErrors[keyof ReportWorkflowReviewErrors];
+
+export type ReportWorkflowReviewResponses = {
+    /**
+     * Records a reviewer's approval or objection
+     */
+    200: {
+        applied: boolean;
+    };
+};
+
+export type ReportWorkflowReviewResponse = ReportWorkflowReviewResponses[keyof ReportWorkflowReviewResponses];
+
+export type DecideWorkflowReviewData = {
+    body: WorkflowHumanDecisionInput;
+    path: {
+        runId: string;
+        nodeKey: string;
+    };
+    query?: never;
+    url: '/workflow/runs/{runId}/nodes/{nodeKey}/decide';
+};
+
+export type DecideWorkflowReviewErrors = {
+    /**
+     * 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 DecideWorkflowReviewError = DecideWorkflowReviewErrors[keyof DecideWorkflowReviewErrors];
+
+export type DecideWorkflowReviewResponses = {
+    /**
+     * A person's approve/reject decision on an objection parked for them
+     */
+    200: {
+        ok: true;
+    };
+};
+
+export type DecideWorkflowReviewResponse = DecideWorkflowReviewResponses[keyof DecideWorkflowReviewResponses];
+
+export type RetryWorkflowNodeData = {
+    body?: never;
+    path: {
+        runId: string;
+        nodeKey: string;
+    };
+    query?: never;
+    url: '/workflow/runs/{runId}/nodes/{nodeKey}/retry';
+};
+
+export type RetryWorkflowNodeErrors = {
+    /**
+     * 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 RetryWorkflowNodeError = RetryWorkflowNodeErrors[keyof RetryWorkflowNodeErrors];
+
+export type RetryWorkflowNodeResponses = {
+    /**
+     * Puts an errored node back in play
+     */
+    200: {
+        applied: boolean;
+    };
+};
+
+export type RetryWorkflowNodeResponse = RetryWorkflowNodeResponses[keyof RetryWorkflowNodeResponses];
+
+export type CancelWorkflowRunData = {
+    body?: never;
+    path: {
+        runId: string;
+    };
+    query?: never;
+    url: '/workflow/runs/{runId}/cancel';
+};
+
+export type CancelWorkflowRunErrors = {
+    /**
+     * 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 CancelWorkflowRunError = CancelWorkflowRunErrors[keyof CancelWorkflowRunErrors];
+
+export type CancelWorkflowRunResponses = {
+    /**
+     * Cancels a live run
+     */
+    200: {
+        applied: boolean;
+    };
+};
+
+export type CancelWorkflowRunResponse = CancelWorkflowRunResponses[keyof CancelWorkflowRunResponses];
+
 export type GetFeatureTogglesData = {
     body?: never;
     path?: never;