// This file is auto-generated by @hey-api/openapi-ts

export type ClientOptions = {
    baseUrl: 'https://api.eigenpal.com' | (string & {});
};

export type UpdateAutomationRequest = {
    /**
     * Move a YAML workflow into this workflow folder. `null` files it at the tenant root. Ignored for the folder lookup when `folderPath` is also sent, but a string value is still validated before the path is applied.
     */
    folderId?: string | null;
    /**
     * Slash-separated workflow folder path. Missing folders are created. Empty or `/` means root. When both fields are sent, `folderPath` wins after `folderId` validation.
     */
    folderPath?: string;
};

export type AutomationDatasetImportMultipartRequest = {
    /**
     * Dataset ZIP file
     */
    file: Blob | File;
    /**
     * `append` adds examples without deleting existing rows. `replace` deletes the current dataset before importing.
     */
    mode?: 'append' | 'replace';
};

/**
 * Replacement evaluator configuration.
 */
export type EvaluatorConfigUpdate = {
    /**
     * Complete evaluator YAML to validate and store.
     */
    yaml: string;
};

/**
 * Fields used to create or update a dataset example.
 */
export type DatasetExampleMutation = {
    /**
     * Example name. Required on create; omitted or null uses a generated name where supported.
     */
    name?: string | null;
    /**
     * Input arguments for the example.
     */
    input?: {
        [key: string]: unknown;
    } | null;
    /**
     * Expected JSON output. Null clears the expected output.
     */
    expected?: unknown | null;
    /**
     * Caller-managed metadata.
     */
    metadata?: {
        [key: string]: unknown;
    } | null;
    /**
     * Human note about the example. Null clears the annotation.
     */
    annotation?: string | null;
    /**
     * Optional display order. Null clears the order.
     */
    rowOrder?: number | null;
    /**
     * Step output overrides used during example runs.
     */
    overrides?: {
        [key: string]: unknown;
    } | null;
};

/**
 * Partial update for a dataset example. Omitted fields are preserved.
 */
export type DatasetExampleUpdate = {
    /**
     * Example name. Required on create; omitted or null uses a generated name where supported.
     */
    name?: string | null;
    /**
     * Input arguments for the example.
     */
    input?: {
        [key: string]: unknown;
    } | null;
    /**
     * Expected JSON output. Null clears the expected output.
     */
    expected?: unknown | null;
    /**
     * Caller-managed metadata.
     */
    metadata?: {
        [key: string]: unknown;
    } | null;
    /**
     * Human note about the example. Null clears the annotation.
     */
    annotation?: string | null;
    /**
     * Optional display order. Null clears the order.
     */
    rowOrder?: number | null;
    /**
     * Step output overrides used during example runs.
     */
    overrides?: {
        [key: string]: unknown;
    } | null;
};

export type DatasetExampleExpectedFileUploadRequest = {
    /**
     * One or more expected files to upload.
     */
    file: Array<Blob | File>;
};

export type DatasetExampleExpectedFileRenameRequest = {
    /**
     * New basename for the file. The parent folder is preserved.
     */
    newFilename: string;
};

export type DatasetExampleInputFileUploadRequest = {
    /**
     * One or more input files to upload.
     */
    file: Array<Blob | File>;
};

export type DatasetExampleInputFileRenameRequest = {
    /**
     * New basename for the file. The parent folder is preserved.
     */
    newFilename: string;
};

/**
 * Request body for starting an experiment batch.
 */
export type ExperimentCreate = {
    /**
     * Optional dataset example ids to run. Omit to run the full dataset.
     */
    examples?: Array<string>;
    /**
     * Maximum concurrent example runs for this experiment.
     */
    batchConcurrency?: number | null;
    /**
     * Optional source version/ref to use for experiment runs.
     */
    sourceRef?: string;
};

/**
 * Exactly one of `yaml` or `historyId`, plus a bare semver `version`. YAML is capped at 1 MiB. `historyId` copies the selected snapshot into a new tagged row and does not retag the source. Set `activate: false` to create a detached candidate that does not move live HEAD; that path requires an existing current version.
 */
export type CreateAutomationVersionRequest = {
    /**
     * Validated workflow YAML to publish as a new tagged version. Mutually exclusive with `historyId`. At most 1 MiB.
     */
    yaml: string;
    /**
     * Bare semver tag such as 1.2.0. Do not include a leading v.
     */
    version: string;
    /**
     * Whether to make the new version current immediately. Defaults to true. Set false to keep a tagged candidate off live traffic until promote. `activate: false` requires an existing current workflow version and returns 400 if HEAD is empty.
     */
    activate?: boolean;
} | {
    /**
     * Existing version id from GET /automations/{id}/versions. Creates a new tagged snapshot copied from that version; the source tag is left unchanged. Mutually exclusive with `yaml`.
     */
    historyId: string;
    /**
     * Bare semver tag such as 1.2.0. Do not include a leading v.
     */
    version: string;
    /**
     * Whether to make the new version current immediately. Defaults to true. Set false to keep a tagged candidate off live traffic until promote. `activate: false` requires an existing current workflow version and returns 400 if HEAD is empty.
     */
    activate?: boolean;
};

/**
 * Optional JSON body. Send `{}` when no message is needed. Restore always creates a new untagged current snapshot; it does not retag the source version.
 */
export type RestoreAutomationVersionRequest = {
    /**
     * Optional restore commit message. Defaults to a timestamped restore note.
     */
    message?: string;
};

export type CreateEmailServerRequest = {
    name: string;
    enabled?: boolean;
    transport: 'resend';
    apiKey: string;
    fromEmail: string;
    fromName: string;
} | {
    name: string;
    enabled?: boolean;
    transport: 'smtp';
    host: string;
    port?: number;
    security?: 'starttls' | 'tls' | 'none';
    username?: string;
    password?: string;
    caPem?: string;
    fromEmail: string;
    fromName: string;
};

export type UpdateEmailServerRequest = {
    name?: string;
    enabled?: boolean;
    transport: 'resend';
    apiKey?: string;
    fromEmail: string;
    fromName: string;
} | {
    name?: string;
    enabled?: boolean;
    transport: 'smtp';
    host: string;
    port: number;
    security: 'starttls' | 'tls' | 'none';
    username?: string | null;
    password?: string;
    caPem?: string | null;
    fromEmail: string;
    fromName: string;
} | {
    name?: string;
    enabled?: boolean;
};

export type TestEmailServerRequest = {
    to: string;
};

export type CreateFileMultipartRequest = {
    /**
     * Binary file field
     */
    file: Blob | File;
    /**
     * Optional lifecycle marker. `run-input` marks a retry-safe temporary run pre-upload reaped after 24 hours. `builder-attachment` marks a Studio builder intermediary (any MIME) with the same TTL.
     */
    purpose?: 'run-input' | 'builder-attachment';
};

export type CreateFileUploadSessionRequest = {
    filename: string;
    contentType: string;
    size: number;
    purpose?: 'run-input' | 'builder-attachment';
    idempotencyKey?: string;
};

export type PresignFileUploadPartRequest = {
    partNumber: number;
};

export type FolderType = 'workflow' | 'template';

export type CreateFolderRequest = {
    /**
     * Folder name. Cannot contain `/`.
     */
    name: string;
    /**
     * Which folder tree to create in. Required; there is no default.
     */
    type: FolderType;
    /**
     * Parent folder id. Omit or `null` to create at the tree root.
     */
    parentId?: string | null;
};

export type UpdateFolderRequest = {
    /**
     * New folder name. Cannot contain `/`.
     */
    name?: string;
    /**
     * New parent folder id. `null` moves the folder to the tree root.
     */
    parentId?: string | null;
};

/**
 * Run envelope. Declare provenance with the `X-Eigenpal-Trigger` header (`api` or `cli`). Legacy 0.5.12 body shapes remain accepted.
 */
export type RunStartBody = {
    /**
     * Automation target without a version suffix, e.g. workflows.invoice or agents.support.
     */
    target: string;
    /**
     * Scalar and structured automation arguments.
     */
    input?: {
        [key: string]: unknown;
    };
    /**
     * File inputs as ingress references (`{ "$fileId": "file_..." }` or `{ "$inline": { filename, mimeType, base64 } }`). Upload bytes via multipart `files.<fieldName>` parts instead.
     */
    files?: {
        [key: string]: {
            /**
             * Reusable file-pool id to materialize
             */
            $fileId: string;
        } | {
            $inline: {
                /**
                 * Original filename for the materialized artifact
                 */
                filename: string;
                /**
                 * MIME type for the materialized artifact
                 */
                mimeType: string;
                /**
                 * Base64-encoded file bytes
                 */
                base64: string;
            };
        } | Array<{
            /**
             * Reusable file-pool id to materialize
             */
            $fileId: string;
        } | {
            $inline: {
                /**
                 * Original filename for the materialized artifact
                 */
                filename: string;
                /**
                 * MIME type for the materialized artifact
                 */
                mimeType: string;
                /**
                 * Base64-encoded file bytes
                 */
                base64: string;
            };
        }>;
    };
    /**
     * Per-step output overrides. Workflow runs only.
     */
    overrides?: {
        steps?: {
            [key: string]: {
                [key: string]: unknown;
            };
        };
    };
    /**
     * Caller-supplied run metadata.
     */
    metadata?: {
        [key: string]: unknown;
    };
};

export type RunStartMultipartRequest = {
    /**
     * Automation target, e.g. `workflows.invoice`.
     */
    target: string;
    /**
     * JSON-encoded scalar input object.
     */
    input?: string;
    /**
     * JSON-encoded step overrides.
     */
    overrides?: string;
    /**
     * JSON-encoded run metadata.
     */
    metadata?: string;
    [key: string]: unknown;
};

/**
 * Create or update a dataset example from the run input, actual output, and review corrections.
 */
export type PromoteRunRequest = {
    /**
     * Dataset example name to create or update. Defaults to a generated name when omitted.
     */
    name?: string;
};

/**
 * Create or replace review metadata for a run. Attribution fields (`reviewedBy`, `closedBy`, and their emails) are read-only and populated from the authenticated user or API key creator.
 */
export type RunReviewRequest = {
    /**
     * Reviewer verdict. Omit or send null for feedback without a ranking (nit). Defaults are applied client-side only; any verdict/status combination is accepted.
     */
    verdict?: 'correct' | 'incorrect' | null;
    /**
     * Review lifecycle. Defaults from verdict (`correct` → `closed`, otherwise `open`). Use `closed` or `wont_fix` to close an open review.
     */
    status?: 'open' | 'closed' | 'wont_fix';
    /**
     * Reviewer note.
     */
    note?: string | null;
    /**
     * Corrected JSON output for this run. Send `null` to clear a previously stored correction.
     */
    correctedOutput?: unknown | null;
    /**
     * Field and file corrections. When present, replaces the entire correction set for this review. Omit to leave existing corrections unchanged.
     */
    corrections?: Array<{
        id?: string;
        kind: 'field' | 'file';
        path: string;
        label?: string | null;
        originalValue?: unknown;
        correctedValue?: unknown;
        note?: string | null;
        correctedArtifactPath?: string | null;
    }>;
};

/**
 * JSON request body for copying one run output file into the corrected artifact set.
 */
export type RunReviewExpectedFileCopyRequest = {
    /**
     * Name of an existing run output file to copy into corrected artifacts.
     */
    outputFileName: string;
    /**
     * Optional name for the copied corrected file. Defaults to the original output file name.
     */
    expectedName?: string;
};

export type RunReviewExpectedFileUploadRequest = {
    /**
     * Corrected artifact file to upload.
     */
    file: Blob | File;
    /**
     * Optional stored corrected file name. Defaults to the uploaded filename.
     */
    name?: string;
};

/**
 * Rename one corrected file.
 */
export type RunReviewExpectedFileUpdateRequest = {
    /**
     * New corrected file name.
     */
    name: string;
};

export type TemplateFileReferenceRequest = {
    /**
     * Reusable file id produced by the direct file upload flow. It is consumed as upload transport, not exposed as template identity.
     */
    fileId: string;
    name?: string;
    description?: string;
    /**
     * When true, the create response includes a one-time cleanupProof for unpublished CLI staging. Normal uploads omit this.
     */
    staged?: boolean;
};

export type TemplateReplaceRequest = {
    /**
     * Reusable file id produced by the direct file upload flow. It is consumed as upload transport, not exposed as template identity.
     */
    fileId: string;
};

export type TemplateStagingRequest = {
    proof: string;
    action: 'cleanup' | 'finalize';
};

export type AuthCheckResponse = {
    ok: true;
    tenantId: string;
    tenantSlug: string;
    tenantName: string | null;
    userId: string | null;
    keyId: string;
    email: string | null;
    name: string | null;
    scope: Array<string>;
    wildcardGranted: boolean;
};

export type ApiErrorEnvelope = {
    issues: Array<ApiErrorIssue>;
    /**
     * Request id echoed via the x-request-id header
     */
    requestId: string;
    /**
     * Suggested fix for known error patterns
     */
    hint?: string;
    /**
     * Link to relevant docs
     */
    docsUrl?: string;
    /**
     * Present on 409 workflow_name_conflict responses. Id of the workflow that already owns the requested name.
     */
    conflictingWorkflowId?: string;
};

export type ApiErrorIssue = {
    /**
     * JSON path of the offending field, or "<root>"
     */
    field: string;
    /**
     * Human-readable error message
     */
    message: string;
    /**
     * Machine-readable error code (e.g. invalid_value, not_found, api_trigger_disabled, manual_trigger_disabled)
     */
    code: string;
    /**
     * Issue severity
     */
    severity: 'error' | 'warning';
};

export type ListAutomationsResponse = {
    data: Array<AutomationSummary>;
    total: number;
    limit: number;
    offset: number;
};

export type AutomationSummary = {
    /**
     * Implementation id for the automation. Workflow automations use workflow ids; agent automations use agent workflow ids.
     */
    id: string;
    type: AutomationType;
    slug: string;
    name: string | null;
    description?: string | null;
    status?: string;
    version?: string | null;
    triggers?: AutomationTriggerState;
    /**
     * False when the automations registry row exists but the workflow/agent implementation row is missing.
     */
    implementationAvailable?: boolean;
    /**
     * Workflow folder id. Null for unfiled workflows, agent automations, and orphan registry rows.
     */
    folderId: string | null;
    /**
     * Slash-separated workflow folder path from the tenant root, such as `billing/invoices`. Null at root and for agent automations.
     */
    folderPath: string | null;
    createdAt: string;
    updatedAt?: string;
};

export type AutomationType = 'workflow' | 'agent';

export type AutomationTriggerState = {
    api: boolean;
    email: boolean;
    manual: boolean;
    cron: boolean;
};

export type AutomationDetail = {
    /**
     * Implementation id for the automation. Workflow automations use workflow ids; agent automations use agent workflow ids.
     */
    id: string;
    type: AutomationType;
    slug: string;
    name: string | null;
    description?: string | null;
    status?: string;
    version?: string | null;
    triggers?: AutomationTriggerState;
    /**
     * False when the automations registry row exists but the workflow/agent implementation row is missing.
     */
    implementationAvailable?: boolean;
    /**
     * Workflow folder id. Null for unfiled workflows, agent automations, and orphan registry rows.
     */
    folderId: string | null;
    /**
     * Slash-separated workflow folder path from the tenant root, such as `billing/invoices`. Null at root and for agent automations.
     */
    folderPath: string | null;
    createdAt: string;
    updatedAt?: string;
    inputSchema?: {
        [key: string]: unknown;
    } | null;
    outputSchema?: {
        [key: string]: unknown;
    } | null;
};

export type DeleteAutomationResponse = {
    deleted: true;
    id: string;
};

export type DatasetImportResponse = {
    mode: 'append';
    created: number;
    expectedSet: number;
    skipped: number;
    issues: Array<unknown>;
} | {
    mode: 'replace';
    created: number;
    expectedSet: number;
    deleted: number;
    filesDeleted: number;
};

/**
 * Evaluator YAML and parsed evaluator configuration for an automation.
 */
export type EvaluatorConfigResponse = {
    /**
     * Automation that owns this evaluator config.
     */
    automationId: string;
    automationType: AutomationType;
    /**
     * Evaluator configuration YAML.
     */
    yaml: string;
    config: {
        /**
         * Parsed evaluator definitions from the YAML.
         */
        evaluators: Array<unknown>;
        /**
         * Overall score threshold required for the experiment to pass.
         */
        passThreshold: number;
    };
};

export type DatasetExampleList = {
    data: Array<DatasetExample>;
    total: number;
    limit: number;
    offset: number;
};

/**
 * One input/expected-output row in an automation dataset.
 */
export type DatasetExample = {
    /**
     * Stable public example id. Workflow examples use DB ids; agent examples use deterministic name-derived ids.
     */
    id: string;
    /**
     * Human-readable dataset example name.
     */
    name: string;
    /**
     * Automation that owns this example.
     */
    automationId: string;
    automationType: AutomationType;
    /**
     * Input arguments used when this example is run. Null when listing with `include=metadata`.
     */
    input: {
        [key: string]: unknown;
    } | null;
    /**
     * Expected JSON output for evaluator comparisons. Null when listing with `include=metadata`.
     */
    expected: unknown | null;
    /**
     * Expected files attached to this example.
     */
    expectedFiles: Array<{
        /**
         * Expected file name.
         */
        name: string;
        /**
         * Download URL for the expected file.
         */
        url?: string;
    }>;
    /**
     * Caller-managed metadata for sorting or filtering examples.
     */
    metadata: {
        [key: string]: unknown;
    } | null;
    /**
     * Human note about the example.
     */
    annotation: string | null;
    /**
     * Optional display order within the dataset.
     */
    rowOrder: number | null;
    /**
     * Step output overrides used when running this example.
     */
    overrides: {
        [key: string]: unknown;
    } | null;
    /**
     * Most recent run id created from this example.
     */
    latestRunId: string | null;
    createdAt?: string;
    updatedAt?: string | null;
};

export type DatasetExampleExpectedFileList = {
    /**
     * Paths under the example expected folder.
     */
    files: Array<string>;
};

export type DatasetExampleExpectedFileUploadResponse = {
    /**
     * Stored expected file paths.
     */
    uploaded: Array<string>;
};

export type DatasetExampleExpectedFileRenameResponse = {
    ok: true;
    filename: string;
    /**
     * Updated expected file path.
     */
    path: string;
};

export type DatasetExampleInputFileList = {
    /**
     * Paths under the example input folder.
     */
    files: Array<string>;
};

export type DatasetExampleInputFileUploadResponse = {
    /**
     * Stored input file paths.
     */
    uploaded: Array<string>;
};

export type DatasetExampleInputFileRenameResponse = {
    ok: true;
    filename: string;
    /**
     * Updated input file path.
     */
    path: string;
};

export type ExampleRunResponse = {
    /**
     * Run id created for this example.
     */
    id: string;
    /**
     * Implementation type behind the automation.
     */
    type: 'workflow' | 'agent';
    /**
     * Experiment batch id when the run is associated with a batch. The API also calls this an experiment id in experiment routes.
     */
    batchId: string | null;
    /**
     * Example runs are accepted asynchronously.
     */
    finished: false;
};

/**
 * Experiment batch summary for an automation dataset run.
 */
export type Experiment = {
    /**
     * Experiment batch id. Some CLI commands historically call this a batch id.
     */
    id: string;
    /**
     * Automation this experiment belongs to.
     */
    automationId: string;
    automationType: AutomationType;
    /**
     * Experiment batch status.
     */
    status: 'queued' | 'running' | 'completed';
    /**
     * Total runs in the experiment.
     */
    runCount: number;
    /**
     * Runs that have completed.
     */
    completedCount: number;
    /**
     * Runs whose evaluator scores passed.
     */
    passedCount: number;
    /**
     * Runs whose evaluator scores failed.
     */
    failedCount: number;
    /**
     * Average automated evaluator score.
     */
    avgScore: number | null;
    createdAt: string;
    completedAt: string | null;
    version: string | null;
};

/**
 * Accepted experiment batch and the runs it enqueued.
 */
export type ExperimentCreateResponse = {
    /**
     * Experiment batch id.
     */
    id: string;
    /**
     * Runs enqueued for this experiment.
     */
    runs: Array<{
        /**
         * Run id.
         */
        id: string;
        /**
         * Dataset example id.
         */
        exampleId: string | null;
    }>;
    /**
     * Number of runs enqueued.
     */
    total: number;
};

/**
 * Experiment batch detail.
 */
export type ExperimentDetail = {
    /**
     * Experiment batch id. Some CLI commands historically call this a batch id.
     */
    id: string;
    /**
     * Automation this experiment belongs to.
     */
    automationId: string;
    automationType: AutomationType;
    /**
     * Experiment batch status.
     */
    status: 'queued' | 'running' | 'completed';
    /**
     * Total runs in the experiment.
     */
    runCount: number;
    /**
     * Runs that have completed.
     */
    completedCount: number;
    /**
     * Runs whose evaluator scores passed.
     */
    passedCount: number;
    /**
     * Runs whose evaluator scores failed.
     */
    failedCount: number;
    /**
     * Average automated evaluator score.
     */
    avgScore: number | null;
    createdAt: string;
    completedAt: string | null;
    version: string | null;
    /**
     * Runs created for dataset examples in this experiment.
     */
    runs: Array<{
        /**
         * Run id created for the experiment.
         */
        id: string;
        /**
         * Current run status.
         */
        status: string;
        /**
         * Dataset example id for the run.
         */
        exampleId: string | null;
        /**
         * Dataset example name for the run.
         */
        exampleName: string | null;
        /**
         * Persisted weighted evaluator score.
         */
        evalScore: number | null;
        /**
         * Persisted aggregate evaluator verdict.
         */
        evalPassed: boolean | null;
        createdAt: string;
        completedAt: string | null;
    }>;
    /**
     * Evaluator results keyed by run id.
     */
    resultsByRun: {
        [key: string]: Array<EvalResult>;
    };
};

/**
 * Automated evaluator result for one run.
 */
export type EvalResult = {
    /**
     * Evaluator result id.
     */
    id: string;
    /**
     * Run this score belongs to.
     */
    runId: string;
    /**
     * Automation this score belongs to.
     */
    automationId: string | null;
    /**
     * Evaluator name from configuration.
     */
    evaluatorName: string;
    /**
     * Evaluator implementation type.
     */
    evaluatorType: string;
    /**
     * Automated evaluator score. Do not confuse this with a human review verdict.
     */
    score: number | null;
    /**
     * Whether this evaluator passed.
     */
    passed: boolean | null;
    /**
     * Optional evaluator label.
     */
    label: string | null;
    /**
     * Weight used in aggregate scoring.
     */
    weight: number | null;
    /**
     * Score threshold required for this evaluator to pass.
     */
    passThreshold: number | null;
    /**
     * Evaluator description.
     */
    description: string | null;
    /**
     * Evaluator-specific details.
     */
    details: unknown | null;
    /**
     * Evaluator error, when scoring failed.
     */
    error: string | null;
    createdAt: string;
};

export type RunReviewHealthResponse = {
    timeRange: {
        from: string;
        to: string;
    };
    granularity: {
        bucket: 'day' | 'week' | 'month';
        rollingWindow: number;
        minRollingReviews: number;
    };
    summary: RunReviewHealthSummary;
    buckets: Array<RunReviewHealthBucket>;
    rolling: Array<RunReviewHealthRollingPoint>;
};

export type RunReviewHealthSummary = {
    totalRuns: number;
    /**
     * Runs with a ranked verdict (`correct` or `incorrect`). Null verdict (nit) is excluded.
     */
    reviewedRuns: number;
    reviewCoverage: number | null;
    correctReviews: number;
    incorrectReviews: number;
    /**
     * Runs with a review row and null verdict (nit). Excluded from review coverage and accuracy.
     */
    nitReviews: number;
    reviewedCorrectness: number | null;
    confidence: RunReviewHealthConfidence;
};

/**
 * Wilson score confidence interval for reviewed correctness. Null bounds mean there are no reviewed runs in the sample.
 */
export type RunReviewHealthConfidence = {
    lower: number | null;
    upper: number | null;
    method: 'wilson';
};

export type RunReviewHealthBucket = {
    start: string;
    end: string;
    totalRuns: number;
    /**
     * Runs with a ranked verdict (`correct` or `incorrect`). Null verdict (nit) is excluded.
     */
    reviewedRuns: number;
    reviewCoverage: number | null;
    correctReviews: number;
    incorrectReviews: number;
    /**
     * Runs with a review row and null verdict (nit). Excluded from review coverage and accuracy.
     */
    nitReviews: number;
    reviewedCorrectness: number | null;
};

export type RunReviewHealthRollingPoint = {
    at: string;
    /**
     * Runs with a ranked verdict (`correct` or `incorrect`). Null verdict (nit) is excluded.
     */
    reviewedRuns: number;
    correctReviews: number;
    reviewedCorrectness: number;
    confidenceLower: number;
    confidenceUpper: number;
    /**
     * Total production runs in the rolling window ending at this point.
     */
    totalRunsInWindow: number;
    /**
     * Share of runs in the rolling window that were reviewed (0-1). Uses the same window size as rolling accuracy, applied to all runs.
     */
    reviewCoverage: number;
};

export type AutomationTriggersResponse = {
    automationId: string;
    type: AutomationType;
    triggers: AutomationTriggerState;
};

export type ListAutomationVersionsResponse = {
    data: Array<AutomationVersion>;
    total: number;
    limit: number;
    offset: number;
};

export type AutomationVersion = {
    id: string;
    automationId: string;
    version: string | null;
    sourceRef?: string | null;
    isCurrent?: boolean;
    createdAt?: string;
};

export type ListEmailServersResponse = {
    data: Array<EmailServer>;
    total: number;
    limit: number;
    offset: number;
};

export type EmailServer = ({
    transport: 'resend';
} & PublicResendEmailServer) | ({
    transport: 'smtp';
} & PublicSmtpEmailServer);

export type PublicResendEmailServer = {
    id: string;
    name: string;
    enabled: boolean;
    createdAt: string;
    updatedAt: string;
    transport: 'resend';
    fromEmail: string;
    fromName: string;
    apiKeyConfigured: true;
};

export type PublicSmtpEmailServer = {
    id: string;
    name: string;
    enabled: boolean;
    createdAt: string;
    updatedAt: string;
    transport: 'smtp';
    fromEmail: string;
    fromName: string;
    host: string;
    port: number;
    security: 'starttls' | 'tls' | 'none';
    username: string | null;
    passwordConfigured: boolean;
    caPemConfigured: boolean;
};

export type DeleteEmailServerResponse = {
    deleted: true;
    id: string;
};

export type TestEmailServerResponse = {
    ok: true;
    transport: 'resend' | 'smtp';
    messageId: string;
} | {
    ok: false;
    error: string;
};

export type ExperimentRef = {
    id: string;
    automationId: string;
};

export type File = {
    id: string;
    filename: string;
    contentType: string | null;
    size: number | null;
    /**
     * Optional lifecycle marker. `run-input` marks a retry-safe temporary run pre-upload reaped after 24 hours. `builder-attachment` marks a Studio builder intermediary (any MIME) with the same TTL. Omitted/null means a durable reusable file.
     */
    purpose?: string | null;
    createdAt: string;
};

export type DeleteFileResponse = {
    deleted: boolean;
};

export type PresignedFileUploadSession = {
    transport: 'presigned-put';
    uploadId: string;
    fileId: string;
    url: string;
    headers: {
        [key: string]: string;
    };
    expiresAt: string;
    maxFileSizeBytes: number;
};

export type PresignedMultipartFileUploadSession = {
    transport: 'presigned-multipart';
    uploadId: string;
    fileId: string;
    partSizeBytes: number;
    partCount: number;
    partsUrl: string;
    completeUrl: string;
    expiresAt: string;
    maxFileSizeBytes: number;
};

export type MultipartFileUploadFallback = {
    transport: 'multipart';
    url: string;
    maxFileSizeBytes: number;
};

export type FileUploadSession = {
    uploadId: string;
    fileId: string;
    transport: 'presigned-put' | 'presigned-multipart';
    status: string;
    expiresAt: string;
    partSizeBytes?: number | null;
    partCount?: number | null;
    parts?: Array<{
        partNumber: number;
        size?: number;
        etag: string;
    }>;
};

export type AbortFileUploadResponse = {
    aborted: true;
};

export type ListFileUploadPartsResponse = {
    transport: 'presigned-multipart';
    uploadId: string;
    fileId: string;
    partSizeBytes: number;
    partCount: number;
    expiresAt: string;
    parts: Array<{
        partNumber: number;
        size?: number;
        etag: string;
    }>;
};

export type PresignFileUploadPartResponse = {
    transport: 'presigned-multipart';
    partNumber: number;
    url: string;
    headers: {
        [key: string]: string;
    };
    expiresAt: string;
    partSizeBytes: number;
};

export type ListFoldersResponse = Array<Folder>;

export type Folder = {
    id: string;
    parentId: string | null;
    type: FolderType;
    name: string;
    createdAt: string;
    /**
     * Direct subfolder count. Present on tree listings.
     */
    childCount?: number;
    /**
     * Workflows filed directly in this folder. Present on workflow-tree listings.
     */
    workflowCount?: number;
    /**
     * Up to a handful of item names — subfolders first, then workflows — for a peek at folder contents. Present on workflow-tree listings.
     */
    previewItems?: Array<{
        name: string;
        kind: 'folder' | 'workflow';
    }>;
};

export type DeleteFolderResponse = {
    deleted: true;
    id: string;
};

export type HumanReviewListResponse = {
    tasks: Array<{
        id: string;
        executionId: string;
        automationId: string;
        automationName: string;
        sourceKind: 'workflow_step' | 'agent_tool';
        sourceLabel: string;
        status: 'pending' | 'approved' | 'rejected' | 'cancelled';
        requiredCount: number;
        confirmedCount: number;
        version: number;
        createdAt: string;
        updatedAt: string;
    }>;
    nextCursor: string | null;
};

export type HumanReviewTaskResponse = {
    task: HumanReviewTaskDetail;
};

export type HumanReviewTaskDetail = {
    id: string;
    executionId: string;
    automationId: string;
    automationName: string;
    sourceKind: 'workflow_step' | 'agent_tool';
    sourceLabel: string;
    status: 'pending' | 'approved' | 'rejected' | 'cancelled';
    requiredCount: number;
    confirmedCount: number;
    version: number;
    createdAt: string;
    updatedAt: string;
    files: Array<{
        fileId: string;
        filename: string;
        mimeType?: string;
        size?: number;
        fieldName?: string;
        artifactPath: string;
        /**
         * run_input for authorized run input files; attachment for extra current-run files. Omitted on historical tasks and inferred at read time.
         */
        role?: 'run_input' | 'attachment';
    }>;
    /**
     * Non-file trigger input derived at read time. Null when every field is a file or external source id. omitted_too_large when the projection exceeds the review data byte limit.
     */
    input: {
        status: 'available';
        data: {
            [key: string]: unknown;
        } | Array<unknown>;
    } | {
        status: 'omitted_too_large';
    } | null;
    machineData: {
        [key: string]: unknown;
    } | Array<unknown>;
    draftData: {
        [key: string]: unknown;
    } | Array<unknown>;
    schema: {
        [key: string]: unknown;
    } | null;
    fieldMetadata: {
        [key: string]: {
            /**
             * Producer-supplied confidence: 0–1 numeric (legacy) or categorical low|medium|high from ai.extract grounding. Not calibrated by Eigenpal.
             */
            confidence?: number | 'low' | 'medium' | 'high' | string;
            /**
             * Short label shown in the review UI
             */
            label?: string;
            /**
             * Longer reviewer guidance for this field
             */
            description?: string;
            /**
             * Legacy per-field override kept for existing tasks. Prefer selection.fields.review.
             */
            review?: 'auto' | 'always' | 'never';
            /**
             * Opaque display metadata preserved for the review UI
             */
            display?: {
                [key: string]: unknown;
            };
        };
    };
    requiredPaths: Array<string>;
    selectionReasons: {
        [key: string]: 'always' | 'explicit' | 'low_confidence' | 'missing_confidence' | 'all' | 'reviewer_edit' | 'threshold_met' | 'never' | 'excluded' | 'unmatched' | 'missing_confidence_skip';
    };
    decisions: Array<{
        id: string;
        path: string;
        originalValue: string | number | boolean | null;
        currentValue: string | number | boolean | null;
        required: boolean;
        reason: 'always' | 'explicit' | 'low_confidence' | 'missing_confidence' | 'all' | 'reviewer_edit' | 'threshold_met' | 'never' | 'excluded' | 'unmatched' | 'missing_confidence_skip';
        confirmedBy: string | null;
        confirmedAt: string | null;
        version: number;
    }>;
    instructions: string | null;
    completedBy: string | null;
    completedAt: string | null;
    outcomeReason: string | null;
    /**
     * Optional lineage@1 document resolved from the extract sidecar. Omitted when missing or unreadable. Validate with @openparser/lineage.
     */
    lineage?: {
        [key: string]: unknown;
    };
    /**
     * Optional ParsedDocument resolved from the extract sidecar. Omitted when missing or unreadable. Validate with @openparser/schema.
     */
    parsedDocument?: {
        [key: string]: unknown;
    };
};

export type HumanReviewApproveResponse = {
    task: HumanReviewTaskDetail;
};

export type HumanReviewFieldResponse = {
    task: HumanReviewTaskDetail;
};

export type HumanReviewRejectResponse = {
    task: HumanReviewTaskDetail;
};

export type ListModelsResponse = {
    data: Array<PublicModel>;
    total: number;
};

export type PublicModel = {
    id: string;
    kind: 'llm' | 'ocr';
    provider: string;
    label: string;
    capabilities: Array<'text' | 'vision' | 'ocr'>;
    configured: boolean;
    available: boolean;
    /**
     * Configuration state only: `configured` means credentials are present in this environment; `unconfigured` means the catalog entry exists but credentials are missing. This list does not probe live providers, so it never reports healthy/degraded/outage. `unknown` is reserved and is not emitted by this endpoint.
     */
    health: 'configured' | 'unconfigured' | 'unknown';
    defaultFor: Array<'text' | 'vision' | 'ocr'>;
    /**
     * `local` means on-prem / no cloud provider egress (`local: true` or tesseract). `hosted` means the provider is a cloud API. Endpoints are never returned.
     */
    location: 'local' | 'hosted';
    limits?: PublicModelLimits;
    /**
     * Static Eigenpal credit rates when known without a live vendor catalog. Omitted for OpenParser OCR and for LLMs (token prices are not part of this catalog).
     */
    cost?: PublicModelCost;
    aliases: Array<string>;
    tags: Array<string>;
    /**
     * Optional picker rank. Higher is more capable. Omitted on catalog rows that do not set it. Does not change role defaults.
     */
    capabilityRank?: number;
};

export type PublicModelLimits = {
    requestTimeoutSeconds?: number;
    maxConcurrentRequests?: number;
};

export type PublicModelCost = {
    creditsPerPage?: number;
    unit: 'credits';
};

export type RunsListResponse = {
    runs: Array<RunListItem>;
    nextCursor: string | null;
};

export type RunListItem = {
    id: string;
    type: 'workflow' | 'agent';
    /**
     * True when the run has reached a terminal status.
     */
    finished: boolean;
    /**
     * Deterministic pseudo-random rank in [0, 1) for this run within the tenant. Use with a sample rate threshold to review a stable subset.
     */
    sampleRank: number;
    /**
     * Parent run id when this run was started by an invoke-workflow step. Omitted for top-level runs.
     */
    parentExecutionId?: string;
    timing: RunTiming;
    source: RunSource;
    trigger: RunTrigger;
    /**
     * Present only on eval-scoped runs. Omitted otherwise.
     */
    eval?: RunEval;
    /**
     * Terminal failure message. Present on terminal runs; null when the run succeeded. Absent while the run is still in flight.
     */
    error?: RunError;
    execution: RunExecutionMeta;
};

export type RunTiming = {
    createdAt: string;
    startedAt: string | null;
    completedAt: string | null;
    durationMs: number | null;
    /**
     * When the user requested cancel; status may still be `running` until the worker stops.
     */
    cancelRequestedAt: string | null;
};

export type RunSource = {
    /**
     * Owning workflow id or agent id.
     */
    id: string;
    name: string | null;
    /**
     * Workflow version label (workflow runs only).
     */
    version: string | null;
    /**
     * Captured workflow version id (workflow runs only).
     */
    versionId?: string | null;
    /**
     * Agent slug (agent runs only).
     */
    slug?: string | null;
    /**
     * LLM model used (agent runs only).
     */
    model?: string | null;
    /**
     * Git provenance (agent runs only).
     */
    git?: RunSourceGit | null;
    /**
     * Whether the live workflow/agent implementation still exists (`GET /api/v1/runs/:id` detail only).
     */
    implementationAvailable?: boolean;
    /**
     * Whether the owning automation registry row still exists (`GET /api/v1/runs/:id` detail only).
     */
    automationFound?: boolean;
    /**
     * Current released workflow version label when the source is live (`GET /api/v1/runs/:id` detail only).
     */
    currentVersion?: string | null;
};

export type RunSourceGit = {
    requestedRef: string | null;
    resolvedRef: string | null;
    resolvedTag: string | null;
    commitSha: string | null;
};

export type RunTrigger = {
    type: string | null;
    by: {
        id: string;
        name: string | null;
        email: string;
    } | null;
    /**
     * Inbound email trigger details (agent runs, `expand=input` not required).
     */
    email?: unknown;
};

export type RunEval = {
    /**
     * Eval example label (agent example name or workflow example id).
     */
    example: string | null;
    /**
     * Workflow eval example folder id (workflow runs only).
     */
    exampleId?: string | null;
    score: number | null;
    passed: boolean | null;
};

export type RunError = string | null;

export type RunExecutionMeta = {
    /**
     * Status of this run. `retry.nextRun.status` is a later retry, not this run.
     */
    status: ExecutionStatus;
    /**
     * Whether the completed output matched the workflow or agent output schema.
     */
    schemaValid: boolean | null;
    /**
     * Experiment batch id when the run is part of a batch.
     */
    batchId: string | null;
    retry: RunExecutionRetry;
    /**
     * Lightweight review state for run list rows.
     */
    review?: RunReviewSummary | null;
    /**
     * Pending in-flight human review when the run is waiting on a reviewer.
     */
    humanReview?: RunHumanReviewSummary | null;
};

export type ExecutionStatus = 'created' | 'pending' | 'running' | 'waiting' | 'finalizing' | 'completed' | 'failed' | 'cancelled' | 'rejected';

export type RunExecutionRetry = {
    /**
     * Retry attempt index (0 = original run).
     */
    number: number;
    /**
     * Run id of the prior attempt in the retry chain.
     */
    previousRunId: string | null;
    /**
     * Retry run spawned from this run, if any. Present on list and detail without `expand`. `status` here is the later retry, not this run.
     */
    nextRun: {
        id: string;
        status: string;
    } | null;
};

export type RunReviewSummary = {
    verdict: 'correct' | 'incorrect' | null;
    status: 'open' | 'closed' | 'wont_fix';
    /**
     * True when review notes were left.
     */
    hasNote: boolean;
    /**
     * Number of field/file corrections.
     */
    correctionCount: number;
};

export type RunHumanReviewSummary = {
    taskId: string;
    sourceKind: 'workflow_step' | 'agent_tool';
    sourceLabel: string;
    status: 'pending';
    requiredCount: number;
    confirmedCount: number;
    version: number;
};

export type Run = {
    id: string;
    type: 'workflow' | 'agent';
    /**
     * True when the run has reached a terminal status.
     */
    finished: boolean;
    /**
     * Deterministic pseudo-random rank in [0, 1) for this run within the tenant. Use with a sample rate threshold to review a stable subset.
     */
    sampleRank: number;
    /**
     * Parent run id when this run was started by an invoke-workflow step. Omitted for top-level runs.
     */
    parentExecutionId?: string;
    timing: RunTiming;
    source: RunSource;
    trigger: RunTrigger;
    /**
     * Present only on eval-scoped runs. Omitted otherwise.
     */
    eval?: RunEval;
    /**
     * Completed runs only. Per-automation business result — not a generic schema. Absent until the run completes.
     */
    output?: {
        [key: string]: unknown;
    } | null;
    /**
     * Completed runs only. Download with GET /api/v1/runs/:id/artifacts/:path. Absent until the run completes.
     */
    files?: Array<RunArtifact>;
    /**
     * Terminal failure message. Present on terminal runs; null when the run succeeded. Absent while the run is still in flight.
     */
    error?: RunError;
    /**
     * Present only with `expand=input`.
     */
    input?: RunInput;
    /**
     * Present only with `expand=usage`. Null for old runs without telemetry.
     */
    usage?: RunUsage | null;
    /**
     * Slim execution metadata always present (`status`, `schemaValid`, `batchId`, `retry`). Pass `expand=execution` to replace with full RunExecution (WorkflowRunExecution or AgentRunExecution depending on run type).
     */
    execution: RunExecutionMeta | RunExecution;
    /**
     * Present only with `expand=debug`.
     */
    debug?: RunDebug;
};

export type RunArtifact = {
    name: string;
    /**
     * `input`, `output`, `debug`, `report`, or another stable artifact role.
     */
    role: string;
    /**
     * Canonical artifact path for GET /api/v1/runs/:id/artifacts/:path.
     */
    path: string;
    /**
     * Workflow step that produced the file, when known.
     */
    stepName?: string;
    contentType?: string | null;
    size?: number | null;
};

export type RunInput = {
    /**
     * Input arguments the run was started with.
     */
    args: unknown;
    /**
     * Uploaded input files (agent runs only).
     */
    files?: Array<RunFile>;
    /**
     * Caller-supplied run metadata, if any.
     */
    metadata?: unknown;
};

export type RunFile = {
    name: string;
};

export type RunUsage = {
    tokens: {
        input: number | null;
        output: number | null;
        cacheRead: number | null;
        cacheWrite: number | null;
    };
    creditsCharged: number | null;
    durationMs: number | null;
    /**
     * LLM call count (workflow runs only).
     */
    llmCallCount?: number;
    /**
     * OCR pages processed (workflow runs only).
     */
    ocrPagesProcessed?: number;
    /**
     * Agent conversation turns (agent runs only).
     */
    agentTurns?: number | null;
};

export type RunExecution = WorkflowRunExecution | AgentRunExecution;

export type WorkflowRunExecution = {
    /**
     * Status of this run. `retry.nextRun.status` is a later retry, not this run.
     */
    status: ExecutionStatus;
    /**
     * Whether the completed output matched the workflow or agent output schema.
     */
    schemaValid: boolean | null;
    /**
     * Experiment batch id when the run is part of a batch.
     */
    batchId: string | null;
    retry: RunExecutionRetry;
    review?: RunReview | null;
    /**
     * Pending in-flight human review when the run is waiting on a reviewer.
     */
    humanReview?: RunHumanReviewSummary | null;
    /**
     * Slim per-step rows (`id`, name, type, status, timing, order, capped error excerpt). Full `input`/`output` live on `GET /api/v1/runs/{id}/steps/{stepExecutionId}`.
     */
    steps: Array<unknown>;
    /**
     * Child invoke-workflow runs and their steps (`expand=execution`, workflow runs only). Omitted when there are no children.
     */
    childExecutions?: Array<unknown>;
    /**
     * Workflow definition snapshot captured when the run was created (`expand=execution`).
     */
    definitionSnapshot?: unknown | null;
    /**
     * Ground-truth expected output and files.
     */
    expected?: {
        output?: unknown;
        files?: Array<RunFile>;
    };
};

export type RunReview = {
    id: string;
    verdict: 'correct' | 'incorrect' | null;
    status: 'open' | 'closed' | 'wont_fix';
    note: string;
    correctedOutput?: unknown | null;
    /**
     * User id of the last reviewer. Read-only; set from the authenticated user or API key creator.
     */
    reviewedBy: string | null;
    /**
     * Email of the last reviewer. Read-only; set from the authenticated user or API key creator.
     */
    reviewedByEmail: string | null;
    reviewedAt: string;
    /**
     * User id recorded when the review was closed. Read-only; set when status becomes closed or wont_fix.
     */
    closedBy: string | null;
    /**
     * Email recorded when the review was closed. Read-only; set when status becomes closed or wont_fix.
     */
    closedByEmail: string | null;
    closedAt: string | null;
    closedNote: string | null;
    createdAt: string;
    updatedAt: string;
    corrections: Array<RunReviewCorrection>;
};

export type RunReviewCorrection = {
    id: string;
    kind: 'field' | 'file';
    /**
     * JSON Pointer for field corrections, or canonical artifact path for file reviews.
     */
    path: string;
    label: string | null;
    originalValue?: unknown | null;
    correctedValue?: unknown | null;
    note: string;
    correctedArtifactPath?: string | null;
    createdAt: string;
    updatedAt: string;
};

export type AgentRunExecution = {
    /**
     * Status of this run. `retry.nextRun.status` is a later retry, not this run.
     */
    status: ExecutionStatus;
    /**
     * Whether the completed output matched the workflow or agent output schema.
     */
    schemaValid: boolean | null;
    /**
     * Experiment batch id when the run is part of a batch.
     */
    batchId: string | null;
    retry: RunExecutionRetry;
    review?: RunReview | null;
    /**
     * Pending in-flight human review when the run is waiting on a reviewer.
     */
    humanReview?: RunHumanReviewSummary | null;
    files: {
        /**
         * Output artifacts the agent produced.
         */
        output: Array<RunFile>;
    };
    /**
     * Ground-truth expected output and files.
     */
    expected?: {
        output?: unknown;
        files?: Array<RunFile>;
    };
    /**
     * Expected-vs-actual comparison for eval runs (terminal runs only).
     */
    comparison?: unknown;
};

export type RunDebug = {
    /**
     * Execution phase timeline and structured failure.
     */
    observability: unknown;
    /**
     * Workflow trace id for span lookup (workflow runs only).
     */
    traceId?: string | null;
};

export type RunAccepted = {
    id: string;
    type: 'workflow' | 'agent';
    finished: false;
    source?: RunSource;
};

export type RunArtifactsResponse = {
    artifacts: Array<RunArtifact>;
};

export type RunCancelResponse = {
    id: string;
    type: 'workflow' | 'agent';
    /**
     * True when the run has reached a terminal status.
     */
    finished: boolean;
    execution: {
        status: ExecutionStatus;
    };
    cancellation: {
        /**
         * `cancelled` — the run was terminated immediately (it had not started). `requested` — the run is in-flight; cancellation was requested and the status will become `cancelled` shortly. `already_terminal` — the run had already finished; nothing changed.
         */
        state: 'cancelled' | 'requested' | 'already_terminal';
        /**
         * Run status at the time the cancel request was received.
         */
        wasStatus: ExecutionStatus;
    };
};

export type RunEventsResponse = {
    events: Array<RunEvent>;
};

export type RunEvent = {
    type: string;
    timestamp: string;
    status?: string | null;
    message?: string | null;
    metadata?: {
        [key: string]: unknown;
    };
};

export type PromoteRunResponse = {
    /**
     * Automation that owns the promoted example.
     */
    automationId: string;
    /**
     * Implementation type behind the automation.
     */
    automationType: 'workflow' | 'agent';
    /**
     * Dataset example identifier returned for follow-up API calls.
     */
    exampleId: string;
    /**
     * Dataset example name.
     */
    name: string | null;
};

export type RunReviewDetail = {
    /**
     * Review metadata and corrections. Corrected files are listed separately at GET /runs/{id}/reviews/expected.
     */
    review: RunReview | null;
};

export type RunReviewExpectedArtifacts = {
    /**
     * Corrected artifact files attached to the run review. Corrected JSON output lives on the review object at GET /runs/{id}/reviews.
     */
    files: Array<RunFile>;
};

/**
 * Corrected file created or renamed by the request.
 */
export type RunReviewExpectedFileMutationResponse = RunFile;

/**
 * Corrected file after the rename.
 */
export type RunReviewExpectedFileUpdateResponse = RunFile;

/**
 * Automated evaluator results attached to a run.
 */
export type RunScoresResponse = {
    /**
     * Automated evaluator scores for the run. These are separate from human review verdicts.
     */
    scores: Array<EvalResult>;
};

export type RunStepsResponse = {
    steps: Array<unknown>;
    total: number;
};

export type RunStepDetailResponse = unknown;

export type RunTraceResponse = {
    /**
     * Chronological trace events. Workflow runs return observability phases or step executions; agent runs return parsed trace.jsonl events.
     */
    events: Array<RunTraceEvent>;
};

/**
 * Trace event emitted by a workflow or agent run. Extra fields depend on the run type and event source.
 */
export type RunTraceEvent = {
    /**
     * Event type when present. Agent traces mirror trace.jsonl events; workflow traces use execution phase or step records.
     */
    type?: string;
    /**
     * Workflow execution phase, when present.
     */
    phase?: string;
    /**
     * Workflow step name, when present.
     */
    stepName?: string;
    /**
     * Event or execution status, when present.
     */
    status?: string;
    /**
     * Event start timestamp.
     */
    startedAt?: string | null;
    /**
     * Event completion timestamp.
     */
    completedAt?: string | null;
    /**
     * Human-readable event message.
     */
    message?: string | null;
    [key: string]: unknown;
};

export type RunUsageResponse = {
    usage: RunUsage | null;
};

export type ListTemplatesResponse = {
    items: Array<Template>;
    total: number;
};

export type Template = {
    /**
     * Stable logical template id (tmpl_…).
     */
    id: string;
    name: string;
    description?: string | null;
    filename: string;
    format: 'docx' | 'xlsx';
    mimeType: string;
    size?: number | null;
    sha256?: string | null;
    tokens: Array<{
        name: string;
        path?: Array<string>;
        kind?: 'variable' | 'loop';
        type?: 'string' | 'number' | 'date' | 'boolean' | 'array' | 'object';
        required?: boolean;
        description?: string;
    }>;
    grammar: {
        syntax: string;
        tokenDiscovery: boolean;
        capabilities: Array<string>;
    };
    currentRevision?: TemplateRevision | null;
    createdAt: string;
    updatedAt?: string | null;
};

export type TemplateRevision = {
    /**
     * Immutable template revision id (tmpr_…).
     */
    id: string;
    number: number;
    sha256: string;
    createdAt: string;
};

export type CreatedTemplate = {
    /**
     * Stable logical template id (tmpl_…).
     */
    id: string;
    name: string;
    description?: string | null;
    filename: string;
    format: 'docx' | 'xlsx';
    mimeType: string;
    size?: number | null;
    sha256?: string | null;
    tokens: Array<{
        name: string;
        path?: Array<string>;
        kind?: 'variable' | 'loop';
        type?: 'string' | 'number' | 'date' | 'boolean' | 'array' | 'object';
        required?: boolean;
        description?: string;
    }>;
    grammar: {
        syntax: string;
        tokenDiscovery: boolean;
        capabilities: Array<string>;
    };
    currentRevision?: TemplateRevision | null;
    createdAt: string;
    updatedAt?: string | null;
    /**
     * One-time proof to finalize or hard-clean this unpublished staged template. Returned only on staged create, never on GET or list.
     */
    cleanupProof?: string;
};

export type DeleteTemplateResponse = {
    deleted: boolean;
};

export type TemplateStagingResponse = {
    cleaned?: boolean;
    finalized?: boolean;
};

export type AuthCheckData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/v1/auth/check';
};

export type AuthCheckErrors = {
    /**
     * Validation error. Request shape did not match the spec.
     */
    400: ApiErrorEnvelope;
    /**
     * Missing or invalid API key
     */
    401: ApiErrorEnvelope;
    /**
     * API key lacks required scope
     */
    403: ApiErrorEnvelope;
    /**
     * Resource not found
     */
    404: ApiErrorEnvelope;
    /**
     * Payload too large. Upload exceeded the per-request size cap.
     */
    413: ApiErrorEnvelope;
    /**
     * Rate limit exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * Internal server error
     */
    500: ApiErrorEnvelope;
};

export type AuthCheckError = AuthCheckErrors[keyof AuthCheckErrors];

export type AuthCheckResponses = {
    /**
     * Authenticated identity
     */
    200: AuthCheckResponse;
};

export type AuthCheckResponse2 = AuthCheckResponses[keyof AuthCheckResponses];

export type AutomationsListData = {
    body?: never;
    path?: never;
    query?: {
        /**
         * Substring match against slug, name, or description
         */
        search?: string;
        /**
         * Filter by implementation type
         */
        type?: 'workflow' | 'agent';
        /**
         * Filter YAML workflows by folder. A folder id matches that folder; `null` matches unfiled workflows at root. Agent automations have no folders, so this filter excludes them. Cannot be combined with `type=agent`.
         */
        folderId?: string;
        /**
         * Maximum number of automations to return.
         */
        limit?: number;
        /**
         * Zero-based offset for paging through automations.
         */
        offset?: number;
    };
    url: '/v1/automations';
};

export type AutomationsListErrors = {
    /**
     * Validation error. Request shape did not match the spec.
     */
    400: ApiErrorEnvelope;
    /**
     * Missing or invalid API key
     */
    401: ApiErrorEnvelope;
    /**
     * API key lacks required scope
     */
    403: ApiErrorEnvelope;
    /**
     * Resource not found
     */
    404: ApiErrorEnvelope;
    /**
     * Payload too large. Upload exceeded the per-request size cap.
     */
    413: ApiErrorEnvelope;
    /**
     * Rate limit exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * Internal server error
     */
    500: ApiErrorEnvelope;
};

export type AutomationsListError = AutomationsListErrors[keyof AutomationsListErrors];

export type AutomationsListResponses = {
    /**
     * Page of runnable workflow and agent automations.
     */
    200: ListAutomationsResponse;
};

export type AutomationsListResponse = AutomationsListResponses[keyof AutomationsListResponses];

export type AutomationsDeleteData = {
    body?: never;
    path: {
        /**
         * Workflow id, agent id, or typed alias like workflows.slug / agents.slug
         */
        id: string;
    };
    query?: never;
    url: '/v1/automations/{id}';
};

export type AutomationsDeleteErrors = {
    /**
     * Validation error. Request shape did not match the spec.
     */
    400: ApiErrorEnvelope;
    /**
     * Missing or invalid API key
     */
    401: ApiErrorEnvelope;
    /**
     * API key lacks required scope
     */
    403: ApiErrorEnvelope;
    /**
     * Resource not found
     */
    404: ApiErrorEnvelope;
    /**
     * Payload too large. Upload exceeded the per-request size cap.
     */
    413: ApiErrorEnvelope;
    /**
     * Rate limit exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * Internal server error
     */
    500: ApiErrorEnvelope;
};

export type AutomationsDeleteError = AutomationsDeleteErrors[keyof AutomationsDeleteErrors];

export type AutomationsDeleteResponses = {
    /**
     * Automation deleted
     */
    200: DeleteAutomationResponse;
};

export type AutomationsDeleteResponse = AutomationsDeleteResponses[keyof AutomationsDeleteResponses];

export type AutomationsGetData = {
    body?: never;
    path: {
        /**
         * Workflow id, agent id, or typed alias like workflows.slug / agents.slug
         */
        id: string;
    };
    query?: never;
    url: '/v1/automations/{id}';
};

export type AutomationsGetErrors = {
    /**
     * Validation error. Request shape did not match the spec.
     */
    400: ApiErrorEnvelope;
    /**
     * Missing or invalid API key
     */
    401: ApiErrorEnvelope;
    /**
     * API key lacks required scope
     */
    403: ApiErrorEnvelope;
    /**
     * Resource not found
     */
    404: ApiErrorEnvelope;
    /**
     * Payload too large. Upload exceeded the per-request size cap.
     */
    413: ApiErrorEnvelope;
    /**
     * Rate limit exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * Internal server error
     */
    500: ApiErrorEnvelope;
};

export type AutomationsGetError = AutomationsGetErrors[keyof AutomationsGetErrors];

export type AutomationsGetResponses = {
    /**
     * Automation
     */
    200: AutomationDetail;
};

export type AutomationsGetResponse = AutomationsGetResponses[keyof AutomationsGetResponses];

export type AutomationsUpdateData = {
    body: UpdateAutomationRequest;
    path: {
        /**
         * Workflow id, agent id, or typed alias like workflows.slug / agents.slug
         */
        id: string;
    };
    query?: never;
    url: '/v1/automations/{id}';
};

export type AutomationsUpdateErrors = {
    /**
     * Validation error. Request shape did not match the spec.
     */
    400: ApiErrorEnvelope;
    /**
     * Missing or invalid API key
     */
    401: ApiErrorEnvelope;
    /**
     * API key lacks required scope
     */
    403: ApiErrorEnvelope;
    /**
     * Resource not found
     */
    404: ApiErrorEnvelope;
    /**
     * Payload too large. Upload exceeded the per-request size cap.
     */
    413: ApiErrorEnvelope;
    /**
     * Rate limit exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * Internal server error
     */
    500: ApiErrorEnvelope;
};

export type AutomationsUpdateError = AutomationsUpdateErrors[keyof AutomationsUpdateErrors];

export type AutomationsUpdateResponses = {
    /**
     * Updated automation
     */
    200: AutomationDetail;
};

export type AutomationsUpdateResponse = AutomationsUpdateResponses[keyof AutomationsUpdateResponses];

export type AutomationsDatasetExportData = {
    body?: never;
    path: {
        /**
         * Automation id or typed alias.
         */
        id: string;
    };
    query?: {
        /**
         * Optional comma-separated dataset example ids to export. Omit to export the full dataset.
         */
        exampleIds?: string;
    };
    url: '/v1/automations/{id}/dataset/export';
};

export type AutomationsDatasetExportErrors = {
    /**
     * Validation error. Request shape did not match the spec.
     */
    400: ApiErrorEnvelope;
    /**
     * Missing or invalid API key
     */
    401: ApiErrorEnvelope;
    /**
     * API key lacks required scope
     */
    403: ApiErrorEnvelope;
    /**
     * Resource not found
     */
    404: ApiErrorEnvelope;
    /**
     * Payload too large. Upload exceeded the per-request size cap.
     */
    413: ApiErrorEnvelope;
    /**
     * Rate limit exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * Internal server error
     */
    500: ApiErrorEnvelope;
};

export type AutomationsDatasetExportError = AutomationsDatasetExportErrors[keyof AutomationsDatasetExportErrors];

export type AutomationsDatasetExportResponses = {
    /**
     * ZIP archive
     */
    200: Blob | File;
};

export type AutomationsDatasetExportResponse = AutomationsDatasetExportResponses[keyof AutomationsDatasetExportResponses];

export type AutomationsDatasetImportData = {
    body: AutomationDatasetImportMultipartRequest;
    path: {
        /**
         * Automation id or typed alias.
         */
        id: string;
    };
    query?: never;
    url: '/v1/automations/{id}/dataset/import';
};

export type AutomationsDatasetImportErrors = {
    /**
     * Validation error. Request shape did not match the spec.
     */
    400: ApiErrorEnvelope;
    /**
     * Missing or invalid API key
     */
    401: ApiErrorEnvelope;
    /**
     * API key lacks required scope
     */
    403: ApiErrorEnvelope;
    /**
     * Resource not found
     */
    404: ApiErrorEnvelope;
    /**
     * Payload too large. Upload exceeded the per-request size cap.
     */
    413: ApiErrorEnvelope;
    /**
     * Rate limit exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * Internal server error
     */
    500: ApiErrorEnvelope;
};

export type AutomationsDatasetImportError = AutomationsDatasetImportErrors[keyof AutomationsDatasetImportErrors];

export type AutomationsDatasetImportResponses = {
    /**
     * Import result
     */
    200: DatasetImportResponse;
};

export type AutomationsDatasetImportResponse = AutomationsDatasetImportResponses[keyof AutomationsDatasetImportResponses];

export type AutomationsEvaluatorsGetData = {
    body?: never;
    path: {
        /**
         * Automation id or typed alias.
         */
        id: string;
    };
    query?: never;
    url: '/v1/automations/{id}/evaluators';
};

export type AutomationsEvaluatorsGetErrors = {
    /**
     * Validation error. Request shape did not match the spec.
     */
    400: ApiErrorEnvelope;
    /**
     * Missing or invalid API key
     */
    401: ApiErrorEnvelope;
    /**
     * API key lacks required scope
     */
    403: ApiErrorEnvelope;
    /**
     * Resource not found
     */
    404: ApiErrorEnvelope;
    /**
     * Payload too large. Upload exceeded the per-request size cap.
     */
    413: ApiErrorEnvelope;
    /**
     * Rate limit exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * Internal server error
     */
    500: ApiErrorEnvelope;
};

export type AutomationsEvaluatorsGetError = AutomationsEvaluatorsGetErrors[keyof AutomationsEvaluatorsGetErrors];

export type AutomationsEvaluatorsGetResponses = {
    /**
     * Evaluator YAML and parsed configuration.
     */
    200: EvaluatorConfigResponse;
};

export type AutomationsEvaluatorsGetResponse = AutomationsEvaluatorsGetResponses[keyof AutomationsEvaluatorsGetResponses];

export type AutomationsEvaluatorsUpdateData = {
    body: EvaluatorConfigUpdate;
    path: {
        /**
         * Automation id or typed alias.
         */
        id: string;
    };
    query?: never;
    url: '/v1/automations/{id}/evaluators';
};

export type AutomationsEvaluatorsUpdateErrors = {
    /**
     * Validation error. Request shape did not match the spec.
     */
    400: ApiErrorEnvelope;
    /**
     * Missing or invalid API key
     */
    401: ApiErrorEnvelope;
    /**
     * API key lacks required scope
     */
    403: ApiErrorEnvelope;
    /**
     * Resource not found
     */
    404: ApiErrorEnvelope;
    /**
     * Payload too large. Upload exceeded the per-request size cap.
     */
    413: ApiErrorEnvelope;
    /**
     * Rate limit exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * Internal server error
     */
    500: ApiErrorEnvelope;
};

export type AutomationsEvaluatorsUpdateError = AutomationsEvaluatorsUpdateErrors[keyof AutomationsEvaluatorsUpdateErrors];

export type AutomationsEvaluatorsUpdateResponses = {
    /**
     * Updated evaluator YAML and parsed configuration.
     */
    200: EvaluatorConfigResponse;
};

export type AutomationsEvaluatorsUpdateResponse = AutomationsEvaluatorsUpdateResponses[keyof AutomationsEvaluatorsUpdateResponses];

export type AutomationsExamplesListData = {
    body?: never;
    path: {
        /**
         * Automation id or typed alias, such as `workflows.slug` or `agents.slug`.
         */
        id: string;
    };
    query?: {
        /**
         * Maximum number of examples to return.
         */
        limit?: number;
        /**
         * Zero-based offset for paging through examples.
         */
        offset?: number;
        /**
         * Response payload scope. `metadata` returns ids, names, metadata, and expected file refs without loading input or expected JSON.
         */
        include?: 'full' | 'metadata';
    };
    url: '/v1/automations/{id}/examples';
};

export type AutomationsExamplesListErrors = {
    /**
     * Validation error. Request shape did not match the spec.
     */
    400: ApiErrorEnvelope;
    /**
     * Missing or invalid API key
     */
    401: ApiErrorEnvelope;
    /**
     * API key lacks required scope
     */
    403: ApiErrorEnvelope;
    /**
     * Resource not found
     */
    404: ApiErrorEnvelope;
    /**
     * Payload too large. Upload exceeded the per-request size cap.
     */
    413: ApiErrorEnvelope;
    /**
     * Rate limit exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * Internal server error
     */
    500: ApiErrorEnvelope;
};

export type AutomationsExamplesListError = AutomationsExamplesListErrors[keyof AutomationsExamplesListErrors];

export type AutomationsExamplesListResponses = {
    /**
     * Page of dataset examples.
     */
    200: DatasetExampleList;
};

export type AutomationsExamplesListResponse = AutomationsExamplesListResponses[keyof AutomationsExamplesListResponses];

export type AutomationsExamplesCreateData = {
    body: DatasetExampleMutation;
    path: {
        /**
         * Automation id or typed alias, such as `workflows.slug` or `agents.slug`.
         */
        id: string;
    };
    query?: never;
    url: '/v1/automations/{id}/examples';
};

export type AutomationsExamplesCreateErrors = {
    /**
     * Validation error. Request shape did not match the spec.
     */
    400: ApiErrorEnvelope;
    /**
     * Missing or invalid API key
     */
    401: ApiErrorEnvelope;
    /**
     * API key lacks required scope
     */
    403: ApiErrorEnvelope;
    /**
     * Resource not found
     */
    404: ApiErrorEnvelope;
    /**
     * Payload too large. Upload exceeded the per-request size cap.
     */
    413: ApiErrorEnvelope;
    /**
     * Rate limit exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * Internal server error
     */
    500: ApiErrorEnvelope;
};

export type AutomationsExamplesCreateError = AutomationsExamplesCreateErrors[keyof AutomationsExamplesCreateErrors];

export type AutomationsExamplesCreateResponses = {
    /**
     * Created dataset example.
     */
    201: DatasetExample;
};

export type AutomationsExamplesCreateResponse = AutomationsExamplesCreateResponses[keyof AutomationsExamplesCreateResponses];

export type AutomationsExamplesDeleteData = {
    body?: never;
    path: {
        /**
         * Automation id or typed alias.
         */
        id: string;
        /**
         * Dataset example id. Agent examples may use deterministic name-derived ids returned by list/create responses.
         */
        exampleId: string;
    };
    query?: never;
    url: '/v1/automations/{id}/examples/{exampleId}';
};

export type AutomationsExamplesDeleteErrors = {
    /**
     * Validation error. Request shape did not match the spec.
     */
    400: ApiErrorEnvelope;
    /**
     * Missing or invalid API key
     */
    401: ApiErrorEnvelope;
    /**
     * API key lacks required scope
     */
    403: ApiErrorEnvelope;
    /**
     * Resource not found
     */
    404: ApiErrorEnvelope;
    /**
     * Payload too large. Upload exceeded the per-request size cap.
     */
    413: ApiErrorEnvelope;
    /**
     * Rate limit exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * Internal server error
     */
    500: ApiErrorEnvelope;
};

export type AutomationsExamplesDeleteError = AutomationsExamplesDeleteErrors[keyof AutomationsExamplesDeleteErrors];

export type AutomationsExamplesDeleteResponses = {
    /**
     * Deleted dataset example.
     */
    200: DatasetExample;
};

export type AutomationsExamplesDeleteResponse = AutomationsExamplesDeleteResponses[keyof AutomationsExamplesDeleteResponses];

export type AutomationsExamplesGetData = {
    body?: never;
    path: {
        /**
         * Automation id or typed alias.
         */
        id: string;
        /**
         * Dataset example id. Agent examples may use deterministic name-derived ids returned by list/create responses.
         */
        exampleId: string;
    };
    query?: never;
    url: '/v1/automations/{id}/examples/{exampleId}';
};

export type AutomationsExamplesGetErrors = {
    /**
     * Validation error. Request shape did not match the spec.
     */
    400: ApiErrorEnvelope;
    /**
     * Missing or invalid API key
     */
    401: ApiErrorEnvelope;
    /**
     * API key lacks required scope
     */
    403: ApiErrorEnvelope;
    /**
     * Resource not found
     */
    404: ApiErrorEnvelope;
    /**
     * Payload too large. Upload exceeded the per-request size cap.
     */
    413: ApiErrorEnvelope;
    /**
     * Rate limit exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * Internal server error
     */
    500: ApiErrorEnvelope;
};

export type AutomationsExamplesGetError = AutomationsExamplesGetErrors[keyof AutomationsExamplesGetErrors];

export type AutomationsExamplesGetResponses = {
    /**
     * Dataset example.
     */
    200: DatasetExample;
};

export type AutomationsExamplesGetResponse = AutomationsExamplesGetResponses[keyof AutomationsExamplesGetResponses];

export type AutomationsExamplesUpdateData = {
    body: DatasetExampleUpdate;
    path: {
        /**
         * Automation id or typed alias.
         */
        id: string;
        /**
         * Dataset example id. Agent examples may use deterministic name-derived ids returned by list/create responses.
         */
        exampleId: string;
    };
    query?: never;
    url: '/v1/automations/{id}/examples/{exampleId}';
};

export type AutomationsExamplesUpdateErrors = {
    /**
     * Validation error. Request shape did not match the spec.
     */
    400: ApiErrorEnvelope;
    /**
     * Missing or invalid API key
     */
    401: ApiErrorEnvelope;
    /**
     * API key lacks required scope
     */
    403: ApiErrorEnvelope;
    /**
     * Resource not found
     */
    404: ApiErrorEnvelope;
    /**
     * Payload too large. Upload exceeded the per-request size cap.
     */
    413: ApiErrorEnvelope;
    /**
     * Rate limit exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * Internal server error
     */
    500: ApiErrorEnvelope;
};

export type AutomationsExamplesUpdateError = AutomationsExamplesUpdateErrors[keyof AutomationsExamplesUpdateErrors];

export type AutomationsExamplesUpdateResponses = {
    /**
     * Updated dataset example.
     */
    200: DatasetExample;
};

export type AutomationsExamplesUpdateResponse = AutomationsExamplesUpdateResponses[keyof AutomationsExamplesUpdateResponses];

export type AutomationsExamplesExpectedFilesListData = {
    body?: never;
    path: {
        /**
         * Automation id or typed alias.
         */
        id: string;
        /**
         * Dataset example id.
         */
        exampleId: string;
    };
    query?: never;
    url: '/v1/automations/{id}/examples/{exampleId}/expected';
};

export type AutomationsExamplesExpectedFilesListErrors = {
    /**
     * Validation error. Request shape did not match the spec.
     */
    400: ApiErrorEnvelope;
    /**
     * Missing or invalid API key
     */
    401: ApiErrorEnvelope;
    /**
     * API key lacks required scope
     */
    403: ApiErrorEnvelope;
    /**
     * Resource not found
     */
    404: ApiErrorEnvelope;
    /**
     * Payload too large. Upload exceeded the per-request size cap.
     */
    413: ApiErrorEnvelope;
    /**
     * Rate limit exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * Internal server error
     */
    500: ApiErrorEnvelope;
};

export type AutomationsExamplesExpectedFilesListError = AutomationsExamplesExpectedFilesListErrors[keyof AutomationsExamplesExpectedFilesListErrors];

export type AutomationsExamplesExpectedFilesListResponses = {
    /**
     * Expected file paths.
     */
    200: DatasetExampleExpectedFileList;
};

export type AutomationsExamplesExpectedFilesListResponse = AutomationsExamplesExpectedFilesListResponses[keyof AutomationsExamplesExpectedFilesListResponses];

export type AutomationsExamplesExpectedFilesCreateData = {
    body: DatasetExampleExpectedFileUploadRequest;
    path: {
        /**
         * Automation id or typed alias.
         */
        id: string;
        /**
         * Dataset example id.
         */
        exampleId: string;
    };
    query?: never;
    url: '/v1/automations/{id}/examples/{exampleId}/expected';
};

export type AutomationsExamplesExpectedFilesCreateErrors = {
    /**
     * Validation error. Request shape did not match the spec.
     */
    400: ApiErrorEnvelope;
    /**
     * Missing or invalid API key
     */
    401: ApiErrorEnvelope;
    /**
     * API key lacks required scope
     */
    403: ApiErrorEnvelope;
    /**
     * Resource not found
     */
    404: ApiErrorEnvelope;
    /**
     * Payload too large. Upload exceeded the per-request size cap.
     */
    413: ApiErrorEnvelope;
    /**
     * Rate limit exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * Internal server error
     */
    500: ApiErrorEnvelope;
};

export type AutomationsExamplesExpectedFilesCreateError = AutomationsExamplesExpectedFilesCreateErrors[keyof AutomationsExamplesExpectedFilesCreateErrors];

export type AutomationsExamplesExpectedFilesCreateResponses = {
    /**
     * Uploaded expected files.
     */
    201: DatasetExampleExpectedFileUploadResponse;
};

export type AutomationsExamplesExpectedFilesCreateResponse = AutomationsExamplesExpectedFilesCreateResponses[keyof AutomationsExamplesExpectedFilesCreateResponses];

export type AutomationsExamplesExpectedFileDeleteData = {
    body?: never;
    path: {
        /**
         * Automation id or typed alias.
         */
        id: string;
        /**
         * Dataset example id.
         */
        exampleId: string;
        /**
         * Path under the example expected folder.
         */
        path: string;
    };
    query?: never;
    url: '/v1/automations/{id}/examples/{exampleId}/expected/{path}';
};

export type AutomationsExamplesExpectedFileDeleteErrors = {
    /**
     * Validation error. Request shape did not match the spec.
     */
    400: ApiErrorEnvelope;
    /**
     * Missing or invalid API key
     */
    401: ApiErrorEnvelope;
    /**
     * API key lacks required scope
     */
    403: ApiErrorEnvelope;
    /**
     * Resource not found
     */
    404: ApiErrorEnvelope;
    /**
     * Payload too large. Upload exceeded the per-request size cap.
     */
    413: ApiErrorEnvelope;
    /**
     * Rate limit exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * Internal server error
     */
    500: ApiErrorEnvelope;
};

export type AutomationsExamplesExpectedFileDeleteError = AutomationsExamplesExpectedFileDeleteErrors[keyof AutomationsExamplesExpectedFileDeleteErrors];

export type AutomationsExamplesExpectedFileDeleteResponses = {
    /**
     * Expected file deleted.
     */
    200: unknown;
};

export type AutomationsExamplesExpectedFileGetData = {
    body?: never;
    path: {
        /**
         * Automation id or typed alias.
         */
        id: string;
        /**
         * Dataset example id.
         */
        exampleId: string;
        /**
         * Path under the example expected folder.
         */
        path: string;
    };
    query?: never;
    url: '/v1/automations/{id}/examples/{exampleId}/expected/{path}';
};

export type AutomationsExamplesExpectedFileGetErrors = {
    /**
     * Validation error. Request shape did not match the spec.
     */
    400: ApiErrorEnvelope;
    /**
     * Missing or invalid API key
     */
    401: ApiErrorEnvelope;
    /**
     * API key lacks required scope
     */
    403: ApiErrorEnvelope;
    /**
     * Resource not found
     */
    404: ApiErrorEnvelope;
    /**
     * Payload too large. Upload exceeded the per-request size cap.
     */
    413: ApiErrorEnvelope;
    /**
     * Rate limit exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * Internal server error
     */
    500: ApiErrorEnvelope;
};

export type AutomationsExamplesExpectedFileGetError = AutomationsExamplesExpectedFileGetErrors[keyof AutomationsExamplesExpectedFileGetErrors];

export type AutomationsExamplesExpectedFileGetResponses = {
    /**
     * Expected file bytes.
     */
    200: Blob | File;
};

export type AutomationsExamplesExpectedFileGetResponse = AutomationsExamplesExpectedFileGetResponses[keyof AutomationsExamplesExpectedFileGetResponses];

export type AutomationsExamplesExpectedFileUpdateData = {
    body: DatasetExampleExpectedFileRenameRequest;
    path: {
        /**
         * Automation id or typed alias.
         */
        id: string;
        /**
         * Dataset example id.
         */
        exampleId: string;
        /**
         * Path under the example expected folder.
         */
        path: string;
    };
    query?: never;
    url: '/v1/automations/{id}/examples/{exampleId}/expected/{path}';
};

export type AutomationsExamplesExpectedFileUpdateErrors = {
    /**
     * Validation error. Request shape did not match the spec.
     */
    400: ApiErrorEnvelope;
    /**
     * Missing or invalid API key
     */
    401: ApiErrorEnvelope;
    /**
     * API key lacks required scope
     */
    403: ApiErrorEnvelope;
    /**
     * Resource not found
     */
    404: ApiErrorEnvelope;
    /**
     * Payload too large. Upload exceeded the per-request size cap.
     */
    413: ApiErrorEnvelope;
    /**
     * Rate limit exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * Internal server error
     */
    500: ApiErrorEnvelope;
};

export type AutomationsExamplesExpectedFileUpdateError = AutomationsExamplesExpectedFileUpdateErrors[keyof AutomationsExamplesExpectedFileUpdateErrors];

export type AutomationsExamplesExpectedFileUpdateResponses = {
    /**
     * Renamed expected file.
     */
    200: DatasetExampleExpectedFileRenameResponse;
};

export type AutomationsExamplesExpectedFileUpdateResponse = AutomationsExamplesExpectedFileUpdateResponses[keyof AutomationsExamplesExpectedFileUpdateResponses];

export type AutomationsExamplesInputFilesListData = {
    body?: never;
    path: {
        /**
         * Automation id or typed alias.
         */
        id: string;
        /**
         * Dataset example id.
         */
        exampleId: string;
    };
    query?: never;
    url: '/v1/automations/{id}/examples/{exampleId}/input';
};

export type AutomationsExamplesInputFilesListErrors = {
    /**
     * Validation error. Request shape did not match the spec.
     */
    400: ApiErrorEnvelope;
    /**
     * Missing or invalid API key
     */
    401: ApiErrorEnvelope;
    /**
     * API key lacks required scope
     */
    403: ApiErrorEnvelope;
    /**
     * Resource not found
     */
    404: ApiErrorEnvelope;
    /**
     * Payload too large. Upload exceeded the per-request size cap.
     */
    413: ApiErrorEnvelope;
    /**
     * Rate limit exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * Internal server error
     */
    500: ApiErrorEnvelope;
};

export type AutomationsExamplesInputFilesListError = AutomationsExamplesInputFilesListErrors[keyof AutomationsExamplesInputFilesListErrors];

export type AutomationsExamplesInputFilesListResponses = {
    /**
     * Input file paths.
     */
    200: DatasetExampleInputFileList;
};

export type AutomationsExamplesInputFilesListResponse = AutomationsExamplesInputFilesListResponses[keyof AutomationsExamplesInputFilesListResponses];

export type AutomationsExamplesInputFilesCreateData = {
    body: DatasetExampleInputFileUploadRequest;
    path: {
        /**
         * Automation id or typed alias.
         */
        id: string;
        /**
         * Dataset example id.
         */
        exampleId: string;
    };
    query?: never;
    url: '/v1/automations/{id}/examples/{exampleId}/input';
};

export type AutomationsExamplesInputFilesCreateErrors = {
    /**
     * Validation error. Request shape did not match the spec.
     */
    400: ApiErrorEnvelope;
    /**
     * Missing or invalid API key
     */
    401: ApiErrorEnvelope;
    /**
     * API key lacks required scope
     */
    403: ApiErrorEnvelope;
    /**
     * Resource not found
     */
    404: ApiErrorEnvelope;
    /**
     * Payload too large. Upload exceeded the per-request size cap.
     */
    413: ApiErrorEnvelope;
    /**
     * Rate limit exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * Internal server error
     */
    500: ApiErrorEnvelope;
};

export type AutomationsExamplesInputFilesCreateError = AutomationsExamplesInputFilesCreateErrors[keyof AutomationsExamplesInputFilesCreateErrors];

export type AutomationsExamplesInputFilesCreateResponses = {
    /**
     * Uploaded input files.
     */
    201: DatasetExampleInputFileUploadResponse;
};

export type AutomationsExamplesInputFilesCreateResponse = AutomationsExamplesInputFilesCreateResponses[keyof AutomationsExamplesInputFilesCreateResponses];

export type AutomationsExamplesInputFileDeleteData = {
    body?: never;
    path: {
        /**
         * Automation id or typed alias.
         */
        id: string;
        /**
         * Dataset example id.
         */
        exampleId: string;
        /**
         * Slash-delimited path under the example input folder.
         */
        path: string;
    };
    query?: never;
    url: '/v1/automations/{id}/examples/{exampleId}/input/{path}';
};

export type AutomationsExamplesInputFileDeleteErrors = {
    /**
     * Validation error. Request shape did not match the spec.
     */
    400: ApiErrorEnvelope;
    /**
     * Missing or invalid API key
     */
    401: ApiErrorEnvelope;
    /**
     * API key lacks required scope
     */
    403: ApiErrorEnvelope;
    /**
     * Resource not found
     */
    404: ApiErrorEnvelope;
    /**
     * Payload too large. Upload exceeded the per-request size cap.
     */
    413: ApiErrorEnvelope;
    /**
     * Rate limit exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * Internal server error
     */
    500: ApiErrorEnvelope;
};

export type AutomationsExamplesInputFileDeleteError = AutomationsExamplesInputFileDeleteErrors[keyof AutomationsExamplesInputFileDeleteErrors];

export type AutomationsExamplesInputFileDeleteResponses = {
    /**
     * Input file deleted.
     */
    200: unknown;
};

export type AutomationsExamplesInputFileGetData = {
    body?: never;
    path: {
        /**
         * Automation id or typed alias.
         */
        id: string;
        /**
         * Dataset example id.
         */
        exampleId: string;
        /**
         * Slash-delimited path under the example input folder.
         */
        path: string;
    };
    query?: never;
    url: '/v1/automations/{id}/examples/{exampleId}/input/{path}';
};

export type AutomationsExamplesInputFileGetErrors = {
    /**
     * Validation error. Request shape did not match the spec.
     */
    400: ApiErrorEnvelope;
    /**
     * Missing or invalid API key
     */
    401: ApiErrorEnvelope;
    /**
     * API key lacks required scope
     */
    403: ApiErrorEnvelope;
    /**
     * Resource not found
     */
    404: ApiErrorEnvelope;
    /**
     * Payload too large. Upload exceeded the per-request size cap.
     */
    413: ApiErrorEnvelope;
    /**
     * Rate limit exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * Internal server error
     */
    500: ApiErrorEnvelope;
};

export type AutomationsExamplesInputFileGetError = AutomationsExamplesInputFileGetErrors[keyof AutomationsExamplesInputFileGetErrors];

export type AutomationsExamplesInputFileGetResponses = {
    /**
     * Input file bytes.
     */
    200: Blob | File;
};

export type AutomationsExamplesInputFileGetResponse = AutomationsExamplesInputFileGetResponses[keyof AutomationsExamplesInputFileGetResponses];

export type AutomationsExamplesInputFileUpdateData = {
    body: DatasetExampleInputFileRenameRequest;
    path: {
        /**
         * Automation id or typed alias.
         */
        id: string;
        /**
         * Dataset example id.
         */
        exampleId: string;
        /**
         * Slash-delimited path under the example input folder.
         */
        path: string;
    };
    query?: never;
    url: '/v1/automations/{id}/examples/{exampleId}/input/{path}';
};

export type AutomationsExamplesInputFileUpdateErrors = {
    /**
     * Validation error. Request shape did not match the spec.
     */
    400: ApiErrorEnvelope;
    /**
     * Missing or invalid API key
     */
    401: ApiErrorEnvelope;
    /**
     * API key lacks required scope
     */
    403: ApiErrorEnvelope;
    /**
     * Resource not found
     */
    404: ApiErrorEnvelope;
    /**
     * Payload too large. Upload exceeded the per-request size cap.
     */
    413: ApiErrorEnvelope;
    /**
     * Rate limit exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * Internal server error
     */
    500: ApiErrorEnvelope;
};

export type AutomationsExamplesInputFileUpdateError = AutomationsExamplesInputFileUpdateErrors[keyof AutomationsExamplesInputFileUpdateErrors];

export type AutomationsExamplesInputFileUpdateResponses = {
    /**
     * Renamed input file.
     */
    200: DatasetExampleInputFileRenameResponse;
};

export type AutomationsExamplesInputFileUpdateResponse = AutomationsExamplesInputFileUpdateResponses[keyof AutomationsExamplesInputFileUpdateResponses];

export type AutomationsExamplesRunData = {
    body?: never;
    path: {
        /**
         * Automation id or typed alias.
         */
        id: string;
        /**
         * Dataset example id to run.
         */
        exampleId: string;
    };
    query?: never;
    url: '/v1/automations/{id}/examples/{exampleId}/run';
};

export type AutomationsExamplesRunErrors = {
    /**
     * Validation error. Request shape did not match the spec.
     */
    400: ApiErrorEnvelope;
    /**
     * Missing or invalid API key
     */
    401: ApiErrorEnvelope;
    /**
     * API key lacks required scope
     */
    403: ApiErrorEnvelope;
    /**
     * Resource not found
     */
    404: ApiErrorEnvelope;
    /**
     * Payload too large. Upload exceeded the per-request size cap.
     */
    413: ApiErrorEnvelope;
    /**
     * Rate limit exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * Internal server error
     */
    500: ApiErrorEnvelope;
};

export type AutomationsExamplesRunError = AutomationsExamplesRunErrors[keyof AutomationsExamplesRunErrors];

export type AutomationsExamplesRunResponses = {
    /**
     * Example run accepted
     */
    201: ExampleRunResponse;
};

export type AutomationsExamplesRunResponse = AutomationsExamplesRunResponses[keyof AutomationsExamplesRunResponses];

export type AutomationsExperimentsListData = {
    body?: never;
    path: {
        /**
         * Automation id or typed alias.
         */
        id: string;
    };
    query?: {
        /**
         * Maximum number of experiment batches to return.
         */
        limit?: number;
        /**
         * Zero-based offset for paging through experiment batches.
         */
        offset?: number;
        /**
         * Filter to experiment batches created at or after this date or relative date.
         */
        fromDate?: string;
        /**
         * Filter to experiment batches created at or before this date or relative date.
         */
        toDate?: string;
    };
    url: '/v1/automations/{id}/experiments';
};

export type AutomationsExperimentsListErrors = {
    /**
     * Validation error. Request shape did not match the spec.
     */
    400: ApiErrorEnvelope;
    /**
     * Missing or invalid API key
     */
    401: ApiErrorEnvelope;
    /**
     * API key lacks required scope
     */
    403: ApiErrorEnvelope;
    /**
     * Resource not found
     */
    404: ApiErrorEnvelope;
    /**
     * Payload too large. Upload exceeded the per-request size cap.
     */
    413: ApiErrorEnvelope;
    /**
     * Rate limit exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * Internal server error
     */
    500: ApiErrorEnvelope;
};

export type AutomationsExperimentsListError = AutomationsExperimentsListErrors[keyof AutomationsExperimentsListErrors];

export type AutomationsExperimentsListResponses = {
    /**
     * Page of experiment batches.
     */
    200: {
        data: Array<Experiment>;
        total: number;
        limit: number;
        offset: number;
    };
};

export type AutomationsExperimentsListResponse = AutomationsExperimentsListResponses[keyof AutomationsExperimentsListResponses];

export type AutomationsExperimentsCreateData = {
    body: ExperimentCreate;
    path: {
        /**
         * Automation id or typed alias.
         */
        id: string;
    };
    query?: never;
    url: '/v1/automations/{id}/experiments';
};

export type AutomationsExperimentsCreateErrors = {
    /**
     * Validation error. Request shape did not match the spec.
     */
    400: ApiErrorEnvelope;
    /**
     * Missing or invalid API key
     */
    401: ApiErrorEnvelope;
    /**
     * API key lacks required scope
     */
    403: ApiErrorEnvelope;
    /**
     * Resource not found
     */
    404: ApiErrorEnvelope;
    /**
     * Payload too large. Upload exceeded the per-request size cap.
     */
    413: ApiErrorEnvelope;
    /**
     * Rate limit exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * Internal server error
     */
    500: ApiErrorEnvelope;
};

export type AutomationsExperimentsCreateError = AutomationsExperimentsCreateErrors[keyof AutomationsExperimentsCreateErrors];

export type AutomationsExperimentsCreateResponses = {
    /**
     * Experiment accepted and runs enqueued.
     */
    202: ExperimentCreateResponse;
};

export type AutomationsExperimentsCreateResponse = AutomationsExperimentsCreateResponses[keyof AutomationsExperimentsCreateResponses];

export type AutomationsExperimentsGetData = {
    body?: never;
    path: {
        /**
         * Automation id or typed alias.
         */
        id: string;
        /**
         * Experiment batch id.
         */
        experimentId: string;
    };
    query?: never;
    url: '/v1/automations/{id}/experiments/{experimentId}';
};

export type AutomationsExperimentsGetErrors = {
    /**
     * Validation error. Request shape did not match the spec.
     */
    400: ApiErrorEnvelope;
    /**
     * Missing or invalid API key
     */
    401: ApiErrorEnvelope;
    /**
     * API key lacks required scope
     */
    403: ApiErrorEnvelope;
    /**
     * Resource not found
     */
    404: ApiErrorEnvelope;
    /**
     * Payload too large. Upload exceeded the per-request size cap.
     */
    413: ApiErrorEnvelope;
    /**
     * Rate limit exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * Internal server error
     */
    500: ApiErrorEnvelope;
};

export type AutomationsExperimentsGetError = AutomationsExperimentsGetErrors[keyof AutomationsExperimentsGetErrors];

export type AutomationsExperimentsGetResponses = {
    /**
     * Experiment detail with runs and results.
     */
    200: ExperimentDetail;
};

export type AutomationsExperimentsGetResponse = AutomationsExperimentsGetResponses[keyof AutomationsExperimentsGetResponses];

export type AutomationsExperimentsCancelData = {
    body?: never;
    path: {
        /**
         * Automation id or typed alias.
         */
        id: string;
        /**
         * Experiment batch id.
         */
        experimentId: string;
    };
    query?: never;
    url: '/v1/automations/{id}/experiments/{experimentId}/cancel';
};

export type AutomationsExperimentsCancelErrors = {
    /**
     * Validation error. Request shape did not match the spec.
     */
    400: ApiErrorEnvelope;
    /**
     * Missing or invalid API key
     */
    401: ApiErrorEnvelope;
    /**
     * API key lacks required scope
     */
    403: ApiErrorEnvelope;
    /**
     * Resource not found
     */
    404: ApiErrorEnvelope;
    /**
     * Payload too large. Upload exceeded the per-request size cap.
     */
    413: ApiErrorEnvelope;
    /**
     * Rate limit exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * Internal server error
     */
    500: ApiErrorEnvelope;
};

export type AutomationsExperimentsCancelError = AutomationsExperimentsCancelErrors[keyof AutomationsExperimentsCancelErrors];

export type AutomationsExperimentsCancelResponses = {
    /**
     * Experiment detail after the cancellation request.
     */
    200: ExperimentDetail;
};

export type AutomationsExperimentsCancelResponse = AutomationsExperimentsCancelResponses[keyof AutomationsExperimentsCancelResponses];

export type AutomationsExperimentsExportData = {
    body?: never;
    path: {
        id: string;
        experimentId: string;
    };
    query: {
        format: 'csv' | 'json';
        includeTrace?: '0' | '1' | 'true' | 'false';
    };
    url: '/v1/automations/{id}/experiments/{experimentId}/export';
};

export type AutomationsExperimentsExportErrors = {
    /**
     * Validation error. Request shape did not match the spec.
     */
    400: ApiErrorEnvelope;
    /**
     * Missing or invalid API key
     */
    401: ApiErrorEnvelope;
    /**
     * API key lacks required scope
     */
    403: ApiErrorEnvelope;
    /**
     * Resource not found
     */
    404: ApiErrorEnvelope;
    /**
     * Payload too large. Upload exceeded the per-request size cap.
     */
    413: ApiErrorEnvelope;
    /**
     * Rate limit exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * Internal server error
     */
    500: ApiErrorEnvelope;
};

export type AutomationsExperimentsExportError = AutomationsExperimentsExportErrors[keyof AutomationsExperimentsExportErrors];

export type AutomationsExperimentsExportResponses = {
    /**
     * CSV or JSON document
     */
    200: string;
};

export type AutomationsExperimentsExportResponse = AutomationsExperimentsExportResponses[keyof AutomationsExperimentsExportResponses];

export type AutomationsExperimentsExportAllData = {
    body?: never;
    path: {
        id: string;
    };
    query: {
        format: 'csv' | 'json';
    };
    url: '/v1/automations/{id}/experiments/export';
};

export type AutomationsExperimentsExportAllErrors = {
    /**
     * Validation error. Request shape did not match the spec.
     */
    400: ApiErrorEnvelope;
    /**
     * Missing or invalid API key
     */
    401: ApiErrorEnvelope;
    /**
     * API key lacks required scope
     */
    403: ApiErrorEnvelope;
    /**
     * Resource not found
     */
    404: ApiErrorEnvelope;
    /**
     * Payload too large. Upload exceeded the per-request size cap.
     */
    413: ApiErrorEnvelope;
    /**
     * Rate limit exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * Internal server error
     */
    500: ApiErrorEnvelope;
};

export type AutomationsExperimentsExportAllError = AutomationsExperimentsExportAllErrors[keyof AutomationsExperimentsExportAllErrors];

export type AutomationsExperimentsExportAllResponses = {
    /**
     * CSV or JSON document
     */
    200: string;
};

export type AutomationsExperimentsExportAllResponse = AutomationsExperimentsExportAllResponses[keyof AutomationsExperimentsExportAllResponses];

export type AutomationsExperimentsCreateStreamData = {
    body: ExperimentCreate;
    path: {
        id: string;
    };
    query?: never;
    url: '/v1/automations/{id}/experiments/stream';
};

export type AutomationsExperimentsCreateStreamErrors = {
    /**
     * Validation error. Request shape did not match the spec.
     */
    400: ApiErrorEnvelope;
    /**
     * Missing or invalid API key
     */
    401: ApiErrorEnvelope;
    /**
     * API key lacks required scope
     */
    403: ApiErrorEnvelope;
    /**
     * Resource not found
     */
    404: ApiErrorEnvelope;
    /**
     * Payload too large. Upload exceeded the per-request size cap.
     */
    413: ApiErrorEnvelope;
    /**
     * Rate limit exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * Internal server error
     */
    500: ApiErrorEnvelope;
};

export type AutomationsExperimentsCreateStreamError = AutomationsExperimentsCreateStreamErrors[keyof AutomationsExperimentsCreateStreamErrors];

export type AutomationsExperimentsCreateStreamResponses = {
    /**
     * application/x-ndjson event stream
     */
    200: string;
};

export type AutomationsExperimentsCreateStreamResponse = AutomationsExperimentsCreateStreamResponses[keyof AutomationsExperimentsCreateStreamResponses];

export type AutomationsReviewsHealthData = {
    body?: never;
    path: {
        /**
         * Workflow id, agent id, or typed alias like workflows.slug / agents.slug.
         */
        id: string;
    };
    query?: {
        /**
         * Comma-separated: workflow,agent.
         */
        type?: string;
        /**
         * Comma-separated execution statuses.
         */
        status?: string;
        /**
         * Comma-separated trigger types.
         */
        trigger?: string;
        /**
         * Comma-separated user ids, or __system__ for system-triggered runs.
         */
        triggeredBy?: string;
        sourceRef?: string;
        batchId?: string;
        exampleId?: string;
        exampleIdContains?: string;
        /**
         * Start of the run-created time range. Defaults to now-30d.
         */
        from?: string;
        /**
         * End of the run-created time range.
         */
        to?: string;
        completedAfter?: string;
        completedBefore?: string;
        /**
         * Set to false to exclude experiment batch runs.
         */
        experiments?: string;
        /**
         * Calendar bucket size for the bar chart series. Defaults to day.
         */
        bucket?: 'day' | 'week' | 'month';
        /**
         * Number of reviewed runs per rolling correctness point. Defaults to 100.
         */
        rollingWindow?: number;
        /**
         * Minimum reviewed runs required before emitting rolling points. Defaults to 1.
         */
        minRollingReviews?: number;
    };
    url: '/v1/automations/{id}/reviews/health';
};

export type AutomationsReviewsHealthErrors = {
    /**
     * Validation error. Request shape did not match the spec.
     */
    400: ApiErrorEnvelope;
    /**
     * Missing or invalid API key
     */
    401: ApiErrorEnvelope;
    /**
     * API key lacks required scope
     */
    403: ApiErrorEnvelope;
    /**
     * Resource not found
     */
    404: ApiErrorEnvelope;
    /**
     * Payload too large. Upload exceeded the per-request size cap.
     */
    413: ApiErrorEnvelope;
    /**
     * Rate limit exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * Internal server error
     */
    500: ApiErrorEnvelope;
};

export type AutomationsReviewsHealthError = AutomationsReviewsHealthErrors[keyof AutomationsReviewsHealthErrors];

export type AutomationsReviewsHealthResponses = {
    /**
     * Automation review health metrics.
     */
    200: RunReviewHealthResponse;
};

export type AutomationsReviewsHealthResponse = AutomationsReviewsHealthResponses[keyof AutomationsReviewsHealthResponses];

export type AutomationsSyncData = {
    body?: never;
    path: {
        /**
         * Automation target to sync, such as agents.invoice-agent or workflows.extract. Do not include a version; sync always uses the latest Git release.
         */
        id: string;
    };
    query?: never;
    url: '/v1/automations/{id}/sync';
};

export type AutomationsSyncErrors = {
    /**
     * Validation error. Request shape did not match the spec.
     */
    400: ApiErrorEnvelope;
    /**
     * Missing or invalid API key
     */
    401: ApiErrorEnvelope;
    /**
     * API key lacks required scope
     */
    403: ApiErrorEnvelope;
    /**
     * Resource not found
     */
    404: ApiErrorEnvelope;
    /**
     * Payload too large. Upload exceeded the per-request size cap.
     */
    413: ApiErrorEnvelope;
    /**
     * Rate limit exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * Internal server error
     */
    500: ApiErrorEnvelope;
};

export type AutomationsSyncError = AutomationsSyncErrors[keyof AutomationsSyncErrors];

export type AutomationsSyncResponses = {
    /**
     * Automation metadata, latest release information, and non-fatal sync warnings.
     */
    200: {
        automation: {
            /**
             * Automation id after reconciliation.
             */
            id: string;
            /**
             * Automation kind inferred from the source package path.
             */
            type: 'agent' | 'workflow';
            /**
             * Source package slug within agents/ or workflows/.
             */
            slug: string;
            /**
             * Current automation registry status.
             */
            status: 'active' | 'archived';
            /**
             * ISO timestamp for the reconciled automation row.
             */
            updatedAt: string;
        };
        release: {
            /**
             * Latest released source package version that was synced.
             */
            version: string;
            /**
             * Git release tag read during sync.
             */
            tag: string;
            /**
             * Git commit for the release tag.
             */
            commit: string;
        };
        /**
         * Non-fatal source-state warnings, such as unsupported email alias domains.
         */
        warnings: Array<string>;
    };
};

export type AutomationsSyncResponse = AutomationsSyncResponses[keyof AutomationsSyncResponses];

export type AutomationsTriggersGetData = {
    body?: never;
    path: {
        /**
         * Workflow id, agent id, or typed alias like workflows.slug / agents.slug
         */
        id: string;
    };
    query?: never;
    url: '/v1/automations/{id}/triggers';
};

export type AutomationsTriggersGetErrors = {
    /**
     * Validation error. Request shape did not match the spec.
     */
    400: ApiErrorEnvelope;
    /**
     * Missing or invalid API key
     */
    401: ApiErrorEnvelope;
    /**
     * API key lacks required scope
     */
    403: ApiErrorEnvelope;
    /**
     * Resource not found
     */
    404: ApiErrorEnvelope;
    /**
     * Payload too large. Upload exceeded the per-request size cap.
     */
    413: ApiErrorEnvelope;
    /**
     * Rate limit exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * Internal server error
     */
    500: ApiErrorEnvelope;
};

export type AutomationsTriggersGetError = AutomationsTriggersGetErrors[keyof AutomationsTriggersGetErrors];

export type AutomationsTriggersGetResponses = {
    /**
     * Automation trigger state
     */
    200: AutomationTriggersResponse;
};

export type AutomationsTriggersGetResponse = AutomationsTriggersGetResponses[keyof AutomationsTriggersGetResponses];

export type AutomationsVersionsListData = {
    body?: never;
    path: {
        /**
         * Workflow id, agent id, or typed alias like workflows.slug / agents.slug
         */
        id: string;
    };
    query?: never;
    url: '/v1/automations/{id}/versions';
};

export type AutomationsVersionsListErrors = {
    /**
     * Validation error. Request shape did not match the spec.
     */
    400: ApiErrorEnvelope;
    /**
     * Missing or invalid API key
     */
    401: ApiErrorEnvelope;
    /**
     * API key lacks required scope
     */
    403: ApiErrorEnvelope;
    /**
     * Resource not found
     */
    404: ApiErrorEnvelope;
    /**
     * Payload too large. Upload exceeded the per-request size cap.
     */
    413: ApiErrorEnvelope;
    /**
     * Rate limit exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * Internal server error
     */
    500: ApiErrorEnvelope;
};

export type AutomationsVersionsListError = AutomationsVersionsListErrors[keyof AutomationsVersionsListErrors];

export type AutomationsVersionsListResponses = {
    /**
     * Automation versions
     */
    200: ListAutomationVersionsResponse;
};

export type AutomationsVersionsListResponse = AutomationsVersionsListResponses[keyof AutomationsVersionsListResponses];

export type AutomationsVersionsCreateData = {
    body: CreateAutomationVersionRequest;
    path: {
        /**
         * Workflow id, agent id, or typed alias like workflows.slug / agents.slug
         */
        id: string;
    };
    query?: never;
    url: '/v1/automations/{id}/versions';
};

export type AutomationsVersionsCreateErrors = {
    /**
     * Validation error. Request shape did not match the spec.
     */
    400: ApiErrorEnvelope;
    /**
     * Missing or invalid API key
     */
    401: ApiErrorEnvelope;
    /**
     * API key lacks required scope
     */
    403: ApiErrorEnvelope;
    /**
     * Resource not found
     */
    404: ApiErrorEnvelope;
    /**
     * Conflict. The resource is in a state that forbids the request.
     */
    409: ApiErrorEnvelope;
    /**
     * Payload too large. Upload exceeded the per-request size cap.
     */
    413: ApiErrorEnvelope;
    /**
     * Rate limit exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * Internal server error
     */
    500: ApiErrorEnvelope;
};

export type AutomationsVersionsCreateError = AutomationsVersionsCreateErrors[keyof AutomationsVersionsCreateErrors];

export type AutomationsVersionsCreateResponses = {
    /**
     * Created workflow version.
     */
    201: AutomationVersion;
};

export type AutomationsVersionsCreateResponse = AutomationsVersionsCreateResponses[keyof AutomationsVersionsCreateResponses];

export type AutomationsVersionsPromoteData = {
    body?: never;
    path: {
        /**
         * Workflow id, agent id, or typed alias like workflows.slug / agents.slug
         */
        id: string;
        /**
         * Tagged version id from GET /automations/{id}/versions. Untagged snapshots (for example after restore) and unknown ids return 404.
         */
        versionId: string;
    };
    query?: never;
    url: '/v1/automations/{id}/versions/{versionId}/promote';
};

export type AutomationsVersionsPromoteErrors = {
    /**
     * Validation error. Request shape did not match the spec.
     */
    400: ApiErrorEnvelope;
    /**
     * Missing or invalid API key
     */
    401: ApiErrorEnvelope;
    /**
     * API key lacks required scope
     */
    403: ApiErrorEnvelope;
    /**
     * Resource not found
     */
    404: ApiErrorEnvelope;
    /**
     * Conflict. The resource is in a state that forbids the request.
     */
    409: ApiErrorEnvelope;
    /**
     * Payload too large. Upload exceeded the per-request size cap.
     */
    413: ApiErrorEnvelope;
    /**
     * Rate limit exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * Internal server error
     */
    500: ApiErrorEnvelope;
};

export type AutomationsVersionsPromoteError = AutomationsVersionsPromoteErrors[keyof AutomationsVersionsPromoteErrors];

export type AutomationsVersionsPromoteResponses = {
    /**
     * Existing tagged workflow version promoted.
     */
    200: AutomationVersion;
};

export type AutomationsVersionsPromoteResponse = AutomationsVersionsPromoteResponses[keyof AutomationsVersionsPromoteResponses];

export type AutomationsVersionsRestoreData = {
    body: RestoreAutomationVersionRequest;
    path: {
        /**
         * Workflow id, agent id, or typed alias like workflows.slug / agents.slug
         */
        id: string;
        /**
         * Version id from GET /automations/{id}/versions (a workflow history id).
         */
        versionId: string;
    };
    query?: never;
    url: '/v1/automations/{id}/versions/{versionId}/restore';
};

export type AutomationsVersionsRestoreErrors = {
    /**
     * Validation error. Request shape did not match the spec.
     */
    400: ApiErrorEnvelope;
    /**
     * Missing or invalid API key
     */
    401: ApiErrorEnvelope;
    /**
     * API key lacks required scope
     */
    403: ApiErrorEnvelope;
    /**
     * Resource not found
     */
    404: ApiErrorEnvelope;
    /**
     * Conflict. The resource is in a state that forbids the request.
     */
    409: ApiErrorEnvelope;
    /**
     * Payload too large. Upload exceeded the per-request size cap.
     */
    413: ApiErrorEnvelope;
    /**
     * Rate limit exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * Internal server error
     */
    500: ApiErrorEnvelope;
};

export type AutomationsVersionsRestoreError = AutomationsVersionsRestoreErrors[keyof AutomationsVersionsRestoreErrors];

export type AutomationsVersionsRestoreResponses = {
    /**
     * New current version created from the restored snapshot.
     */
    201: AutomationVersion;
};

export type AutomationsVersionsRestoreResponse = AutomationsVersionsRestoreResponses[keyof AutomationsVersionsRestoreResponses];

export type EmailServersListData = {
    body?: never;
    path?: never;
    query?: {
        /**
         * Maximum number of email servers to return (1–100).
         */
        limit?: number;
        /**
         * Zero-based offset for paging through email servers.
         */
        offset?: number;
    };
    url: '/v1/email-servers';
};

export type EmailServersListErrors = {
    /**
     * Validation error. Request shape did not match the spec.
     */
    400: ApiErrorEnvelope;
    /**
     * Missing or invalid API key
     */
    401: ApiErrorEnvelope;
    /**
     * API key lacks required scope
     */
    403: ApiErrorEnvelope;
    /**
     * Resource not found
     */
    404: ApiErrorEnvelope;
    /**
     * Payload too large. Upload exceeded the per-request size cap.
     */
    413: ApiErrorEnvelope;
    /**
     * Rate limit exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * Internal server error
     */
    500: ApiErrorEnvelope;
};

export type EmailServersListError = EmailServersListErrors[keyof EmailServersListErrors];

export type EmailServersListResponses = {
    /**
     * Page of email servers
     */
    200: ListEmailServersResponse;
};

export type EmailServersListResponse = EmailServersListResponses[keyof EmailServersListResponses];

export type EmailServersCreateData = {
    body: CreateEmailServerRequest;
    path?: never;
    query?: never;
    url: '/v1/email-servers';
};

export type EmailServersCreateErrors = {
    /**
     * Validation error. Request shape did not match the spec.
     */
    400: ApiErrorEnvelope;
    /**
     * Missing or invalid API key
     */
    401: ApiErrorEnvelope;
    /**
     * API key lacks required scope
     */
    403: ApiErrorEnvelope;
    /**
     * Resource not found
     */
    404: ApiErrorEnvelope;
    /**
     * Conflict. The resource is in a state that forbids the request.
     */
    409: ApiErrorEnvelope;
    /**
     * Payload too large. Upload exceeded the per-request size cap.
     */
    413: ApiErrorEnvelope;
    /**
     * Rate limit exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * Internal server error
     */
    500: ApiErrorEnvelope;
};

export type EmailServersCreateError = EmailServersCreateErrors[keyof EmailServersCreateErrors];

export type EmailServersCreateResponses = {
    /**
     * Created email server
     */
    201: EmailServer;
};

export type EmailServersCreateResponse = EmailServersCreateResponses[keyof EmailServersCreateResponses];

export type EmailServersDeleteData = {
    body?: never;
    path: {
        /**
         * Email server id (`ems_…`).
         */
        id: string;
    };
    query?: never;
    url: '/v1/email-servers/{id}';
};

export type EmailServersDeleteErrors = {
    /**
     * Validation error. Request shape did not match the spec.
     */
    400: ApiErrorEnvelope;
    /**
     * Missing or invalid API key
     */
    401: ApiErrorEnvelope;
    /**
     * API key lacks required scope
     */
    403: ApiErrorEnvelope;
    /**
     * Resource not found
     */
    404: ApiErrorEnvelope;
    /**
     * Payload too large. Upload exceeded the per-request size cap.
     */
    413: ApiErrorEnvelope;
    /**
     * Rate limit exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * Internal server error
     */
    500: ApiErrorEnvelope;
};

export type EmailServersDeleteError = EmailServersDeleteErrors[keyof EmailServersDeleteErrors];

export type EmailServersDeleteResponses = {
    /**
     * Email server deleted
     */
    200: DeleteEmailServerResponse;
};

export type EmailServersDeleteResponse = EmailServersDeleteResponses[keyof EmailServersDeleteResponses];

export type EmailServersGetData = {
    body?: never;
    path: {
        /**
         * Email server id (`ems_…`).
         */
        id: string;
    };
    query?: never;
    url: '/v1/email-servers/{id}';
};

export type EmailServersGetErrors = {
    /**
     * Validation error. Request shape did not match the spec.
     */
    400: ApiErrorEnvelope;
    /**
     * Missing or invalid API key
     */
    401: ApiErrorEnvelope;
    /**
     * API key lacks required scope
     */
    403: ApiErrorEnvelope;
    /**
     * Resource not found
     */
    404: ApiErrorEnvelope;
    /**
     * Payload too large. Upload exceeded the per-request size cap.
     */
    413: ApiErrorEnvelope;
    /**
     * Rate limit exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * Internal server error
     */
    500: ApiErrorEnvelope;
};

export type EmailServersGetError = EmailServersGetErrors[keyof EmailServersGetErrors];

export type EmailServersGetResponses = {
    /**
     * Email server
     */
    200: EmailServer;
};

export type EmailServersGetResponse = EmailServersGetResponses[keyof EmailServersGetResponses];

export type EmailServersUpdateData = {
    body: UpdateEmailServerRequest;
    path: {
        /**
         * Email server id (`ems_…`).
         */
        id: string;
    };
    query?: never;
    url: '/v1/email-servers/{id}';
};

export type EmailServersUpdateErrors = {
    /**
     * Validation error. Request shape did not match the spec.
     */
    400: ApiErrorEnvelope;
    /**
     * Missing or invalid API key
     */
    401: ApiErrorEnvelope;
    /**
     * API key lacks required scope
     */
    403: ApiErrorEnvelope;
    /**
     * Resource not found
     */
    404: ApiErrorEnvelope;
    /**
     * Conflict. The resource is in a state that forbids the request.
     */
    409: ApiErrorEnvelope;
    /**
     * Payload too large. Upload exceeded the per-request size cap.
     */
    413: ApiErrorEnvelope;
    /**
     * Rate limit exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * Internal server error
     */
    500: ApiErrorEnvelope;
};

export type EmailServersUpdateError = EmailServersUpdateErrors[keyof EmailServersUpdateErrors];

export type EmailServersUpdateResponses = {
    /**
     * Updated email server
     */
    200: EmailServer;
};

export type EmailServersUpdateResponse = EmailServersUpdateResponses[keyof EmailServersUpdateResponses];

export type EmailServersTestData = {
    body: TestEmailServerRequest;
    path: {
        /**
         * Email server id (`ems_…`).
         */
        id: string;
    };
    query?: never;
    url: '/v1/email-servers/{id}/test';
};

export type EmailServersTestErrors = {
    /**
     * Validation error. Request shape did not match the spec.
     */
    400: ApiErrorEnvelope;
    /**
     * Missing or invalid API key
     */
    401: ApiErrorEnvelope;
    /**
     * API key lacks required scope
     */
    403: ApiErrorEnvelope;
    /**
     * Resource not found
     */
    404: ApiErrorEnvelope;
    /**
     * Conflict. The resource is in a state that forbids the request.
     */
    409: ApiErrorEnvelope;
    /**
     * Payload too large. Upload exceeded the per-request size cap.
     */
    413: ApiErrorEnvelope;
    /**
     * Rate limit exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * Internal server error
     */
    500: ApiErrorEnvelope;
};

export type EmailServersTestError = EmailServersTestErrors[keyof EmailServersTestErrors];

export type EmailServersTestResponses = {
    /**
     * Test send result
     */
    200: TestEmailServerResponse;
};

export type EmailServersTestResponse = EmailServersTestResponses[keyof EmailServersTestResponses];

export type ExperimentsResolveData = {
    body?: never;
    path: {
        experimentId: string;
    };
    query?: never;
    url: '/v1/experiments/{experimentId}';
};

export type ExperimentsResolveErrors = {
    /**
     * Validation error. Request shape did not match the spec.
     */
    400: ApiErrorEnvelope;
    /**
     * Missing or invalid API key
     */
    401: ApiErrorEnvelope;
    /**
     * API key lacks required scope
     */
    403: ApiErrorEnvelope;
    /**
     * Resource not found
     */
    404: ApiErrorEnvelope;
    /**
     * Payload too large. Upload exceeded the per-request size cap.
     */
    413: ApiErrorEnvelope;
    /**
     * Rate limit exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * Internal server error
     */
    500: ApiErrorEnvelope;
};

export type ExperimentsResolveError = ExperimentsResolveErrors[keyof ExperimentsResolveErrors];

export type ExperimentsResolveResponses = {
    /**
     * Experiment reference
     */
    200: ExperimentRef;
};

export type ExperimentsResolveResponse = ExperimentsResolveResponses[keyof ExperimentsResolveResponses];

export type FilesCreateData = {
    body: CreateFileMultipartRequest;
    path?: never;
    query?: never;
    url: '/v1/files';
};

export type FilesCreateErrors = {
    /**
     * Validation error. Request shape did not match the spec.
     */
    400: ApiErrorEnvelope;
    /**
     * Missing or invalid API key
     */
    401: ApiErrorEnvelope;
    /**
     * API key lacks required scope
     */
    403: ApiErrorEnvelope;
    /**
     * Resource not found
     */
    404: ApiErrorEnvelope;
    /**
     * Payload too large. Upload exceeded the per-request size cap.
     */
    413: ApiErrorEnvelope;
    /**
     * Rate limit exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * Internal server error
     */
    500: ApiErrorEnvelope;
};

export type FilesCreateError = FilesCreateErrors[keyof FilesCreateErrors];

export type FilesCreateResponses = {
    /**
     * Uploaded file
     */
    200: File;
};

export type FilesCreateResponse = FilesCreateResponses[keyof FilesCreateResponses];

export type FilesDeleteData = {
    body?: never;
    path: {
        /**
         * File id
         */
        id: string;
    };
    query?: never;
    url: '/v1/files/{id}';
};

export type FilesDeleteErrors = {
    /**
     * Validation error. Request shape did not match the spec.
     */
    400: ApiErrorEnvelope;
    /**
     * Missing or invalid API key
     */
    401: ApiErrorEnvelope;
    /**
     * API key lacks required scope
     */
    403: ApiErrorEnvelope;
    /**
     * Resource not found
     */
    404: ApiErrorEnvelope;
    /**
     * Payload too large. Upload exceeded the per-request size cap.
     */
    413: ApiErrorEnvelope;
    /**
     * Rate limit exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * Internal server error
     */
    500: ApiErrorEnvelope;
};

export type FilesDeleteError = FilesDeleteErrors[keyof FilesDeleteErrors];

export type FilesDeleteResponses = {
    /**
     * File deleted
     */
    200: DeleteFileResponse;
};

export type FilesDeleteResponse = FilesDeleteResponses[keyof FilesDeleteResponses];

export type FilesGetData = {
    body?: never;
    path: {
        /**
         * File id
         */
        id: string;
    };
    query?: never;
    url: '/v1/files/{id}';
};

export type FilesGetErrors = {
    /**
     * Validation error. Request shape did not match the spec.
     */
    400: ApiErrorEnvelope;
    /**
     * Missing or invalid API key
     */
    401: ApiErrorEnvelope;
    /**
     * API key lacks required scope
     */
    403: ApiErrorEnvelope;
    /**
     * Resource not found
     */
    404: ApiErrorEnvelope;
    /**
     * Payload too large. Upload exceeded the per-request size cap.
     */
    413: ApiErrorEnvelope;
    /**
     * Rate limit exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * Internal server error
     */
    500: ApiErrorEnvelope;
};

export type FilesGetError = FilesGetErrors[keyof FilesGetErrors];

export type FilesGetResponses = {
    /**
     * File metadata
     */
    200: File;
};

export type FilesGetResponse = FilesGetResponses[keyof FilesGetResponses];

export type FilesContentGetData = {
    body?: never;
    path: {
        /**
         * File id
         */
        id: string;
    };
    query?: never;
    url: '/v1/files/{id}/content';
};

export type FilesContentGetErrors = {
    /**
     * Validation error. Request shape did not match the spec.
     */
    400: ApiErrorEnvelope;
    /**
     * Missing or invalid API key
     */
    401: ApiErrorEnvelope;
    /**
     * API key lacks required scope
     */
    403: ApiErrorEnvelope;
    /**
     * Resource not found
     */
    404: ApiErrorEnvelope;
    /**
     * Payload too large. Upload exceeded the per-request size cap.
     */
    413: ApiErrorEnvelope;
    /**
     * Rate limit exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * Internal server error
     */
    500: ApiErrorEnvelope;
};

export type FilesContentGetError = FilesContentGetErrors[keyof FilesContentGetErrors];

export type FilesContentGetResponses = {
    /**
     * File content
     */
    200: unknown;
};

export type FilesUploadsCreateData = {
    body: CreateFileUploadSessionRequest;
    path?: never;
    query?: never;
    url: '/v1/files/uploads';
};

export type FilesUploadsCreateErrors = {
    /**
     * Validation error. Request shape did not match the spec.
     */
    400: ApiErrorEnvelope;
    /**
     * Missing or invalid API key
     */
    401: ApiErrorEnvelope;
    /**
     * API key lacks required scope
     */
    403: ApiErrorEnvelope;
    /**
     * Resource not found
     */
    404: ApiErrorEnvelope;
    /**
     * Payload too large. Upload exceeded the per-request size cap.
     */
    413: ApiErrorEnvelope;
    /**
     * Rate limit exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * Internal server error
     */
    500: ApiErrorEnvelope;
};

export type FilesUploadsCreateError = FilesUploadsCreateErrors[keyof FilesUploadsCreateErrors];

export type FilesUploadsCreateResponses = {
    /**
     * Negotiated upload transport
     */
    200: PresignedFileUploadSession | PresignedMultipartFileUploadSession | MultipartFileUploadFallback;
};

export type FilesUploadsCreateResponse = FilesUploadsCreateResponses[keyof FilesUploadsCreateResponses];

export type FilesUploadsAbortData = {
    body?: never;
    path: {
        uploadId: string;
    };
    query?: never;
    url: '/v1/files/uploads/{uploadId}';
};

export type FilesUploadsAbortErrors = {
    /**
     * Validation error. Request shape did not match the spec.
     */
    400: ApiErrorEnvelope;
    /**
     * Missing or invalid API key
     */
    401: ApiErrorEnvelope;
    /**
     * API key lacks required scope
     */
    403: ApiErrorEnvelope;
    /**
     * Resource not found
     */
    404: ApiErrorEnvelope;
    /**
     * Payload too large. Upload exceeded the per-request size cap.
     */
    413: ApiErrorEnvelope;
    /**
     * Rate limit exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * Internal server error
     */
    500: ApiErrorEnvelope;
};

export type FilesUploadsAbortError = FilesUploadsAbortErrors[keyof FilesUploadsAbortErrors];

export type FilesUploadsAbortResponses = {
    /**
     * Upload aborted
     */
    200: AbortFileUploadResponse;
};

export type FilesUploadsAbortResponse = FilesUploadsAbortResponses[keyof FilesUploadsAbortResponses];

export type FilesUploadsGetData = {
    body?: never;
    path: {
        uploadId: string;
    };
    query?: never;
    url: '/v1/files/uploads/{uploadId}';
};

export type FilesUploadsGetErrors = {
    /**
     * Validation error. Request shape did not match the spec.
     */
    400: ApiErrorEnvelope;
    /**
     * Missing or invalid API key
     */
    401: ApiErrorEnvelope;
    /**
     * API key lacks required scope
     */
    403: ApiErrorEnvelope;
    /**
     * Resource not found
     */
    404: ApiErrorEnvelope;
    /**
     * Payload too large. Upload exceeded the per-request size cap.
     */
    413: ApiErrorEnvelope;
    /**
     * Rate limit exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * Internal server error
     */
    500: ApiErrorEnvelope;
};

export type FilesUploadsGetError = FilesUploadsGetErrors[keyof FilesUploadsGetErrors];

export type FilesUploadsGetResponses = {
    /**
     * Upload session
     */
    200: FileUploadSession;
};

export type FilesUploadsGetResponse = FilesUploadsGetResponses[keyof FilesUploadsGetResponses];

export type FilesUploadsCompleteData = {
    body?: never;
    path: {
        uploadId: string;
    };
    query?: never;
    url: '/v1/files/uploads/{uploadId}/complete';
};

export type FilesUploadsCompleteErrors = {
    /**
     * Validation error. Request shape did not match the spec.
     */
    400: ApiErrorEnvelope;
    /**
     * Missing or invalid API key
     */
    401: ApiErrorEnvelope;
    /**
     * API key lacks required scope
     */
    403: ApiErrorEnvelope;
    /**
     * Resource not found
     */
    404: ApiErrorEnvelope;
    /**
     * Payload too large. Upload exceeded the per-request size cap.
     */
    413: ApiErrorEnvelope;
    /**
     * Rate limit exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * Internal server error
     */
    500: ApiErrorEnvelope;
};

export type FilesUploadsCompleteError = FilesUploadsCompleteErrors[keyof FilesUploadsCompleteErrors];

export type FilesUploadsCompleteResponses = {
    /**
     * Completed reusable file
     */
    200: File;
};

export type FilesUploadsCompleteResponse = FilesUploadsCompleteResponses[keyof FilesUploadsCompleteResponses];

export type FilesUploadsPartsListData = {
    body?: never;
    path: {
        uploadId: string;
    };
    query?: never;
    url: '/v1/files/uploads/{uploadId}/parts';
};

export type FilesUploadsPartsListErrors = {
    /**
     * Validation error. Request shape did not match the spec.
     */
    400: ApiErrorEnvelope;
    /**
     * Missing or invalid API key
     */
    401: ApiErrorEnvelope;
    /**
     * API key lacks required scope
     */
    403: ApiErrorEnvelope;
    /**
     * Resource not found
     */
    404: ApiErrorEnvelope;
    /**
     * Payload too large. Upload exceeded the per-request size cap.
     */
    413: ApiErrorEnvelope;
    /**
     * Rate limit exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * Internal server error
     */
    500: ApiErrorEnvelope;
};

export type FilesUploadsPartsListError = FilesUploadsPartsListErrors[keyof FilesUploadsPartsListErrors];

export type FilesUploadsPartsListResponses = {
    /**
     * Uploaded parts
     */
    200: ListFileUploadPartsResponse;
};

export type FilesUploadsPartsListResponse = FilesUploadsPartsListResponses[keyof FilesUploadsPartsListResponses];

export type FilesUploadsPartsPresignData = {
    body: PresignFileUploadPartRequest;
    path: {
        uploadId: string;
    };
    query?: never;
    url: '/v1/files/uploads/{uploadId}/parts';
};

export type FilesUploadsPartsPresignErrors = {
    /**
     * Validation error. Request shape did not match the spec.
     */
    400: ApiErrorEnvelope;
    /**
     * Missing or invalid API key
     */
    401: ApiErrorEnvelope;
    /**
     * API key lacks required scope
     */
    403: ApiErrorEnvelope;
    /**
     * Resource not found
     */
    404: ApiErrorEnvelope;
    /**
     * Payload too large. Upload exceeded the per-request size cap.
     */
    413: ApiErrorEnvelope;
    /**
     * Rate limit exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * Internal server error
     */
    500: ApiErrorEnvelope;
};

export type FilesUploadsPartsPresignError = FilesUploadsPartsPresignErrors[keyof FilesUploadsPartsPresignErrors];

export type FilesUploadsPartsPresignResponses = {
    /**
     * Signed part upload
     */
    200: PresignFileUploadPartResponse;
};

export type FilesUploadsPartsPresignResponse = FilesUploadsPartsPresignResponses[keyof FilesUploadsPartsPresignResponses];

export type FoldersListData = {
    body?: never;
    path?: never;
    query: {
        /**
         * Folder tree to list. Required; there is no default.
         */
        type: FolderType;
        /**
         * Limit to direct children of this folder. Pass `null` for root folders only. Ignored when `tree=true`.
         */
        parentId?: string;
        /**
         * When `true`, return the full tree for `type` with child counts (and workflow previews for workflow trees).
         */
        tree?: string;
    };
    url: '/v1/folders';
};

export type FoldersListErrors = {
    /**
     * Validation error. Request shape did not match the spec.
     */
    400: ApiErrorEnvelope;
    /**
     * Missing or invalid API key
     */
    401: ApiErrorEnvelope;
    /**
     * API key lacks required scope
     */
    403: ApiErrorEnvelope;
    /**
     * Resource not found
     */
    404: ApiErrorEnvelope;
    /**
     * Payload too large. Upload exceeded the per-request size cap.
     */
    413: ApiErrorEnvelope;
    /**
     * Rate limit exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * Internal server error
     */
    500: ApiErrorEnvelope;
};

export type FoldersListError = FoldersListErrors[keyof FoldersListErrors];

export type FoldersListResponses = {
    /**
     * Folders in the requested tree
     */
    200: ListFoldersResponse;
};

export type FoldersListResponse = FoldersListResponses[keyof FoldersListResponses];

export type FoldersCreateData = {
    body: CreateFolderRequest;
    path?: never;
    query?: never;
    url: '/v1/folders';
};

export type FoldersCreateErrors = {
    /**
     * Validation error. Request shape did not match the spec.
     */
    400: ApiErrorEnvelope;
    /**
     * Missing or invalid API key
     */
    401: ApiErrorEnvelope;
    /**
     * API key lacks required scope
     */
    403: ApiErrorEnvelope;
    /**
     * Resource not found
     */
    404: ApiErrorEnvelope;
    /**
     * Conflict. The resource is in a state that forbids the request.
     */
    409: ApiErrorEnvelope;
    /**
     * Payload too large. Upload exceeded the per-request size cap.
     */
    413: ApiErrorEnvelope;
    /**
     * Rate limit exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * Internal server error
     */
    500: ApiErrorEnvelope;
};

export type FoldersCreateError = FoldersCreateErrors[keyof FoldersCreateErrors];

export type FoldersCreateResponses = {
    /**
     * Created folder
     */
    201: Folder;
};

export type FoldersCreateResponse = FoldersCreateResponses[keyof FoldersCreateResponses];

export type FoldersDeleteData = {
    body?: never;
    path: {
        /**
         * Folder id (`fldr_…`).
         */
        id: string;
    };
    query?: never;
    url: '/v1/folders/{id}';
};

export type FoldersDeleteErrors = {
    /**
     * Validation error. Request shape did not match the spec.
     */
    400: ApiErrorEnvelope;
    /**
     * Missing or invalid API key
     */
    401: ApiErrorEnvelope;
    /**
     * API key lacks required scope
     */
    403: ApiErrorEnvelope;
    /**
     * Resource not found
     */
    404: ApiErrorEnvelope;
    /**
     * Payload too large. Upload exceeded the per-request size cap.
     */
    413: ApiErrorEnvelope;
    /**
     * Rate limit exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * Internal server error
     */
    500: ApiErrorEnvelope;
};

export type FoldersDeleteError = FoldersDeleteErrors[keyof FoldersDeleteErrors];

export type FoldersDeleteResponses = {
    /**
     * Folder deleted
     */
    200: DeleteFolderResponse;
};

export type FoldersDeleteResponse = FoldersDeleteResponses[keyof FoldersDeleteResponses];

export type FoldersGetData = {
    body?: never;
    path: {
        /**
         * Folder id (`fldr_…`).
         */
        id: string;
    };
    query?: never;
    url: '/v1/folders/{id}';
};

export type FoldersGetErrors = {
    /**
     * Validation error. Request shape did not match the spec.
     */
    400: ApiErrorEnvelope;
    /**
     * Missing or invalid API key
     */
    401: ApiErrorEnvelope;
    /**
     * API key lacks required scope
     */
    403: ApiErrorEnvelope;
    /**
     * Resource not found
     */
    404: ApiErrorEnvelope;
    /**
     * Payload too large. Upload exceeded the per-request size cap.
     */
    413: ApiErrorEnvelope;
    /**
     * Rate limit exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * Internal server error
     */
    500: ApiErrorEnvelope;
};

export type FoldersGetError = FoldersGetErrors[keyof FoldersGetErrors];

export type FoldersGetResponses = {
    /**
     * Folder
     */
    200: Folder;
};

export type FoldersGetResponse = FoldersGetResponses[keyof FoldersGetResponses];

export type FoldersUpdateData = {
    body: UpdateFolderRequest;
    path: {
        /**
         * Folder id (`fldr_…`).
         */
        id: string;
    };
    query?: never;
    url: '/v1/folders/{id}';
};

export type FoldersUpdateErrors = {
    /**
     * Validation error. Request shape did not match the spec.
     */
    400: ApiErrorEnvelope;
    /**
     * Missing or invalid API key
     */
    401: ApiErrorEnvelope;
    /**
     * API key lacks required scope
     */
    403: ApiErrorEnvelope;
    /**
     * Resource not found
     */
    404: ApiErrorEnvelope;
    /**
     * Conflict. The resource is in a state that forbids the request.
     */
    409: ApiErrorEnvelope;
    /**
     * Payload too large. Upload exceeded the per-request size cap.
     */
    413: ApiErrorEnvelope;
    /**
     * Rate limit exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * Internal server error
     */
    500: ApiErrorEnvelope;
};

export type FoldersUpdateError = FoldersUpdateErrors[keyof FoldersUpdateErrors];

export type FoldersUpdateResponses = {
    /**
     * Updated folder
     */
    200: Folder;
};

export type FoldersUpdateResponse = FoldersUpdateResponses[keyof FoldersUpdateResponses];

export type HumanReviewsListData = {
    body?: never;
    path?: never;
    query?: {
        automationId?: string;
        waitingBefore?: string;
        cursor?: string;
        limit?: number;
    };
    url: '/v1/human-reviews';
};

export type HumanReviewsListErrors = {
    /**
     * Validation error. Request shape did not match the spec.
     */
    400: ApiErrorEnvelope;
    /**
     * Missing or invalid API key
     */
    401: ApiErrorEnvelope;
    /**
     * API key lacks required scope
     */
    403: ApiErrorEnvelope;
    /**
     * Resource not found
     */
    404: ApiErrorEnvelope;
    /**
     * Payload too large. Upload exceeded the per-request size cap.
     */
    413: ApiErrorEnvelope;
    /**
     * Rate limit exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * Internal server error
     */
    500: ApiErrorEnvelope;
};

export type HumanReviewsListError = HumanReviewsListErrors[keyof HumanReviewsListErrors];

export type HumanReviewsListResponses = {
    /**
     * Pending review tasks
     */
    200: HumanReviewListResponse;
};

export type HumanReviewsListResponse = HumanReviewsListResponses[keyof HumanReviewsListResponses];

export type HumanReviewsGetData = {
    body?: never;
    path: {
        /**
         * Human review task id
         */
        taskId: string;
    };
    query?: never;
    url: '/v1/human-reviews/{taskId}';
};

export type HumanReviewsGetErrors = {
    /**
     * Validation error. Request shape did not match the spec.
     */
    400: ApiErrorEnvelope;
    /**
     * Missing or invalid API key
     */
    401: ApiErrorEnvelope;
    /**
     * API key lacks required scope
     */
    403: ApiErrorEnvelope;
    /**
     * Resource not found
     */
    404: ApiErrorEnvelope;
    /**
     * Payload too large. Upload exceeded the per-request size cap.
     */
    413: ApiErrorEnvelope;
    /**
     * Rate limit exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * Internal server error
     */
    500: ApiErrorEnvelope;
};

export type HumanReviewsGetError = HumanReviewsGetErrors[keyof HumanReviewsGetErrors];

export type HumanReviewsGetResponses = {
    /**
     * Human review task detail
     */
    200: HumanReviewTaskResponse;
};

export type HumanReviewsGetResponse = HumanReviewsGetResponses[keyof HumanReviewsGetResponses];

export type HumanReviewsApproveData = {
    body: {
        expectedVersion: number;
    };
    path: {
        /**
         * Human review task id
         */
        taskId: string;
    };
    query?: never;
    url: '/v1/human-reviews/{taskId}/approve';
};

export type HumanReviewsApproveErrors = {
    /**
     * Validation error. Request shape did not match the spec.
     */
    400: ApiErrorEnvelope;
    /**
     * Missing or invalid API key
     */
    401: ApiErrorEnvelope;
    /**
     * API key lacks required scope
     */
    403: ApiErrorEnvelope;
    /**
     * Resource not found
     */
    404: ApiErrorEnvelope;
    /**
     * Payload too large. Upload exceeded the per-request size cap.
     */
    413: ApiErrorEnvelope;
    /**
     * Rate limit exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * Internal server error
     */
    500: ApiErrorEnvelope;
};

export type HumanReviewsApproveError = HumanReviewsApproveErrors[keyof HumanReviewsApproveErrors];

export type HumanReviewsApproveResponses = {
    /**
     * Approved task
     */
    200: HumanReviewApproveResponse;
};

export type HumanReviewsApproveResponse = HumanReviewsApproveResponses[keyof HumanReviewsApproveResponses];

export type HumanReviewsConfirmFieldData = {
    body: {
        expectedVersion: number;
        idempotencyKey: string;
        path: string;
        value: string | number | boolean | null;
        confirmed?: boolean;
    };
    path: {
        /**
         * Human review task id
         */
        taskId: string;
    };
    query?: never;
    url: '/v1/human-reviews/{taskId}/fields';
};

export type HumanReviewsConfirmFieldErrors = {
    /**
     * Validation error. Request shape did not match the spec.
     */
    400: ApiErrorEnvelope;
    /**
     * Missing or invalid API key
     */
    401: ApiErrorEnvelope;
    /**
     * API key lacks required scope
     */
    403: ApiErrorEnvelope;
    /**
     * Resource not found
     */
    404: ApiErrorEnvelope;
    /**
     * Payload too large. Upload exceeded the per-request size cap.
     */
    413: ApiErrorEnvelope;
    /**
     * Rate limit exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * Internal server error
     */
    500: ApiErrorEnvelope;
};

export type HumanReviewsConfirmFieldError = HumanReviewsConfirmFieldErrors[keyof HumanReviewsConfirmFieldErrors];

export type HumanReviewsConfirmFieldResponses = {
    /**
     * Updated task after field confirmation
     */
    200: HumanReviewFieldResponse;
};

export type HumanReviewsConfirmFieldResponse = HumanReviewsConfirmFieldResponses[keyof HumanReviewsConfirmFieldResponses];

export type HumanReviewsFilesContentGetData = {
    body?: never;
    path: {
        /**
         * Human review task id
         */
        taskId: string;
        /**
         * File id listed on the review task
         */
        fileId: string;
    };
    query?: never;
    url: '/v1/human-reviews/{taskId}/files/{fileId}/content';
};

export type HumanReviewsFilesContentGetErrors = {
    /**
     * Validation error. Request shape did not match the spec.
     */
    400: ApiErrorEnvelope;
    /**
     * Missing or invalid API key
     */
    401: ApiErrorEnvelope;
    /**
     * API key lacks required scope
     */
    403: ApiErrorEnvelope;
    /**
     * Resource not found
     */
    404: ApiErrorEnvelope;
    /**
     * Payload too large. Upload exceeded the per-request size cap.
     */
    413: ApiErrorEnvelope;
    /**
     * Rate limit exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * Internal server error
     */
    500: ApiErrorEnvelope;
};

export type HumanReviewsFilesContentGetError = HumanReviewsFilesContentGetErrors[keyof HumanReviewsFilesContentGetErrors];

export type HumanReviewsFilesContentGetResponses = {
    /**
     * Task file content
     */
    200: unknown;
};

export type HumanReviewsRejectData = {
    body: {
        expectedVersion: number;
        idempotencyKey: string;
        reason: string;
    };
    path: {
        /**
         * Human review task id
         */
        taskId: string;
    };
    query?: never;
    url: '/v1/human-reviews/{taskId}/reject';
};

export type HumanReviewsRejectErrors = {
    /**
     * Validation error. Request shape did not match the spec.
     */
    400: ApiErrorEnvelope;
    /**
     * Missing or invalid API key
     */
    401: ApiErrorEnvelope;
    /**
     * API key lacks required scope
     */
    403: ApiErrorEnvelope;
    /**
     * Resource not found
     */
    404: ApiErrorEnvelope;
    /**
     * Payload too large. Upload exceeded the per-request size cap.
     */
    413: ApiErrorEnvelope;
    /**
     * Rate limit exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * Internal server error
     */
    500: ApiErrorEnvelope;
};

export type HumanReviewsRejectError = HumanReviewsRejectErrors[keyof HumanReviewsRejectErrors];

export type HumanReviewsRejectResponses = {
    /**
     * Rejected task
     */
    200: HumanReviewRejectResponse;
};

export type HumanReviewsRejectResponse = HumanReviewsRejectResponses[keyof HumanReviewsRejectResponses];

export type ModelsListData = {
    body?: never;
    path?: never;
    query?: {
        /**
         * Return only models that support this capability (`text`, `vision`, or `ocr`).
         */
        capability?: 'text' | 'vision' | 'ocr';
    };
    url: '/v1/models';
};

export type ModelsListErrors = {
    /**
     * Validation error. Request shape did not match the spec.
     */
    400: ApiErrorEnvelope;
    /**
     * Missing or invalid API key
     */
    401: ApiErrorEnvelope;
    /**
     * API key lacks required scope
     */
    403: ApiErrorEnvelope;
    /**
     * Resource not found
     */
    404: ApiErrorEnvelope;
    /**
     * Payload too large. Upload exceeded the per-request size cap.
     */
    413: ApiErrorEnvelope;
    /**
     * Rate limit exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * Internal server error
     */
    500: ApiErrorEnvelope;
};

export type ModelsListError = ModelsListErrors[keyof ModelsListErrors];

export type ModelsListResponses = {
    /**
     * Configured models
     */
    200: ListModelsResponse;
};

export type ModelsListResponse = ModelsListResponses[keyof ModelsListResponses];

export type RunsListData = {
    body?: never;
    path?: never;
    query?: {
        type?: string;
        source?: string;
        status?: string;
        trigger?: string;
        triggeredBy?: string;
        sourceRef?: string;
        batchId?: string;
        exampleId?: string;
        exampleIdContains?: string;
        from?: string;
        to?: string;
        createdAfter?: string;
        createdBefore?: string;
        completedAfter?: string;
        completedBefore?: string;
        cursor?: string;
        offset?: number;
        limit?: number;
        ids?: string;
        experiments?: string;
        sort?: string;
        order?: string;
        reviewStatus?: string;
        reviewVerdict?: string;
        hasReview?: string;
        noReview?: string;
        hasCorrections?: string;
        reviewNoteContains?: string;
        reviewCreatedAfter?: string;
        reviewCreatedBefore?: string;
        reviewUpdatedAfter?: string;
        reviewUpdatedBefore?: string;
        reviewClosedAfter?: string;
        reviewClosedBefore?: string;
        sinceLastClosed?: string;
        /**
         * Keep runs whose `sampleRank` is below this threshold (0–1). Pages may return fewer than `limit` rows when filtered.
         */
        sampleRate?: string;
    };
    url: '/v1/runs';
};

export type RunsListErrors = {
    /**
     * Validation error. Request shape did not match the spec.
     */
    400: ApiErrorEnvelope;
    /**
     * Missing or invalid API key
     */
    401: ApiErrorEnvelope;
    /**
     * API key lacks required scope
     */
    403: ApiErrorEnvelope;
    /**
     * Resource not found
     */
    404: ApiErrorEnvelope;
    /**
     * Payload too large. Upload exceeded the per-request size cap.
     */
    413: ApiErrorEnvelope;
    /**
     * Rate limit exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * Internal server error
     */
    500: ApiErrorEnvelope;
};

export type RunsListError = RunsListErrors[keyof RunsListErrors];

export type RunsListResponses = {
    /**
     * Runs page
     */
    200: RunsListResponse;
};

export type RunsListResponse2 = RunsListResponses[keyof RunsListResponses];

export type RunsStartData = {
    body: RunStartBody;
    path?: never;
    query?: {
        /**
         * Release or git ref. Defaults to latest.
         */
        version?: string;
        /**
         * Seconds to wait before returning (max 600). Omit for async.
         */
        wait_for_completion?: number;
    };
    url: '/v1/runs';
};

export type RunsStartErrors = {
    /**
     * Validation error. Request shape did not match the spec.
     */
    400: ApiErrorEnvelope;
    /**
     * Missing or invalid API key
     */
    401: ApiErrorEnvelope;
    /**
     * Trigger disabled or insufficient scope. Run start may return api_trigger_disabled when the API trigger is off, or manual_trigger_disabled for dashboard runs on API-only workflows.
     */
    403: ApiErrorEnvelope;
    /**
     * Resource not found
     */
    404: ApiErrorEnvelope;
    /**
     * Payload too large. Upload exceeded the per-request size cap.
     */
    413: ApiErrorEnvelope;
    /**
     * Rate limit exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * Internal server error
     */
    500: ApiErrorEnvelope;
};

export type RunsStartError = RunsStartErrors[keyof RunsStartErrors];

export type RunsStartResponses = {
    /**
     * Run completed while waiting — same body as GET /api/v1/runs/:id
     */
    200: Run;
    /**
     * Run accepted (async)
     */
    201: RunAccepted;
    /**
     * Wait expired with a non-terminal status — poll GET /api/v1/runs/:id
     */
    202: RunAccepted;
};

export type RunsStartResponse = RunsStartResponses[keyof RunsStartResponses];

export type RunsGetData = {
    body?: never;
    path: {
        /**
         * Run id
         */
        id: string;
    };
    query?: {
        /**
         * Optional sections: `input`, `usage`, `execution`, `debug`. Terminal runs always include top-level output, files, and error.
         */
        expand?: string;
    };
    url: '/v1/runs/{id}';
};

export type RunsGetErrors = {
    /**
     * Validation error. Request shape did not match the spec.
     */
    400: ApiErrorEnvelope;
    /**
     * Missing or invalid API key
     */
    401: ApiErrorEnvelope;
    /**
     * API key lacks required scope
     */
    403: ApiErrorEnvelope;
    /**
     * Resource not found
     */
    404: ApiErrorEnvelope;
    /**
     * Payload too large. Upload exceeded the per-request size cap.
     */
    413: ApiErrorEnvelope;
    /**
     * Rate limit exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * Internal server error
     */
    500: ApiErrorEnvelope;
};

export type RunsGetError = RunsGetErrors[keyof RunsGetErrors];

export type RunsGetResponses = {
    /**
     * Run detail. Expanded sections appear only when requested.
     */
    200: Run;
};

export type RunsGetResponse = RunsGetResponses[keyof RunsGetResponses];

export type RunsArtifactsListData = {
    body?: never;
    path: {
        /**
         * Run id
         */
        id: string;
    };
    query?: {
        /**
         * When `1`, download output files as a ZIP instead of listing paths. Does not include trace, scores, or input — use `GET /runs/{id}/scores` and `GET /runs/{id}/trace` for those. Cloud deployments reject archives whose uncompressed inputs exceed 32 MiB (`413 artifacts_zip_too_large`); download files individually or pass a smaller `files=` subset.
         */
        zip?: '1';
        /**
         * With `zip=1`, use `review` to download a ZIP with `output/` and `expected/` folders (corrected review artifacts).
         */
        bundle?: 'review';
        /**
         * Signed email download token (zip only; no Bearer required).
         */
        token?: string;
    };
    url: '/v1/runs/{id}/artifacts';
};

export type RunsArtifactsListErrors = {
    /**
     * Validation error. Request shape did not match the spec.
     */
    400: ApiErrorEnvelope;
    /**
     * Missing or invalid API key
     */
    401: ApiErrorEnvelope;
    /**
     * API key lacks required scope
     */
    403: ApiErrorEnvelope;
    /**
     * Resource not found
     */
    404: ApiErrorEnvelope;
    /**
     * Payload too large. Upload exceeded the per-request size cap.
     */
    413: ApiErrorEnvelope;
    /**
     * Rate limit exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * Internal server error
     */
    500: ApiErrorEnvelope;
};

export type RunsArtifactsListError = RunsArtifactsListErrors[keyof RunsArtifactsListErrors];

export type RunsArtifactsListResponses = {
    /**
     * JSON artifact list, or ZIP bytes when `zip=1`.
     */
    200: RunArtifactsResponse | Blob;
};

export type RunsArtifactsListResponse = RunsArtifactsListResponses[keyof RunsArtifactsListResponses];

export type RunsArtifactsGetData = {
    body?: never;
    path: {
        id: string;
        path: string;
    };
    query?: never;
    url: '/v1/runs/{id}/artifacts/{path}';
};

export type RunsArtifactsGetErrors = {
    /**
     * Validation error. Request shape did not match the spec.
     */
    400: ApiErrorEnvelope;
    /**
     * Missing or invalid API key
     */
    401: ApiErrorEnvelope;
    /**
     * API key lacks required scope
     */
    403: ApiErrorEnvelope;
    /**
     * Resource not found
     */
    404: ApiErrorEnvelope;
    /**
     * Payload too large. Upload exceeded the per-request size cap.
     */
    413: ApiErrorEnvelope;
    /**
     * Rate limit exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * Internal server error
     */
    500: ApiErrorEnvelope;
};

export type RunsArtifactsGetError = RunsArtifactsGetErrors[keyof RunsArtifactsGetErrors];

export type RunsArtifactsGetResponses = {
    /**
     * Run artifact
     */
    200: unknown;
};

export type RunsCancelData = {
    body?: never;
    path: {
        id: string;
    };
    query?: never;
    url: '/v1/runs/{id}/cancel';
};

export type RunsCancelErrors = {
    /**
     * Validation error. Request shape did not match the spec.
     */
    400: ApiErrorEnvelope;
    /**
     * Missing or invalid API key
     */
    401: ApiErrorEnvelope;
    /**
     * API key lacks required scope
     */
    403: ApiErrorEnvelope;
    /**
     * Resource not found
     */
    404: ApiErrorEnvelope;
    /**
     * Payload too large. Upload exceeded the per-request size cap.
     */
    413: ApiErrorEnvelope;
    /**
     * Rate limit exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * Internal server error
     */
    500: ApiErrorEnvelope;
};

export type RunsCancelError = RunsCancelErrors[keyof RunsCancelErrors];

export type RunsCancelResponses = {
    /**
     * Cancellation result
     */
    200: RunCancelResponse;
};

export type RunsCancelResponse = RunsCancelResponses[keyof RunsCancelResponses];

export type RunsEventsListData = {
    body?: never;
    path: {
        /**
         * Run id
         */
        id: string;
    };
    query?: never;
    url: '/v1/runs/{id}/events';
};

export type RunsEventsListErrors = {
    /**
     * Validation error. Request shape did not match the spec.
     */
    400: ApiErrorEnvelope;
    /**
     * Missing or invalid API key
     */
    401: ApiErrorEnvelope;
    /**
     * API key lacks required scope
     */
    403: ApiErrorEnvelope;
    /**
     * Resource not found
     */
    404: ApiErrorEnvelope;
    /**
     * Payload too large. Upload exceeded the per-request size cap.
     */
    413: ApiErrorEnvelope;
    /**
     * Rate limit exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * Internal server error
     */
    500: ApiErrorEnvelope;
};

export type RunsEventsListError = RunsEventsListErrors[keyof RunsEventsListErrors];

export type RunsEventsListResponses = {
    /**
     * Run events
     */
    200: RunEventsResponse;
};

export type RunsEventsListResponse = RunsEventsListResponses[keyof RunsEventsListResponses];

export type RunsPromoteData = {
    body: PromoteRunRequest;
    path: {
        /**
         * Run id.
         */
        id: string;
    };
    query?: never;
    url: '/v1/runs/{id}/promote';
};

export type RunsPromoteErrors = {
    /**
     * Validation error. Request shape did not match the spec.
     */
    400: ApiErrorEnvelope;
    /**
     * Missing or invalid API key
     */
    401: ApiErrorEnvelope;
    /**
     * API key lacks required scope
     */
    403: ApiErrorEnvelope;
    /**
     * Resource not found
     */
    404: ApiErrorEnvelope;
    /**
     * Payload too large. Upload exceeded the per-request size cap.
     */
    413: ApiErrorEnvelope;
    /**
     * Rate limit exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * Internal server error
     */
    500: ApiErrorEnvelope;
};

export type RunsPromoteError = RunsPromoteErrors[keyof RunsPromoteErrors];

export type RunsPromoteResponses = {
    /**
     * Created or updated a dataset example from the run
     */
    200: PromoteRunResponse;
};

export type RunsPromoteResponse = RunsPromoteResponses[keyof RunsPromoteResponses];

export type RunsRerunData = {
    body?: never;
    path: {
        /**
         * Source run id to retry.
         */
        id: string;
    };
    query?: {
        /**
         * Version for the new run. `original` pins the source run. Defaults to latest.
         */
        version?: string;
        /**
         * Seconds to wait before returning (max 600). Omit for async.
         */
        wait_for_completion?: number;
    };
    url: '/v1/runs/{id}/rerun';
};

export type RunsRerunErrors = {
    /**
     * Validation error. Request shape did not match the spec.
     */
    400: ApiErrorEnvelope;
    /**
     * Missing or invalid API key
     */
    401: ApiErrorEnvelope;
    /**
     * API key lacks required scope
     */
    403: ApiErrorEnvelope;
    /**
     * Resource not found
     */
    404: ApiErrorEnvelope;
    /**
     * Payload too large. Upload exceeded the per-request size cap.
     */
    413: ApiErrorEnvelope;
    /**
     * Rate limit exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * Internal server error
     */
    500: ApiErrorEnvelope;
};

export type RunsRerunError = RunsRerunErrors[keyof RunsRerunErrors];

export type RunsRerunResponses = {
    /**
     * Rerun completed while waiting
     */
    200: Run;
    /**
     * Rerun accepted (async)
     */
    201: RunAccepted;
    /**
     * Wait expired with a non-terminal status — poll GET /api/v1/runs/:id
     */
    202: RunAccepted;
};

export type RunsRerunResponse = RunsRerunResponses[keyof RunsRerunResponses];

export type RunsReviewsClearData = {
    body?: never;
    path: {
        /**
         * Run id.
         */
        id: string;
    };
    query?: never;
    url: '/v1/runs/{id}/reviews';
};

export type RunsReviewsClearErrors = {
    /**
     * Validation error. Request shape did not match the spec.
     */
    400: ApiErrorEnvelope;
    /**
     * Missing or invalid API key
     */
    401: ApiErrorEnvelope;
    /**
     * API key lacks required scope
     */
    403: ApiErrorEnvelope;
    /**
     * Resource not found
     */
    404: ApiErrorEnvelope;
    /**
     * Payload too large. Upload exceeded the per-request size cap.
     */
    413: ApiErrorEnvelope;
    /**
     * Rate limit exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * Internal server error
     */
    500: ApiErrorEnvelope;
};

export type RunsReviewsClearError = RunsReviewsClearErrors[keyof RunsReviewsClearErrors];

export type RunsReviewsClearResponses = {
    /**
     * Empty run review state.
     */
    200: RunReviewDetail;
};

export type RunsReviewsClearResponse = RunsReviewsClearResponses[keyof RunsReviewsClearResponses];

export type RunsReviewsGetData = {
    body?: never;
    path: {
        /**
         * Run id.
         */
        id: string;
    };
    query?: never;
    url: '/v1/runs/{id}/reviews';
};

export type RunsReviewsGetErrors = {
    /**
     * Validation error. Request shape did not match the spec.
     */
    400: ApiErrorEnvelope;
    /**
     * Missing or invalid API key
     */
    401: ApiErrorEnvelope;
    /**
     * API key lacks required scope
     */
    403: ApiErrorEnvelope;
    /**
     * Resource not found
     */
    404: ApiErrorEnvelope;
    /**
     * Payload too large. Upload exceeded the per-request size cap.
     */
    413: ApiErrorEnvelope;
    /**
     * Rate limit exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * Internal server error
     */
    500: ApiErrorEnvelope;
};

export type RunsReviewsGetError = RunsReviewsGetErrors[keyof RunsReviewsGetErrors];

export type RunsReviewsGetResponses = {
    /**
     * Run review metadata.
     */
    200: RunReviewDetail;
};

export type RunsReviewsGetResponse = RunsReviewsGetResponses[keyof RunsReviewsGetResponses];

export type RunsReviewsUpdateData = {
    body: RunReviewRequest;
    path: {
        /**
         * Run id.
         */
        id: string;
    };
    query?: never;
    url: '/v1/runs/{id}/reviews';
};

export type RunsReviewsUpdateErrors = {
    /**
     * Validation error. Request shape did not match the spec.
     */
    400: ApiErrorEnvelope;
    /**
     * Missing or invalid API key
     */
    401: ApiErrorEnvelope;
    /**
     * API key lacks required scope
     */
    403: ApiErrorEnvelope;
    /**
     * Resource not found
     */
    404: ApiErrorEnvelope;
    /**
     * Payload too large. Upload exceeded the per-request size cap.
     */
    413: ApiErrorEnvelope;
    /**
     * Rate limit exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * Internal server error
     */
    500: ApiErrorEnvelope;
};

export type RunsReviewsUpdateError = RunsReviewsUpdateErrors[keyof RunsReviewsUpdateErrors];

export type RunsReviewsUpdateResponses = {
    /**
     * Updated run review metadata.
     */
    200: RunReviewDetail;
};

export type RunsReviewsUpdateResponse = RunsReviewsUpdateResponses[keyof RunsReviewsUpdateResponses];

export type RunsReviewsExpectedGetData = {
    body?: never;
    path: {
        /**
         * Run id.
         */
        id: string;
    };
    query?: never;
    url: '/v1/runs/{id}/reviews/expected';
};

export type RunsReviewsExpectedGetErrors = {
    /**
     * Validation error. Request shape did not match the spec.
     */
    400: ApiErrorEnvelope;
    /**
     * Missing or invalid API key
     */
    401: ApiErrorEnvelope;
    /**
     * API key lacks required scope
     */
    403: ApiErrorEnvelope;
    /**
     * Resource not found
     */
    404: ApiErrorEnvelope;
    /**
     * Payload too large. Upload exceeded the per-request size cap.
     */
    413: ApiErrorEnvelope;
    /**
     * Rate limit exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * Internal server error
     */
    500: ApiErrorEnvelope;
};

export type RunsReviewsExpectedGetError = RunsReviewsExpectedGetErrors[keyof RunsReviewsExpectedGetErrors];

export type RunsReviewsExpectedGetResponses = {
    /**
     * Corrected artifact files.
     */
    200: RunReviewExpectedArtifacts;
};

export type RunsReviewsExpectedGetResponse = RunsReviewsExpectedGetResponses[keyof RunsReviewsExpectedGetResponses];

export type RunsReviewsExpectedCreateData = {
    body: RunReviewExpectedFileCopyRequest | RunReviewExpectedFileUploadRequest;
    path: {
        /**
         * Run id.
         */
        id: string;
    };
    query?: never;
    url: '/v1/runs/{id}/reviews/expected';
};

export type RunsReviewsExpectedCreateErrors = {
    /**
     * Validation error. Request shape did not match the spec.
     */
    400: ApiErrorEnvelope;
    /**
     * Missing or invalid API key
     */
    401: ApiErrorEnvelope;
    /**
     * API key lacks required scope
     */
    403: ApiErrorEnvelope;
    /**
     * Resource not found
     */
    404: ApiErrorEnvelope;
    /**
     * Payload too large. Upload exceeded the per-request size cap.
     */
    413: ApiErrorEnvelope;
    /**
     * Rate limit exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * Internal server error
     */
    500: ApiErrorEnvelope;
};

export type RunsReviewsExpectedCreateError = RunsReviewsExpectedCreateErrors[keyof RunsReviewsExpectedCreateErrors];

export type RunsReviewsExpectedCreateResponses = {
    /**
     * Corrected file created.
     */
    201: RunReviewExpectedFileMutationResponse;
};

export type RunsReviewsExpectedCreateResponse = RunsReviewsExpectedCreateResponses[keyof RunsReviewsExpectedCreateResponses];

export type RunsReviewsExpectedFileDeleteData = {
    body?: never;
    path: {
        /**
         * Run id.
         */
        id: string;
        /**
         * Corrected artifact file name or slash-delimited path, as returned by `GET /runs/{id}/reviews/expected`.
         */
        filename: string;
    };
    query?: never;
    url: '/v1/runs/{id}/reviews/expected/{filename}';
};

export type RunsReviewsExpectedFileDeleteErrors = {
    /**
     * Validation error. Request shape did not match the spec.
     */
    400: ApiErrorEnvelope;
    /**
     * Missing or invalid API key
     */
    401: ApiErrorEnvelope;
    /**
     * API key lacks required scope
     */
    403: ApiErrorEnvelope;
    /**
     * Resource not found
     */
    404: ApiErrorEnvelope;
    /**
     * Payload too large. Upload exceeded the per-request size cap.
     */
    413: ApiErrorEnvelope;
    /**
     * Rate limit exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * Internal server error
     */
    500: ApiErrorEnvelope;
};

export type RunsReviewsExpectedFileDeleteError = RunsReviewsExpectedFileDeleteErrors[keyof RunsReviewsExpectedFileDeleteErrors];

export type RunsReviewsExpectedFileDeleteResponses = {
    /**
     * Corrected file deleted; no response body.
     */
    204: void;
};

export type RunsReviewsExpectedFileDeleteResponse = RunsReviewsExpectedFileDeleteResponses[keyof RunsReviewsExpectedFileDeleteResponses];

export type RunsReviewsExpectedFileGetData = {
    body?: never;
    path: {
        /**
         * Run id.
         */
        id: string;
        /**
         * Corrected artifact file name or slash-delimited path, as returned by `GET /runs/{id}/reviews/expected`.
         */
        filename: string;
    };
    query?: never;
    url: '/v1/runs/{id}/reviews/expected/{filename}';
};

export type RunsReviewsExpectedFileGetErrors = {
    /**
     * Validation error. Request shape did not match the spec.
     */
    400: ApiErrorEnvelope;
    /**
     * Missing or invalid API key
     */
    401: ApiErrorEnvelope;
    /**
     * API key lacks required scope
     */
    403: ApiErrorEnvelope;
    /**
     * Resource not found
     */
    404: ApiErrorEnvelope;
    /**
     * Payload too large. Upload exceeded the per-request size cap.
     */
    413: ApiErrorEnvelope;
    /**
     * Rate limit exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * Internal server error
     */
    500: ApiErrorEnvelope;
};

export type RunsReviewsExpectedFileGetError = RunsReviewsExpectedFileGetErrors[keyof RunsReviewsExpectedFileGetErrors];

export type RunsReviewsExpectedFileGetResponses = {
    /**
     * Corrected file bytes.
     */
    200: Blob | File;
};

export type RunsReviewsExpectedFileGetResponse = RunsReviewsExpectedFileGetResponses[keyof RunsReviewsExpectedFileGetResponses];

export type RunsReviewsExpectedFileUpdateData = {
    body: RunReviewExpectedFileUpdateRequest;
    path: {
        /**
         * Run id.
         */
        id: string;
        /**
         * Corrected artifact file name or slash-delimited path, as returned by `GET /runs/{id}/reviews/expected`.
         */
        filename: string;
    };
    query?: never;
    url: '/v1/runs/{id}/reviews/expected/{filename}';
};

export type RunsReviewsExpectedFileUpdateErrors = {
    /**
     * Validation error. Request shape did not match the spec.
     */
    400: ApiErrorEnvelope;
    /**
     * Missing or invalid API key
     */
    401: ApiErrorEnvelope;
    /**
     * API key lacks required scope
     */
    403: ApiErrorEnvelope;
    /**
     * Resource not found
     */
    404: ApiErrorEnvelope;
    /**
     * Payload too large. Upload exceeded the per-request size cap.
     */
    413: ApiErrorEnvelope;
    /**
     * Rate limit exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * Internal server error
     */
    500: ApiErrorEnvelope;
};

export type RunsReviewsExpectedFileUpdateError = RunsReviewsExpectedFileUpdateErrors[keyof RunsReviewsExpectedFileUpdateErrors];

export type RunsReviewsExpectedFileUpdateResponses = {
    /**
     * Renamed corrected file.
     */
    200: RunReviewExpectedFileUpdateResponse;
};

export type RunsReviewsExpectedFileUpdateResponse = RunsReviewsExpectedFileUpdateResponses[keyof RunsReviewsExpectedFileUpdateResponses];

export type RunsScoresListData = {
    body?: never;
    path: {
        /**
         * Run id.
         */
        id: string;
    };
    query?: never;
    url: '/v1/runs/{id}/scores';
};

export type RunsScoresListErrors = {
    /**
     * Validation error. Request shape did not match the spec.
     */
    400: ApiErrorEnvelope;
    /**
     * Missing or invalid API key
     */
    401: ApiErrorEnvelope;
    /**
     * API key lacks required scope
     */
    403: ApiErrorEnvelope;
    /**
     * Resource not found
     */
    404: ApiErrorEnvelope;
    /**
     * Payload too large. Upload exceeded the per-request size cap.
     */
    413: ApiErrorEnvelope;
    /**
     * Rate limit exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * Internal server error
     */
    500: ApiErrorEnvelope;
};

export type RunsScoresListError = RunsScoresListErrors[keyof RunsScoresListErrors];

export type RunsScoresListResponses = {
    /**
     * Per-evaluator scores for the run
     */
    200: RunScoresResponse;
};

export type RunsScoresListResponse = RunsScoresListResponses[keyof RunsScoresListResponses];

export type RunsStepsListData = {
    body?: never;
    path: {
        /**
         * Run id
         */
        id: string;
    };
    query?: never;
    url: '/v1/runs/{id}/steps';
};

export type RunsStepsListErrors = {
    /**
     * Validation error. Request shape did not match the spec.
     */
    400: ApiErrorEnvelope;
    /**
     * Missing or invalid API key
     */
    401: ApiErrorEnvelope;
    /**
     * API key lacks required scope
     */
    403: ApiErrorEnvelope;
    /**
     * Resource not found
     */
    404: ApiErrorEnvelope;
    /**
     * Payload too large. Upload exceeded the per-request size cap.
     */
    413: ApiErrorEnvelope;
    /**
     * Rate limit exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * Internal server error
     */
    500: ApiErrorEnvelope;
};

export type RunsStepsListError = RunsStepsListErrors[keyof RunsStepsListErrors];

export type RunsStepsListResponses = {
    /**
     * Run steps
     */
    200: RunStepsResponse;
};

export type RunsStepsListResponse = RunsStepsListResponses[keyof RunsStepsListResponses];

export type RunsStepsGetData = {
    body?: never;
    path: {
        /**
         * Run id
         */
        id: string;
        /**
         * Step execution id
         */
        stepExecutionId: string;
    };
    query?: never;
    url: '/v1/runs/{id}/steps/{stepExecutionId}';
};

export type RunsStepsGetErrors = {
    /**
     * Validation error. Request shape did not match the spec.
     */
    400: ApiErrorEnvelope;
    /**
     * Missing or invalid API key
     */
    401: ApiErrorEnvelope;
    /**
     * API key lacks required scope
     */
    403: ApiErrorEnvelope;
    /**
     * Resource not found
     */
    404: ApiErrorEnvelope;
    /**
     * Payload too large. Upload exceeded the per-request size cap.
     */
    413: ApiErrorEnvelope;
    /**
     * Rate limit exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * Internal server error
     */
    500: ApiErrorEnvelope;
};

export type RunsStepsGetError = RunsStepsGetErrors[keyof RunsStepsGetErrors];

export type RunsStepsGetResponses = {
    /**
     * Full step execution
     */
    200: RunStepDetailResponse;
};

export type RunsStepsGetResponse = RunsStepsGetResponses[keyof RunsStepsGetResponses];

export type RunsTraceGetData = {
    body?: never;
    path: {
        /**
         * Run id.
         */
        id: string;
    };
    query?: never;
    url: '/v1/runs/{id}/trace';
};

export type RunsTraceGetErrors = {
    /**
     * Validation error. Request shape did not match the spec.
     */
    400: ApiErrorEnvelope;
    /**
     * Missing or invalid API key
     */
    401: ApiErrorEnvelope;
    /**
     * API key lacks required scope
     */
    403: ApiErrorEnvelope;
    /**
     * Resource not found
     */
    404: ApiErrorEnvelope;
    /**
     * Payload too large. Upload exceeded the per-request size cap.
     */
    413: ApiErrorEnvelope;
    /**
     * Rate limit exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * Internal server error
     */
    500: ApiErrorEnvelope;
};

export type RunsTraceGetError = RunsTraceGetErrors[keyof RunsTraceGetErrors];

export type RunsTraceGetResponses = {
    /**
     * Run trace events.
     */
    200: RunTraceResponse;
};

export type RunsTraceGetResponse = RunsTraceGetResponses[keyof RunsTraceGetResponses];

export type RunsUsageGetData = {
    body?: never;
    path: {
        /**
         * Run id
         */
        id: string;
    };
    query?: never;
    url: '/v1/runs/{id}/usage';
};

export type RunsUsageGetErrors = {
    /**
     * Validation error. Request shape did not match the spec.
     */
    400: ApiErrorEnvelope;
    /**
     * Missing or invalid API key
     */
    401: ApiErrorEnvelope;
    /**
     * API key lacks required scope
     */
    403: ApiErrorEnvelope;
    /**
     * Resource not found
     */
    404: ApiErrorEnvelope;
    /**
     * Payload too large. Upload exceeded the per-request size cap.
     */
    413: ApiErrorEnvelope;
    /**
     * Rate limit exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * Internal server error
     */
    500: ApiErrorEnvelope;
};

export type RunsUsageGetError = RunsUsageGetErrors[keyof RunsUsageGetErrors];

export type RunsUsageGetResponses = {
    /**
     * Run usage
     */
    200: RunUsageResponse;
};

export type RunsUsageGetResponse = RunsUsageGetResponses[keyof RunsUsageGetResponses];

export type TemplatesListData = {
    body?: never;
    path?: never;
    query?: {
        limit?: number;
        offset?: number;
    };
    url: '/v1/templates';
};

export type TemplatesListErrors = {
    /**
     * Validation error. Request shape did not match the spec.
     */
    400: ApiErrorEnvelope;
    /**
     * Missing or invalid API key
     */
    401: ApiErrorEnvelope;
    /**
     * API key lacks required scope
     */
    403: ApiErrorEnvelope;
    /**
     * Resource not found
     */
    404: ApiErrorEnvelope;
    /**
     * Payload too large. Upload exceeded the per-request size cap.
     */
    413: ApiErrorEnvelope;
    /**
     * Rate limit exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * Internal server error
     */
    500: ApiErrorEnvelope;
};

export type TemplatesListError = TemplatesListErrors[keyof TemplatesListErrors];

export type TemplatesListResponses = {
    /**
     * Template resources
     */
    200: ListTemplatesResponse;
};

export type TemplatesListResponse = TemplatesListResponses[keyof TemplatesListResponses];

export type TemplatesCreateData = {
    body: TemplateFileReferenceRequest;
    path?: never;
    query?: never;
    url: '/v1/templates';
};

export type TemplatesCreateErrors = {
    /**
     * Validation error. Request shape did not match the spec.
     */
    400: ApiErrorEnvelope;
    /**
     * Missing or invalid API key
     */
    401: ApiErrorEnvelope;
    /**
     * API key lacks required scope
     */
    403: ApiErrorEnvelope;
    /**
     * Resource not found
     */
    404: ApiErrorEnvelope;
    /**
     * Payload too large. Upload exceeded the per-request size cap.
     */
    413: ApiErrorEnvelope;
    /**
     * Validation error. Request shape did not match the spec.
     */
    422: ApiErrorEnvelope;
    /**
     * Rate limit exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * Internal server error
     */
    500: ApiErrorEnvelope;
};

export type TemplatesCreateError = TemplatesCreateErrors[keyof TemplatesCreateErrors];

export type TemplatesCreateResponses = {
    /**
     * Created template
     */
    201: CreatedTemplate;
};

export type TemplatesCreateResponse = TemplatesCreateResponses[keyof TemplatesCreateResponses];

export type TemplatesDeleteData = {
    body?: never;
    path: {
        /**
         * Logical template id (tmpl_…).
         */
        id: string;
    };
    query?: never;
    url: '/v1/templates/{id}';
};

export type TemplatesDeleteErrors = {
    /**
     * Validation error. Request shape did not match the spec.
     */
    400: ApiErrorEnvelope;
    /**
     * Missing or invalid API key
     */
    401: ApiErrorEnvelope;
    /**
     * API key lacks required scope
     */
    403: ApiErrorEnvelope;
    /**
     * Resource not found
     */
    404: ApiErrorEnvelope;
    /**
     * Payload too large. Upload exceeded the per-request size cap.
     */
    413: ApiErrorEnvelope;
    /**
     * Rate limit exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * Internal server error
     */
    500: ApiErrorEnvelope;
};

export type TemplatesDeleteError = TemplatesDeleteErrors[keyof TemplatesDeleteErrors];

export type TemplatesDeleteResponses = {
    /**
     * Template deleted
     */
    200: DeleteTemplateResponse;
};

export type TemplatesDeleteResponse = TemplatesDeleteResponses[keyof TemplatesDeleteResponses];

export type TemplatesGetData = {
    body?: never;
    path: {
        /**
         * Logical template id (tmpl_…).
         */
        id: string;
    };
    query?: never;
    url: '/v1/templates/{id}';
};

export type TemplatesGetErrors = {
    /**
     * Validation error. Request shape did not match the spec.
     */
    400: ApiErrorEnvelope;
    /**
     * Missing or invalid API key
     */
    401: ApiErrorEnvelope;
    /**
     * API key lacks required scope
     */
    403: ApiErrorEnvelope;
    /**
     * Resource not found
     */
    404: ApiErrorEnvelope;
    /**
     * Payload too large. Upload exceeded the per-request size cap.
     */
    413: ApiErrorEnvelope;
    /**
     * Rate limit exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * Internal server error
     */
    500: ApiErrorEnvelope;
};

export type TemplatesGetError = TemplatesGetErrors[keyof TemplatesGetErrors];

export type TemplatesGetResponses = {
    /**
     * Template inspection
     */
    200: Template;
};

export type TemplatesGetResponse = TemplatesGetResponses[keyof TemplatesGetResponses];

export type TemplatesReplaceData = {
    body: TemplateReplaceRequest;
    path: {
        /**
         * Logical template id (tmpl_…).
         */
        id: string;
    };
    query?: never;
    url: '/v1/templates/{id}';
};

export type TemplatesReplaceErrors = {
    /**
     * Validation error. Request shape did not match the spec.
     */
    400: ApiErrorEnvelope;
    /**
     * Missing or invalid API key
     */
    401: ApiErrorEnvelope;
    /**
     * API key lacks required scope
     */
    403: ApiErrorEnvelope;
    /**
     * Resource not found
     */
    404: ApiErrorEnvelope;
    /**
     * Payload too large. Upload exceeded the per-request size cap.
     */
    413: ApiErrorEnvelope;
    /**
     * Validation error. Request shape did not match the spec.
     */
    422: ApiErrorEnvelope;
    /**
     * Rate limit exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * Internal server error
     */
    500: ApiErrorEnvelope;
};

export type TemplatesReplaceError = TemplatesReplaceErrors[keyof TemplatesReplaceErrors];

export type TemplatesReplaceResponses = {
    /**
     * Updated template
     */
    200: Template;
};

export type TemplatesReplaceResponse = TemplatesReplaceResponses[keyof TemplatesReplaceResponses];

export type TemplatesContentGetData = {
    body?: never;
    path: {
        /**
         * Logical template id (tmpl_…).
         */
        id: string;
    };
    query?: {
        /**
         * Immutable revision id (tmpr_…). Omit for the current content.
         */
        revisionId?: string;
    };
    url: '/v1/templates/{id}/content';
};

export type TemplatesContentGetErrors = {
    /**
     * Validation error. Request shape did not match the spec.
     */
    400: ApiErrorEnvelope;
    /**
     * Missing or invalid API key
     */
    401: ApiErrorEnvelope;
    /**
     * API key lacks required scope
     */
    403: ApiErrorEnvelope;
    /**
     * Resource not found
     */
    404: ApiErrorEnvelope;
    /**
     * Payload too large. Upload exceeded the per-request size cap.
     */
    413: ApiErrorEnvelope;
    /**
     * Rate limit exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * Internal server error
     */
    500: ApiErrorEnvelope;
};

export type TemplatesContentGetError = TemplatesContentGetErrors[keyof TemplatesContentGetErrors];

export type TemplatesContentGetResponses = {
    /**
     * Template file bytes (DOCX or XLSX).
     */
    200: Blob | File;
};

export type TemplatesContentGetResponse = TemplatesContentGetResponses[keyof TemplatesContentGetResponses];

export type TemplatesStagingData = {
    body: TemplateStagingRequest;
    path: {
        /**
         * Logical template id (tmpl_…).
         */
        id: string;
    };
    query?: never;
    url: '/v1/templates/{id}/staging';
};

export type TemplatesStagingErrors = {
    /**
     * Validation error. Request shape did not match the spec.
     */
    400: ApiErrorEnvelope;
    /**
     * Missing or invalid API key
     */
    401: ApiErrorEnvelope;
    /**
     * API key lacks required scope
     */
    403: ApiErrorEnvelope;
    /**
     * Resource not found
     */
    404: ApiErrorEnvelope;
    /**
     * Conflict. The resource is in a state that forbids the request.
     */
    409: ApiErrorEnvelope;
    /**
     * Payload too large. Upload exceeded the per-request size cap.
     */
    413: ApiErrorEnvelope;
    /**
     * Rate limit exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * Internal server error
     */
    500: ApiErrorEnvelope;
};

export type TemplatesStagingError = TemplatesStagingErrors[keyof TemplatesStagingErrors];

export type TemplatesStagingResponses = {
    /**
     * Staging action applied
     */
    200: TemplateStagingResponse;
};

export type TemplatesStagingResponse = TemplatesStagingResponses[keyof TemplatesStagingResponses];