/**
 * Generated by scripts/generate-contracts.mjs from
 * ui/src/api/generated/openapi.ts. Do not edit this package-local copy.
 */
/**
 * This file was auto-generated by openapi-typescript.
 * Do not make direct changes to the file.
 */
export interface paths {
    "/factory-sessions/{session_id}/work": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * List work for one session
         * @description Lists current work tokens from the engine state snapshot owned by the explicitly selected live factory session.
         */
        get: operations["listWorkBySessionId"];
        put?: never;
        /**
         * Submit work for one session
         * @description Submits one work item to the explicitly selected live factory session. Unknown session identifiers return NOT_FOUND instead of falling back to the default session.
         */
        post: operations["submitWorkBySessionId"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/factory-sessions/{session_id}/invocations": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Invoke one factory session and return its primary result
         * @description Live-session compatibility API for invocations against an already-open factory session. This route is not the primary durable workflow execution entrypoint; use POST /factory-sessions/async or POST /factory-sessions/sync for dynamic workflow-backed durable execution. Requests may use legacy text-first compatibility content or structured invocationSignature args. Structured args normalize through the shared backend argument resolver, while content preserves the legacy compatibility carrier. When invocationReturn is omitted, runtimes use the documented SUBMITTED_WORK_TERMINAL fallback. Supplying ambiguous input sources is rejected with INVOCATION_INPUT_SOURCE_CONFLICT or INVOCATION_ARGUMENT_SOURCE_CONFLICT. Empty selected text input is rejected with INVOCATION_INPUT_EMPTY. If no primary output can be resolved, the response status is FAILED with INVOCATION_PRIMARY_RESULT_UNRESOLVED and no primaryResult.
         */
        post: operations["invokeFactorySessionBySessionId"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/factory-sessions/{session_id}/work/staged-files": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Stage one submit-work file for one session
         * @description Accepts one dashboard-authored file payload for the selected factory session, stores it behind a backend-owned staged reference, and returns the staged reference plus identifying metadata for structured submit-work items.
         */
        post: operations["stageSubmitWorkFileBySessionId"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/factory-sessions/{session_id}/work-requests/{request_id}": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        /**
         * Upsert work request for one session
         * @description Submits or retries one canonical work request batch against the explicitly selected live factory session. Unknown session identifiers return NOT_FOUND instead of falling back to the default session.
         */
        put: operations["upsertWorkRequestBySessionId"];
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/factory-sessions/{session_id}/work/{id}": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Get work for one session
         * @description Returns one work item by work or token identifier from the current marking owned by the explicitly selected live factory session.
         */
        get: operations["getWorkBySessionId"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/factory-sessions/{session_id}/work/{id}/move": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Move work to another state for one session
         * @description Moves an existing work item to a named authored marking state in the selected live factory session. Rejects moves while the work item is consumed by an active dispatch.
         */
        post: operations["moveWorkBySessionId"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/factory-sessions/{session_id}/events": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Stream factory events for one session
         * @description Canonical FactoryEvent Server-Sent Events stream for dashboard, Factory Session, and durable replay traffic scoped to one explicitly selected session_id. OpenAPI 3.0.3 cannot structurally declare SSE event ids, comment keepalives, or per-connection ordering guarantees, so the lifecycle rules below are documented in operation prose rather than as unsupported response fields.
         *     Event ordering: the server sends retained history first in ascending tick order, then continues on the same connection with live FactoryEvent records. Each text/event-stream data frame is serialized JSON matching the FactoryEvent union referenced by x-event-schema.
         *     Reconnect cursors: pass after_event_id or after_sequence to receive only events recorded after the acknowledged point. When both are present, after_event_id wins. For session-scoped streams, after_sequence prefers FactoryEvent.context.sessionSequence when that field is present; otherwise it falls back to FactoryEvent.context.sequence. Omitting both cursors starts replay from the beginning of the session's currently retained history.
         *     Replay bounds: live sessions replay only events retained for the current stream generation of the targeted Factory Session. Durable execution session identifiers replay persisted canonical records for that session without crossing into another session. Cursors that no longer match the retained history boundary return typed invalid-cursor handling (400 on SSE open, cursor_stale on JSON reconnect probe) rather than silently skipping events.
         *     Identity handshake before reconnect: compare the response headers X-Factory-Session-Backend-Scope-Id, X-Factory-Session-Logical-Session-Key-Id, X-Factory-Session-Factory-Session-Id, and X-Factory-Session-Stream-Generation-Id with the latest sync-preflight or session-read identity set before reusing a persisted reconnect cursor or stream-derived cache. A changed streamGenerationId means the current stream generation invalidates prior cursors even when factorySessionId is unchanged.
         *     Bounded retained-history reads: X-Factory-Session-Retained-Event-Count reports exactly how many leading text/event-stream data frames make up the already-committed retained-history prefix, captured at subscribe time. Clients that need a point-in-time snapshot of committed history can read exactly this many records and stop, instead of inferring completion from stream quiescence.
         *     Keepalives: successful SSE responses use Connection keep-alive. Idle periods may occur while the Factory Session is waiting for new canonical events; clients must treat these as normal waiting state rather than terminal stream completion unless the HTTP connection closes.
         *     Expired-cursor recovery: when Accept includes application/json, the same route acts as a reconnect probe and returns FactorySessionEventStreamRecovery instead of opening Server-Sent Events. cursor_stale outcomes tell clients to retry with omitAfterEventId and omitAfterSequence set so the next open omits stale cursors. UNKNOWN_SESSION means the selector does not resolve to a live or durable session and never falls back to the default session.
         *     Unknown session identifiers return NOT_FOUND instead of falling back to the default session.
         */
        get: operations["getEventsBySessionId"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/factory-sessions/{session_id}/response-events": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Stream ephemeral response events for one Factory Session
         * @description Streams ephemeral FactoryResponseEvent observation records for the explicitly selected Factory Session. These records are outside canonical FactoryEvent replay and never derive canonical Factory state. The connection first sends retained matching records in ascending response sequence and then continues with live matching records. Each SSE id is the decimal FactoryResponseEvent.sequence so reconnect clients can acknowledge it with after_sequence. Omitting after_sequence starts at the beginning of retained history. When a cursor predates retained history, the first emitted record is STREAM_GAP and describes the lost range rather than silently skipping it. An unknown session_id returns a typed 404 and never falls back to the current or default session.
         */
        get: operations["getFactoryResponseEventsBySessionId"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/factory-sessions/{session_id}/sync-preflight": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Validate cached session sync state for one session
         * @description Returns the canonical backend-owned session sync identity set and validates an optional reconnect cursor before the dashboard restores cached checkpoint state or opens the event stream. This route accepts `~default` as a session selector, but clients must persist the returned `factorySessionId` field rather than treating `~default` as a durable live-session identifier.
         */
        get: operations["getFactorySessionSyncPreflightBySessionId"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/status": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Get runtime status
         * @description Returns the current factory lifecycle status, token category counts, and resource availability from the aggregate engine snapshot.
         */
        get: operations["getStatus"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/models": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * List managed runtimes
         * @description Lists named managed runtimes exposed by the currently loaded runtime configuration together with readiness, lifecycle state, locality, supported operations, and resource summary data using the managed-runtime contract.
         */
        get: operations["listModels"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/models/{model_name}": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Inspect one managed runtime
         * @description Returns one managed runtime's readiness, lifecycle state, supported operations, resource metadata, worker capabilities, and diagnostics for the currently loaded runtime configuration.
         */
        get: operations["getModel"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/models/{model_name}/invocations": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Invoke one discovered model directly
         * @description Invokes one discovered model through its declared provider-agnostic operation contract using canonical `WorkContent` input and optional slot-binding overrides. Non-streaming clients receive JSON metadata, while audio-producing operations can return a streamed audio body when requested.
         */
        post: operations["invokeModel"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/models/{model_name}/pull": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Pull or install one managed runtime
         * @description Pulls or installs required managed runtime assets into the managed cache using one source-agnostic customer action. Cloud-backed runtimes and unsupported local targets return actionable errors instead of silently succeeding.
         */
        post: operations["pullModel"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/factory-sessions/{session_id}/status": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Get runtime status for one session
         * @description Returns the current factory lifecycle status, token category counts, and resource availability from the aggregate engine snapshot owned by the explicitly selected live factory session.
         */
        get: operations["getStatusBySessionId"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/provider-sessions/detail": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Get provider session details
         * @description Returns parsed provider-session details using a provider-neutral response schema. The browser supplies provider, kind, and identifier query parameters; the server resolves the matching session file under the configured provider sessions root and never accepts a raw filesystem path. Only Codex (`codex`) sessions are currently loadable for this endpoint.
         */
        get: operations["getProviderSessionDetails"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/factories/preview": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Preview JavaScript orchestrator factory source
         * @description Canonical Factory preview surface for JavaScript orchestrator factories. Resolves orchestrator source, validates JavaScript or TypeScript source without execution, and projects effective policy, artifact-root, and structured-result constraints before Factory Session start.
         */
        post: operations["previewFactory"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/factory-validations": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Validate factory definition
         * @description Validates a submitted complete factory definition and returns canonical validation targets without persisting or activating the factory.
         */
        post: operations["validateFactory"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/factory-sessions/async": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Start durable factory session execution asynchronously
         * @description Primary durable execution entrypoint for dynamic workflow-backed factory sessions. Accepts the normalized FactorySessionExecutionRequest, resolves the requested source, and returns session identity plus polling links without waiting for terminal completion. WORKFLOW_FILE and WORKFLOW_NAME sources resolve in order: project `.claude/workflows`, user `~/.you-agent-factory/workflows`, package-relative workflow directories, built-in/global JavaScript factories, then explicit factory lookup when requested or required. Replaying the same requestId with the same normalized source, args, orchestrator, and requested policy returns the existing session instead of starting duplicate work. Reusing requestId with materially different inputs returns 409 Conflict with EXECUTION_REQUEST_ID_CONFLICT.
         */
        post: operations["startDurableFactorySessionAsync"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/factory-sessions/sync": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Start durable factory session execution synchronously
         * @description Durable execution entrypoint that waits for terminal completion or a sync timeout before returning. Accepts the same normalized FactorySessionExecutionRequest as POST /factory-sessions/async and uses the same workflow source resolution order and requestId idempotency semantics. When the session reaches a terminal result before timeout, the response includes FactorySessionResult. Timeout responses use syncOutcome = TIMED_OUT and must not imply the session was canceled unless wait.cancelOnTimeout was explicitly true in the request.
         */
        post: operations["startDurableFactorySessionSync"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/factory-sessions": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * List factory sessions
         * @description Lists factory sessions for the requested scope. live returns workspace sessions kept open by the runtime host, including the reserved default session. persisted returns durable execution sessions stored outside the live workspace. all returns both live and persisted summaries. Persisted summaries cover active, terminal, interrupted, and stale-lease durable sessions without exposing raw workflow source or unrestricted host paths.
         */
        get: operations["listFactorySessions"];
        put?: never;
        /**
         * Open another live factory session
         * @description Live-session compatibility API for opening workspace tabs from a folder path and optional target selection. This route is not the primary durable workflow execution entrypoint; use POST /factory-sessions/async or POST /factory-sessions/sync for dynamic workflow-backed durable execution. When `validateOnly` is true, the request validates the folder and optional target selection without creating a session. When the folder exposes more than one runnable target and no explicit target was provided, the response returns typed target metadata instead of creating a session yet.
         */
        post: operations["openFactorySession"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/factory-sessions/{session_id}/result": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Get one live factory session result
         * @description Returns the terminal session result for one live factory session. JavaScript workflow sessions expose final result and checkpoint artifact refs without raw checkpoint bodies or unrestricted host paths. Durable workflow execution results use GET /factory-sessions/{session_id}/results instead.
         */
        get: operations["getFactorySessionResult"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/factory-sessions/{session_id}/results": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Get durable factory session results
         * @description Returns final or partial durable workflow outputs for one factory session. Supports mode=final|partial and includeArtifacts=true|false without requiring clients to scrape event streams or logs. Non-ready, unavailable, and failed-with-partial states return typed FactorySessionResult bodies with session identity, current session status, and actionable failure or availability details when known.
         */
        get: operations["getFactorySessionResults"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/factory-sessions/{session_id}/dispatches": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * List durable factory session dispatches
         * @description Returns dispatch summaries for one factory session with dispatch id, status, dispatch kind, phase, label, attempt, runner/model metadata when available, provider-session correlation refs, usage, warnings, output artifact ids, and failure details. Petri and JavaScript dispatches share the neutral summary shape; orchestrator-specific detail is available on GET /factory-sessions/{session_id}/dispatches/{dispatch_id}.
         */
        get: operations["listFactorySessionDispatches"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/factory-sessions/{session_id}/dispatches/{dispatch_id}": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Get one durable factory session dispatch
         * @description Returns one dispatch detail for the targeted session. Petri transition dispatches expose optional petri projections and JavaScript workflow dispatches expose optional javascript projections without forcing orchestrator-specific fields on neutral clients.
         */
        get: operations["getFactorySessionDispatch"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/factory-sessions/{session_id}/artifacts": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * List durable factory session artifacts
         * @description Returns artifact metadata for one factory session with artifact id, kind, visibility, content hash, size, created time, dispatch relation, secret-redaction counts, audit mode, and safe retrieval refs without exposing unrestricted host filesystem paths by default.
         */
        get: operations["listFactorySessionArtifacts"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/factory-sessions/{session_id}/artifacts/{artifact_id}": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Get one durable factory session artifact
         * @description Returns artifact metadata plus inlined content or a safe content ref according to artifact visibility and payload size. Responses must not expose unrestricted host filesystem paths by default.
         */
        get: operations["getFactorySessionArtifact"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/factory-sessions/{session_id}/approve": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Approve one durable factory session
         * @description Approves requested orchestrator policy for one durable factory session in AWAITING_APPROVAL state. Returns the updated session or a typed lifecycle-control outcome for no-op, invalid-state, terminal-session, or conflict cases. Approval responses include the effective policy hash and approval preview identity when available.
         */
        post: operations["approveFactorySession"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/factory-sessions/{session_id}/pause": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Pause one Factory Session
         * @description Pauses one live or durable Factory Session while preserving inspectable partial results, dispatches, artifacts, and buffered inbound submissions or completed worker results. Live workspace sessions use the same route family as durable execution sessions. Automatic progression stops until resume. Returns the updated session or a typed lifecycle-control outcome for no-op, invalid-state, terminal-session, or conflict cases.
         */
        post: operations["pauseFactorySession"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/factory-sessions/{session_id}/resume": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Resume one Factory Session
         * @description Resumes one paused live or durable Factory Session while preserving inspectable partial results, dispatches, and artifacts. Live workspace sessions use the same route family as durable execution sessions. Wakes the runtime internally and drains ready buffered submissions and completed worker results without requiring a new external signal. Returns the updated session or a typed lifecycle-control outcome for no-op, invalid-state, terminal-session, or conflict cases.
         */
        post: operations["resumeFactorySession"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/factory-sessions/{session_id}/cancel": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Cancel one durable factory session
         * @description Requests graceful cancellation for one durable factory session while preserving inspectable partial results, dispatches, and artifacts. Returns the updated session or a typed lifecycle-control outcome for no-op, invalid-state, terminal-session, or conflict cases.
         */
        post: operations["cancelFactorySession"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/factory-sessions/{session_id}/terminate": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Terminate one durable factory session
         * @description Forcefully terminates one durable factory session while preserving inspectable partial results, dispatches, and artifacts. Returns the updated session or a typed lifecycle-control outcome for no-op, invalid-state, terminal-session, or conflict cases.
         */
        post: operations["terminateFactorySession"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/factory-sessions/{session_id}/retry-dispatch": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Retry one durable factory session dispatch
         * @description Retries one failed or interrupted dispatch within the targeted durable factory session. The response links the retry to the session and dispatch state and preserves inspectable partial results, dispatches, and artifacts after the control operation.
         */
        post: operations["retryFactorySessionDispatch"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/factory-sessions/{session_id}/interrupt-dispatch": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Interrupt one active durable factory session dispatch
         * @description Interrupts one active dispatch within the targeted durable factory session. The response links the interruption to the session and dispatch state and preserves inspectable partial results, dispatches, and artifacts after the control operation.
         */
        post: operations["interruptFactorySessionDispatch"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/factory-sessions/{session_id}/partial-result": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Get one factory session partial result
         * @description Returns the current partial result for one live JavaScript workflow session. Checkpoint artifact refs and summaries are returned without raw checkpoint bodies or unrestricted host paths.
         */
        get: operations["getFactorySessionPartialResult"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/factory-sessions/{session_id}": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Get one factory session
         * @description Returns the canonical factory session inspection read model. Live workspace sessions return the existing FactorySession projection with orchestrator identity, lifecycle status, progress, budgets, usage, and kind-specific runtime projections. Durable execution sessions return a durable read model with status, resolved source ref/hash, phase summaries, progress counts, budgets, usage, policy hash, artifact refs, result summary, failure details, and lifecycle timestamps. Responses expose public source refs and hashes without raw workflow source or diagnostic artifacts.
         */
        get: operations["getFactorySession"];
        put?: never;
        post?: never;
        /**
         * Close one live factory session
         * @description Stops the selected live factory session, removes it from the workspace session list, and leaves all remaining sessions running unchanged.
         */
        delete: operations["closeFactorySession"];
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/factory-sessions/{session_id}/factory": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Get current factory for one session
         * @description Returns the current factory definition owned by the explicitly selected live session together with server-managed version metadata for replacement saves. Unknown session identifiers return NOT_FOUND instead of falling back to the default session.
         */
        get: operations["getCurrentFactoryBySessionId"];
        /**
         * Save factory for one session
         * @description Submits one complete factory definition to the explicitly selected live session using an explicit save mode. Omitted `mode` defaults to `REPLACE_CURRENT`, which replaces the factory already current in the session. `UPSERT_NAMED_AND_ACTIVATE` persists under the session factory root using `factory.name`, updates the session current-factory pointer, and activates that runtime when idle. Clients should echo the server-managed `factory.version` field from the latest current-factory read for replacement saves. Unknown session identifiers return NOT_FOUND instead of falling back to the default session.
         */
        put: operations["saveCurrentFactoryBySessionId"];
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/factory-sessions/{session_id}/factory/workstations/{workstation_name}/prompt-template-contract": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Get workstation prompt-template contract
         * @description Returns the authoritative prompt-variable reference and unavailable-access patterns for the selected current-factory workstation editing context.
         */
        get: operations["getCurrentFactoryWorkstationPromptTemplateContractBySessionId"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/factory-sessions/{session_id}/factory/workstations/{workstation_name}/prompt-template-validation": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Validate workstation prompt template
         * @description Validates a prompt draft against the authoritative current-factory workstation prompt contract and returns typed syntax or variable diagnostics.
         */
        post: operations["validateCurrentFactoryWorkstationPromptTemplateBySessionId"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/packaged-factories": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * List built-in packaged factories
         * @description Returns the backend-owned built-in factory catalog, including the selected artifacts the dashboard displays. The dashboard must consume this API rather than importing the publication package.
         */
        get: operations["listPackagedFactories"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
}
export type webhooks = Record<string, never>;
export interface components {
    schemas: {
        SubmitWorkRequest: {
            /** @description Optional authored name for this single-work submission. When omitted, the server assigns the single-work request's canonical identity. */
            name?: string;
            /** @description Configured work type name from factory.json to submit to. */
            workTypeName: string;
            /** @description Explicit chaining-trace identifier for the submitted work. */
            currentChainingTraceId?: string;
            /** @description Legacy trace identifier retained for compatibility; prefer currentChainingTraceId. */
            traceId?: string;
            /** @description Ordered submit-work items authored by the dashboard for structured multimodal submission. */
            items?: components["schemas"]["SubmitWorkItemList"];
            /** @description Optional canonical ordered work content parts for this submission. */
            content?: components["schemas"]["WorkContent"];
            /** @description Opaque work payload forwarded as raw JSON. */
            payload?: unknown;
            tags?: components["schemas"]["StringMap"];
            /** @description Optional token-level runtime relations preserved on the submitted work item. */
            relations?: components["schemas"]["SubmitRelation"][];
        };
        SubmitRelation: {
            type: components["schemas"]["RelationType"];
            /** @description Target runtime work identifier for the relation. */
            targetWorkId: string;
            /** @description Required target state before the dependency can proceed. */
            requiredState?: string;
        };
        SubmitWorkResponse: {
            /** @description Trace identifier for the submitted work request batch. */
            traceId: string;
            /** @description Stable request identifier assigned during normalization. */
            requestId: string;
            /** @description False when the same requestId was already accepted (idempotent replay). */
            accepted: boolean;
            /** @description Primary work identifier for single-work submits (batch-<requestId>-<name> when omitted). */
            workId?: string;
            /** @description Submitted work display name. */
            name?: string;
            /** @description Configured work type name for the submitted work. */
            workTypeName?: string;
            /** @description Factory session that accepted the submit (~default for POST /work). */
            sessionId?: string;
        };
        /**
         * @description Invocation input source category. `text` is the only implemented API source for the text-first invocation slice. `fileRef` and `audioStream` are reserved future source categories and are not accepted by current runtimes.
         * @enum {string}
         */
        InvocationInputSourceKind: InvocationInputSourceKind;
        InvocationRequest: {
            /** @description Compatibility input source category selected by the API caller when `content` is supplied. Current runtimes accept `text` only; future multimodal categories are documented in the enum but not implemented by this contract slice. */
            sourceKind?: components["schemas"]["InvocationInputSourceKind"];
            /** @description Canonical text-first compatibility invocation content. Current runtimes resolve exactly one logical text input from this carrier; non-text source categories are reserved for future contract extensions. When `args` is omitted, `content` and `sourceKind: text` preserve the legacy invocation contract. */
            content?: components["schemas"]["WorkContent"];
            /** @description Optional structured invocation arguments keyed by parameter name, externalName, or alias. Values must decode as a string or an array of strings. Signature-backed runtimes normalize these values through the shared backend argument resolver. Compatibility `content` requests should omit `args`. */
            args?: {
                [key: string]: unknown;
            };
            /** @description Optional caller-supplied idempotency key for the invocation request. */
            requestId?: string;
            /**
             * Format: int64
             * @description Optional caller timeout budget in milliseconds for waiting on the primary result.
             */
            timeoutMillis?: number;
        };
        InvocationResponse: {
            /** @description Stable invocation request identifier assigned or accepted by the server. */
            requestId: string;
            /** @description Trace identifier for the work submitted by this invocation. */
            traceId: string;
            /** @description Terminal invocation status after resolving or failing primary-result selection. */
            status: components["schemas"]["InvocationTerminalStatus"];
            /** @description Primary invocation result. Present only when the invocation resolves successfully with status `COMPLETED`. */
            primaryResult?: components["schemas"]["WorkContent"];
            /**
             * @description Stable machine-readable invocation failure code when status is not `COMPLETED`.
             * @enum {string}
             */
            errorCode?: InvocationResponseErrorCode;
            /** @description Human-readable failure summary when status is not `COMPLETED`. */
            message?: string;
            /** @description Session identifier for the invocation outcome when non-success context needs to point operators at the relevant factory session. */
            sessionId?: string;
            /** @description Relevant work identifier for a non-success invocation outcome when one scoped work item explains the stop condition. */
            workId?: string;
            /** @description Relevant work name for a non-success invocation outcome when one scoped work item explains the stop condition. */
            workName?: string;
            /** @description Current authored work state that best explains the non-success invocation outcome when one scoped work item is available. */
            workState?: string;
        };
        /**
         * @description Terminal status for a factory-session invocation.
         * @enum {string}
         */
        InvocationTerminalStatus: InvocationTerminalStatus;
        /** @description Ordered dashboard-authored submit-work items preserved for one submission. */
        SubmitWorkItemList: components["schemas"]["SubmitWorkItem"][];
        /** @description One ordered dashboard-authored submit-work item. */
        SubmitWorkItem: components["schemas"]["SubmitWorkTextItem"] | components["schemas"]["SubmitWorkImageItem"] | components["schemas"]["SubmitWorkVideoItem"] | components["schemas"]["SubmitWorkAudioItem"] | components["schemas"]["SubmitWorkDocumentItem"];
        /**
         * @description Supported dashboard submit-work item types for multimodal submission.
         * @enum {string}
         */
        SubmitWorkItemType: SubmitWorkItemType;
        SubmitWorkFileItemCommonFields: {
            url: components["schemas"]["SubmitWorkContentURLProperty"];
            /** @description Backend-owned staged file reference preserved for later dispatch. */
            stagedFileRef?: string;
            /** @description Browser-authored filename preserved for inline identification and validation. */
            fileName?: string;
            /** @description Browser-authored MIME type preserved for validation and dispatch decisions. */
            mediaType?: string;
        };
        /** @description Ordered inline text submission item. */
        SubmitWorkTextItem: {
            /** @enum {unknown} */
            type: SubmitWorkTextItemType;
            /** @description Authored inline text preserved in item order. */
            text: string;
        };
        /** @description Ordered image submission item backed by one staged file reference. */
        SubmitWorkImageItem: components["schemas"]["SubmitWorkFileItemCommonFields"] & {
            /** @enum {unknown} */
            type: SubmitWorkImageItemType;
        };
        /** @description Ordered video submission item backed by one staged file reference. */
        SubmitWorkVideoItem: components["schemas"]["SubmitWorkFileItemCommonFields"] & {
            /** @enum {unknown} */
            type: SubmitWorkVideoItemType;
        };
        /** @description Ordered audio submission item backed by one staged file reference. */
        SubmitWorkAudioItem: components["schemas"]["SubmitWorkFileItemCommonFields"] & {
            /** @enum {unknown} */
            type: SubmitWorkAudioItemType;
        };
        /** @description Ordered document submission item backed by one staged file reference. */
        SubmitWorkDocumentItem: components["schemas"]["SubmitWorkFileItemCommonFields"] & {
            /** @enum {unknown} */
            type: SubmitWorkDocumentItemType;
        };
        StageSubmitWorkFileRequest: {
            /** @description Structured submit-work item kind this file will back. Text is not allowed. */
            itemType: components["schemas"]["SubmitWorkItemType"];
            /** @description Browser-authored filename preserved for inline identification and staging. */
            fileName: string;
            /** @description Browser-authored MIME type preserved for validation and dispatch decisions. */
            mediaType: string;
            /** @description Base64-encoded file payload to stage behind a backend-owned reference. */
            contentBase64: string;
        };
        StageSubmitWorkFileResponse: {
            /** @description Canonical file:// URL for the staged bytes on the factory host. */
            url: components["schemas"]["SubmitWorkContentURLProperty"];
            /** @description Backend-owned staged file reference returned for later structured submit-work items. */
            stagedFileRef: string;
            /** @description Browser-authored filename preserved for inline identification after staging. */
            fileName: string;
            /** @description Browser-authored MIME type preserved for inline identification after staging. */
            mediaType: string;
        };
        UpsertWorkRequestSubmittedWork: {
            name: string;
            workTypeName: string;
            workId: string;
        };
        UpsertWorkRequestResponse: {
            requestId: string;
            traceId: string;
            works: components["schemas"]["UpsertWorkRequestSubmittedWork"][];
        };
        /** @description Operator request to move one work item to another authored marking state. */
        MoveWorkRequest: {
            /** @description Authored marking state name to move the work item into. */
            stateName: string;
            /** @description Optional client idempotency key. Repeating the same requestId for an already-applied operator move returns 409 Conflict without a second mutation. */
            requestId?: string;
        };
        ListWorkResponse: {
            results: components["schemas"]["Work"][];
            paginationContext?: components["schemas"]["PaginationContext"];
        };
        PaginationContext: {
            maxResults: number;
            nextToken?: string;
        };
        TokenResponse: {
            id: string;
            placeId: string;
            name?: string;
            workId: string;
            workType: string;
            chainingTraceDepth?: number;
            currentChainingTraceId?: string;
            previousChainingTraceIds?: string[];
            traceId: string;
            /** @description Ordered canonical content parts preserved on this work token. */
            content?: components["schemas"]["WorkContent"];
            tags?: components["schemas"]["StringMap"];
            /** Format: date-time */
            createdAt: string;
            /** Format: date-time */
            enteredAt: string;
            history?: components["schemas"]["TokenHistory"];
        };
        TokenHistory: {
            totalVisits?: components["schemas"]["IntegerMap"];
            consecutiveFailures?: components["schemas"]["IntegerMap"];
            placeVisits?: components["schemas"]["IntegerMap"];
            lastError?: string;
        };
        ResourceUsage: {
            name: string;
            available: number;
            total: number;
        };
        ResourceRequirement: {
            name: string;
            capacity: number;
        };
        StatusCategories: {
            initial: number;
            processing: number;
            terminal: number;
            failed: number;
        };
        StatusResponse: {
            categories: components["schemas"]["StatusCategories"];
            factoryState: string;
            /** @description Canonical Factory Session lifecycle-control status reconstructed from SESSION_PAUSED and SESSION_RESUMED events when present. Live status reads report PAUSED after a successful pause and RUNNING after a successful resume. */
            lifecycleControlStatus?: components["schemas"]["FactorySessionDurableLifecycleStatus"];
            runtimeStatus: string;
            totalTokens: number;
            resources?: components["schemas"]["ResourceUsage"][];
        };
        ListModelsResponse: {
            /** @description Managed runtimes exposed by the currently loaded runtime configuration. */
            results: components["schemas"]["ModelSummary"][];
        };
        ManagedRuntime: {
            /** @description Stable managed runtime identity shared by discovery, inspect, pull or install, and factory dependency surfaces. */
            identity: string;
            readinessState: components["schemas"]["ManagedRuntimeReadinessState"];
            lifecycleState: components["schemas"]["ManagedRuntimeLifecycleState"];
            locality: components["schemas"]["WorkerModelLocality"];
            /** @description Provider-agnostic operations supported by this managed runtime. */
            supportedOperations: components["schemas"]["ModelOperation"][];
            /** @description Concise managed-runtime diagnostics in customer-relevant terms. */
            diagnostics?: components["schemas"]["StringMap"];
        };
        /**
         * @description Customer-facing lifecycle position for one managed runtime. Lifecycle state tracks install, cache, and load progression independently from short-lived readiness used by invocation surfaces.
         * @enum {string}
         */
        ManagedRuntimeLifecycleState: ManagedRuntimeLifecycleState;
        /**
         * @description Source-agnostic outcome for one managed runtime pull or install request. Outcomes classify whether the runtime is already ready, newly installed, still preparing, timed out, failed to fetch required assets, or unsupported.
         * @enum {string}
         */
        ManagedRuntimePullOutcome: ManagedRuntimePullOutcome;
        ManagedRuntimePullResult: {
            /** @description Stable managed runtime identity targeted by the pull or install request. */
            identity: string;
            pullOutcome: components["schemas"]["ManagedRuntimePullOutcome"];
            readinessState: components["schemas"]["ManagedRuntimeReadinessState"];
            /** @description Managed cache directory that now contains the installed runtime assets. */
            cachePath?: string;
            /** @description Managed revision identifier for the installed runtime assets. */
            revision?: string;
            /** @description Files downloaded or verified as already present for the managed cache entry. */
            downloadedFiles?: components["schemas"]["ModelPullDownloadedFile"][];
            sourceDiagnostics?: components["schemas"]["ManagedRuntimeSourceDiagnostics"];
        };
        /**
         * @description Customer-facing readiness for one managed runtime. Readiness describes whether the runtime can be invoked now or what action is required next, without naming upstream repository or provider-specific cache semantics.
         * @enum {string}
         */
        ManagedRuntimeReadinessState: ManagedRuntimeReadinessState;
        /** @description Optional advanced diagnostics for how one managed runtime resolved assets from a configured backend source. Source details are implementation diagnostics and are not required for the primary customer lifecycle contract. */
        ManagedRuntimeSourceDiagnostics: {
            /** @description Resolver-classified backend source kind, such as `UPSTREAM_REPOSITORY` or `MANAGED_MIRROR`, without exposing provider-native repository vocabulary in the primary customer contract. */
            sourceKind?: string;
            /** @description Opaque resolver identifier for the selected backend source instance. */
            sourceId?: string;
            /** @description Concise resolver note suitable for operator diagnostics. */
            resolverNotes?: string;
        };
        ModelSummary: {
            /** @description Stable managed runtime identity such as `OMNIVOICE_Q4_K_M`. Mirrors `managedRuntime.identity` for compatibility with earlier discovery fields. */
            name: string;
            managedRuntime: components["schemas"]["ManagedRuntime"];
            /** @description Managed runtime locality summary. Mirrors `managedRuntime.locality` for compatibility with earlier discovery fields. */
            providerLocality: components["schemas"]["WorkerModelLocality"];
            status: components["schemas"]["ModelStatus"];
            loadState: components["schemas"]["ModelLoadState"];
            /** @description Provider-agnostic operations supported by the managed runtime. Mirrors `managedRuntime.supportedOperations` for compatibility with earlier discovery fields. */
            operations: components["schemas"]["ModelOperation"][];
            /** @description Uppercase content modalities observed across the model's declared operation inputs and outputs. */
            modalities: components["schemas"]["ModelOperationContentType"][];
            /** @description Factory resource summaries associated with this model's workers or explicit model metadata. */
            resources: components["schemas"]["ModelResourceSummary"][];
        };
        ModelDetail: {
            /** @description Stable managed runtime identity such as `OMNIVOICE_Q4_K_M`. Mirrors `managedRuntime.identity` for compatibility with earlier inspect fields. */
            name: string;
            managedRuntime: components["schemas"]["ManagedRuntime"];
            /** @description Managed runtime locality summary. Mirrors `managedRuntime.locality` for compatibility with earlier inspect fields. */
            providerLocality: components["schemas"]["WorkerModelLocality"];
            status: components["schemas"]["ModelStatus"];
            loadState: components["schemas"]["ModelLoadState"];
            /** @description Union of provider-agnostic operations supported by workers for this managed runtime. Mirrors `managedRuntime.supportedOperations` for compatibility with earlier inspect fields. */
            operations: components["schemas"]["ModelOperation"][];
            /** @description Uppercase content modalities observed across all declared operation inputs and outputs. */
            modalities: components["schemas"]["ModelOperationContentType"][];
            /** @description Factory resource summaries associated with this model's workers or explicit model metadata. */
            resources: components["schemas"]["ModelResourceSummary"][];
            /** @description Worker-scoped capability declarations that contribute to this discovered model. */
            capabilities: components["schemas"]["ModelCapability"][];
            diagnostics: components["schemas"]["StringMap"];
        };
        ModelInvocationRequest: {
            /** @description Uppercase provider-agnostic operation to invoke, such as `TTS`. */
            operation: string;
            /** @description Ordered invocation input content resolved through optional slot bindings. */
            content?: components["schemas"]["WorkContent"];
            /** @description Optional per-request slot bindings that follow the same contract as `MODEL_INVOKE` workstation bindings. */
            bindings?: components["schemas"]["WorkstationOperationBinding"][];
            options?: components["schemas"]["ModelInvocationOptions"];
        };
        /** @description Optional direct-invocation controls for response shaping and transport. */
        ModelInvocationOptions: {
            responseMode?: components["schemas"]["ModelInvocationResponseMode"];
        };
        /**
         * @description Requested direct-invocation response mode.
         * @enum {string}
         */
        ModelInvocationResponseMode: ModelInvocationResponseMode;
        ModelInvocationResponse: {
            /** @description Concrete public model identifier such as `OMNIVOICE_Q4_K_M`. */
            modelName: string;
            /** @description Worker selected to satisfy this invocation. */
            worker: string;
            /** @description Uppercase provider-agnostic operation that was invoked. */
            operation: string;
            providerLocality: components["schemas"]["WorkerModelLocality"];
            /** @description Returned model output as canonical `WorkContent`. */
            content: components["schemas"]["WorkContent"];
            /** @description Deterministically resolved slot bindings used for the invocation. */
            bindings: components["schemas"]["ResolvedModelOperationBinding"][];
        };
        ModelPullDownloadedFile: {
            /** @description Relative file path written under the managed model cache directory. */
            path: string;
            /**
             * Format: int64
             * @description Downloaded file size in bytes.
             */
            bytes: number;
            /** @description Lowercase SHA-256 checksum for the cached file when known. */
            sha256?: string;
        };
        /**
         * @description Compatibility pull outcome projection for one managed runtime. Prefer `managedRuntimePull.pullOutcome` for the canonical managed-runtime vocabulary. `PULLED` maps to managed pull outcome `INSTALLED_SUCCESSFULLY`; `ALREADY_PRESENT` maps to managed pull outcome `ALREADY_PRESENT`.
         * @enum {string}
         */
        ModelPullOutcome: ModelPullOutcome;
        ModelPullResponse: {
            /** @description Stable managed runtime identity such as `OMNIVOICE_Q4_K_M`. Mirrors `managedRuntimePull.identity` for compatibility with earlier pull fields. */
            modelName: string;
            managedRuntimePull: components["schemas"]["ManagedRuntimePullResult"];
            providerLocality: components["schemas"]["WorkerModelLocality"];
            outcome: components["schemas"]["ModelPullOutcome"];
            /** @description Final managed cache directory that now contains the installed runtime assets. Mirrors `managedRuntimePull.cachePath`. */
            cachePath: string;
            /** @description Managed revision identifier for the installed runtime assets. Mirrors `managedRuntimePull.revision`. */
            revision: string;
            /** @description Files that were downloaded or verified as already present for the managed cache entry. */
            downloadedFiles: components["schemas"]["ModelPullDownloadedFile"][];
        };
        ResolvedModelOperationBinding: {
            /** @description Stable input slot name declared by the worker capability. */
            slot: string;
            source: components["schemas"]["ResolvedModelOperationBindingSource"];
            /** @description Resolved content bound to the slot. */
            content: components["schemas"]["WorkContent"];
        };
        /**
         * @description Source used to resolve one invocation slot binding.
         * @enum {string}
         */
        ResolvedModelOperationBindingSource: ResolvedModelOperationBindingSource;
        ModelCapability: {
            /** @description Customer-authored worker name that exposes this capability declaration. */
            worker: string;
            modelProvider?: components["schemas"]["WorkerModelProvider"];
            providerLocality: components["schemas"]["WorkerModelLocality"];
            /** @description Operations declared by this worker for the selected model. */
            operations: components["schemas"]["ModelOperation"][];
            /** @description Factory resource names referenced by the worker declaration. */
            resourceNames: string[];
        };
        ModelResourceSummary: {
            /** @description Factory-authored resource name. */
            name: string;
            type: components["schemas"]["ResourceType"];
            /** @description Declared factory capacity for this resource. */
            capacity: number;
            /** @description Concrete model identifier when the resource is model-specific. */
            model?: string;
            /** @description Local runtime backend identifier for model resources. */
            backend?: string;
            /** @description Local load-policy metadata for model resources. */
            loadPolicy?: string;
            /** @description Cloud provider identity when the resource models quota or routing. */
            provider?: string;
        };
        /**
         * @description Compatibility readiness projection for one managed runtime. Prefer `managedRuntime.readinessState` for the canonical managed-runtime vocabulary. `READY` maps to managed readiness `READY`; `UNAVAILABLE` maps to managed readiness `MISSING` for local runtimes that still require install or setup.
         * @enum {string}
         */
        ModelStatus: ModelStatus;
        /**
         * @description Compatibility lifecycle projection for one managed runtime. Prefer `managedRuntime.lifecycleState` for the canonical managed-runtime vocabulary. `UNLOADED` maps to managed lifecycle `NOT_INSTALLED` or `LOADED` depending on cache and load state; `NOT_APPLICABLE` maps to managed lifecycle `NOT_APPLICABLE` for cloud-backed runtimes.
         * @enum {string}
         */
        ModelLoadState: ModelLoadState;
        /**
         * @description Stable machine-readable error family for broader client grouping.
         * @enum {string}
         */
        ErrorFamily: ErrorFamily;
        ErrorResponse: {
            message: string;
            family: components["schemas"]["ErrorFamily"];
            /**
             * @description Stable machine-readable error code.
             * @enum {string}
             */
            code: ErrorResponseCode;
            /** @description Optional canonical validation targets that clients can map to factory graph nodes, handles, and form fields. */
            targets?: components["schemas"]["FactoryValidationTarget"][];
        };
        ErrorTarget: {
            /** @description Client-visible target category such as form, node, edge, field, or save. */
            kind: string;
            /** @description Optional graph entity, relationship, or save condition identifier. */
            id?: string;
            /** @description Optional request or form field path associated with the error. */
            field?: string;
        };
        HybridLogicalTimestamp: {
            /**
             * Format: int64
             * @description Monotonic Lamport-style logical component derived from the persisted factory definition version. Serialized as a decimal string so JavaScript clients can round-trip the 64-bit value without precision loss.
             */
            logical: string;
            /**
             * Format: date-time
             * @description UTC physical timestamp component for the persisted factory definition version.
             */
            physical: string;
        };
        ProviderSessionDetailResponse: {
            providerSession: components["schemas"]["LoadableProviderSessionRef"];
            source: components["schemas"]["ProviderSessionSourceMetadata"];
            parse: components["schemas"]["ProviderSessionParseSummary"];
            /** @description Ordered transcript entries extracted from the provider-session stream. */
            transcript: components["schemas"]["ProviderSessionTranscriptEntry"][];
        };
        FactorySessionTargetRef: {
            /** @enum {string} */
            kind: FactorySessionTargetRefKind;
            name?: string;
        };
        FactorySessionTarget: {
            ref: components["schemas"]["FactorySessionTargetRef"];
            label: string;
            folderPath: string;
            factoryDir: string;
            project: string;
        };
        FactorySessionSummary: {
            id: string;
            target: components["schemas"]["FactorySessionTargetRef"];
            folderPath: string;
            factoryDir: string;
            project: string;
            isDefault: boolean;
            runtime?: components["schemas"]["FactorySessionRuntime"];
        };
        FactorySession: {
            id: string;
            target: components["schemas"]["FactorySessionTargetRef"];
            folderPath: string;
            factoryDir: string;
            project: string;
            isDefault: boolean;
            runtime: components["schemas"]["FactorySessionRuntime"];
        };
        FactorySessionRuntime: {
            orchestratorKind: components["schemas"]["FactoryOrchestratorKind"];
            /** @description JavaScript workflow dialect when orchestrator.kind = JAVASCRIPT. */
            dialect?: string;
            /** @description Authored JavaScript workflow source reference when applicable. */
            sourceRef?: string;
            /** @description Stable hash of the authored JavaScript workflow source. */
            sourceHash?: string;
            /** @description Stable hash of the effective orchestrator policy. */
            policyHash?: string;
            status: components["schemas"]["FactorySessionStatus"];
            /** @description Canonical Factory Session lifecycle-control status reconstructed from SESSION_PAUSED and SESSION_RESUMED events when present. Live session inspection reads report PAUSED after a successful pause and RUNNING after a successful resume. */
            lifecycleControlStatus?: components["schemas"]["FactorySessionDurableLifecycleStatus"];
            progress: components["schemas"]["FactorySessionProgress"];
            budgets?: components["schemas"]["FactorySessionBudgets"];
            usage: components["schemas"]["FactorySessionUsage"];
            lifecycle: components["schemas"]["FactorySessionLifecycle"];
            /** @description Canonical stopped-state summary for paused, blocked, needs-human, and interrupted inspection paths on the existing Factory Session surface. */
            stopSummary?: components["schemas"]["FactoryStopSummary"];
            /** @description Backend-authoritative identity for the current live session event stream. Clients must confirm this identity before reusing persisted reconnect cursors or timeline checkpoints. */
            streamIdentity?: components["schemas"]["FactorySessionStreamIdentity"];
            petri?: components["schemas"]["FactorySessionPetriProjection"];
            javascript?: components["schemas"]["FactorySessionJavaScriptProjection"];
            /** @description Shared artifact projections for the session runtime. */
            artifacts?: components["schemas"]["FactoryArtifact"][];
        };
        /**
         * @description Canonical inspect classification for stopped automation on existing Factory Session and Work surfaces.
         * @enum {string}
         */
        FactoryStopKind: FactoryStopKind;
        FactoryStopDispatchSummary: {
            /** @description Stable dispatch identifier that most directly explains the stopped state. */
            dispatchId: string;
            status: components["schemas"]["FactoryDispatchStatus"];
            dispatchKind: components["schemas"]["FactoryDispatchKind"];
            /** @description Customer-authored workstation name when one existing workstation run explains the stop. */
            workstationName?: string;
            /** @description Failure or interruption detail from the latest relevant dispatch when available. */
            failureDetail?: components["schemas"]["FailureDetail"];
        };
        FactoryStopSummary: {
            stopKind: components["schemas"]["FactoryStopKind"];
            /** @description Stable Factory Session identifier that owns the stopped work. */
            sessionId: string;
            /** @description Relevant work identifier when one work item best explains the stop. */
            workId?: string;
            /** @description Relevant work name when one work item best explains the stop. */
            workName?: string;
            /** @description Relevant work type name when one work item best explains the stop. */
            workTypeName?: string;
            /** @description Current authored work state label such as `goal:blocked` when one work item best explains the stop. */
            workState?: string;
            /** @description Session lifecycle-control status when the stop is explained by pause or another session-level lifecycle condition. */
            sessionLifecycleStatus?: components["schemas"]["FactorySessionDurableLifecycleStatus"];
            latestDispatch?: components["schemas"]["FactoryStopDispatchSummary"];
            /** @description Short operator-readable summary of the latest relevant result when one explains the stop better than a dispatch identifier alone. */
            latestResultSummary?: string;
            /** @description Existing operator surface to use next, expressed with current Factory Session and Work vocabulary rather than a goal-specific control route. */
            suggestedRecoverySurface?: string;
            /** @description Human-readable next step that names the existing work or session action the operator should take to recover or continue automation. */
            suggestedRecoveryAction?: string;
        };
        FactorySessionStreamIdentity: {
            /** @description Stable backend process or scope identity for the current live session stream. */
            backendScopeID: string;
            /** @description Canonical logical-session key derived from the normalized factory session target. This remains stable across live-session remaps for the same target. */
            logicalSessionKeyID: string;
            /** @description Stable live Factory Session identifier for the current stream. */
            factorySessionID: string;
            /** @description Stable generation identifier for the current live session stream incarnation. */
            streamGenerationID: string;
            normalizedTarget?: components["schemas"]["FactorySessionLogicalTarget"];
        };
        /**
         * @description Client-safe normalized factory session target metadata derived from canonical
         *     logical target references. This shape is safe to persist for remap and does not
         *     expose secrets or internal runtime identifiers.
         */
        FactorySessionLogicalTarget: {
            kind: components["schemas"]["FactorySessionLogicalTargetKind"];
            /** @description Canonical absolute folder path for the normalized factory session target within the backend scope. */
            folderPath: string;
            /** @description Canonical named target identifier when kind is named. */
            namedTarget?: string;
            providerBoundary?: components["schemas"]["FactorySessionLogicalProviderBoundary"];
        };
        /**
         * @description Canonical normalized factory session target kind used for logical identity.
         * @enum {string}
         */
        FactorySessionLogicalTargetKind: FactorySessionLogicalTargetKind;
        /** @description Stable provider workspace or account boundary for a provider-backed logical session target. Values must not contain secret material. */
        FactorySessionLogicalProviderBoundary: {
            /** @description Provider identifier for the normalized target. */
            provider: string;
            /** @description Provider session kind for the normalized target. */
            kind: string;
            /** @description Stable provider workspace or account boundary without secret material. */
            boundary: string;
        };
        /**
         * @description Canonical lifecycle status for one live factory session runtime.
         * @enum {string}
         */
        FactorySessionStatus: FactorySessionStatus;
        FactorySessionProgress: {
            /** @description Factory lifecycle state from the aggregate engine snapshot. */
            factoryState: string;
            categories: components["schemas"]["StatusCategories"];
            /** @description Number of dispatches currently in flight for the session. */
            inFlightCount: number;
            /** @description Number of customer-visible work tokens in the current marking. */
            totalTokens: number;
        };
        /** @description Effective orchestrator policy budgets projected for one factory session. */
        FactorySessionBudgets: {
            /** @description Maximum concurrent child-agent dispatches allowed by the effective JavaScript policy. */
            maxAgents?: number;
        };
        FactorySessionUsage: {
            /** @description Resource availability and consumption for the session runtime. */
            resources: components["schemas"]["ResourceUsage"][];
        };
        FactorySessionLifecycle: {
            /**
             * Format: date-time
             * @description When the live session runtime started.
             */
            startedAt: string;
            /**
             * Format: date-time
             * @description When the session projection was last refreshed.
             */
            updatedAt: string;
            /**
             * Format: date-time
             * @description When the session runtime reached a terminal finished state.
             */
            finishedAt?: string;
        };
        FactorySessionPetriProjection: {
            /** @description Current Petri marking tokens for the session runtime. */
            marking: components["schemas"]["TokenResponse"][];
            /** @description Transitions currently enabled in the Petri marking. */
            enabledTransitions: components["schemas"]["FactorySessionPetriEnabledTransition"][];
        };
        FactorySessionPetriEnabledTransition: {
            /** @description Enabled Petri transition identifier. */
            transitionId: string;
            /** @description Worker type bound to the enabled transition. */
            workerType: string;
        };
        FactorySessionJavaScriptProjection: {
            /** @description Current JavaScript workflow phase name. */
            phase?: string;
            /** @description Ordered phase names visible in the session runtime. */
            phases: string[];
            /** @description Stable digest of the effective workflow arguments. */
            argsDigest?: string;
            /** @description Checkpoint refs and summaries without raw VM checkpoint bodies. */
            checkpoints?: components["schemas"]["FactorySessionJavaScriptCheckpointRef"][];
            scriptStatus: components["schemas"]["FactorySessionJavaScriptScriptStatus"];
            childDispatchCounts: components["schemas"]["FactorySessionJavaScriptChildDispatchCounts"];
        };
        FactorySessionJavaScriptCheckpointRef: {
            /** @description Stable checkpoint identifier referenced by the session runtime. */
            id: string;
            /** @description Customer-visible checkpoint label. */
            label?: string;
            /**
             * Format: date-time
             * @description When the checkpoint was recorded.
             */
            timestamp?: string;
            /** @description Short customer-visible checkpoint summary without raw VM state. */
            summary?: string;
            /** @description Orchestrator-owned checkpoint artifact metadata without raw VM state. */
            artifactRef?: components["schemas"]["FactoryArtifactRef"];
        };
        /**
         * @description JavaScript workflow script runtime status for one factory session.
         * @enum {string}
         */
        FactorySessionJavaScriptScriptStatus: FactorySessionJavaScriptScriptStatus;
        FactorySessionJavaScriptChildDispatchCounts: {
            /** @description Child dispatches waiting to start. */
            queued: number;
            /** @description Child dispatches currently executing. */
            running: number;
            /** @description Child dispatches that have completed. */
            completed: number;
        };
        /**
         * @description Typed session sync preflight response used before restoring cached dashboard
         *     checkpoint state or opening the session event stream with a reconnect cursor.
         */
        FactorySessionSyncPreflightResponse: {
            /** @description Session selector requested by the client. This may be `~default`. */
            requestedSessionId: string;
            reasonCode: components["schemas"]["FactorySessionSyncPreflightReasonCode"];
            /** @description Canonical backend scope identifier for the current server-owned session cache and event history scope. */
            backendScopeId?: string;
            /** @description Canonical logical-session key for the resolved session target. This remains stable across live-session remaps for the same folder and target selector. */
            logicalSessionKeyId?: string;
            /** @description Resolved live Factory Session identifier for the current preflight target. Clients must persist this value rather than treating `~default` as a durable session identifier. */
            factorySessionId?: string;
            /** @description Canonical event-stream generation identifier for the resolved live Factory Session. */
            streamGenerationId?: string;
            normalizedTarget?: components["schemas"]["FactorySessionLogicalTarget"];
            /** @description True when cached stream-derived checkpoint state is safe to restore for the resolved identity set. */
            checkpointReusable: boolean;
            reconnectCursor: components["schemas"]["FactorySessionSyncPreflightReconnectCursor"];
        };
        /**
         * @description Stable backend-owned session sync preflight outcome code.
         * @enum {string}
         */
        FactorySessionSyncPreflightReasonCode: FactorySessionSyncPreflightReasonCode;
        FactorySessionSyncPreflightReconnectCursor: {
            /** @description True when the client supplied at least one reconnect cursor field for validation. */
            provided: boolean;
            /** @description True when the supplied reconnect cursor belongs to the current stream generation for the resolved live session. */
            validForStreamGeneration: boolean;
            /** @description Optional acknowledged FactoryEvent.id supplied by the client. */
            afterEventId?: string;
            /**
             * Format: int64
             * @description Optional acknowledged FactoryEvent.context.sessionSequence supplied by the client.
             */
            afterSequence?: number;
        };
        FactorySessionLiveResult: {
            /** @description Live factory session identifier for this result read. */
            sessionId: string;
            status: components["schemas"]["FactorySessionStatus"];
            /** @description Final result artifact reference without raw checkpoint bodies. */
            resultArtifactRef?: components["schemas"]["FactoryArtifactRef"];
            /** @description Checkpoint refs associated with the terminal session result. */
            checkpointRefs?: components["schemas"]["FactorySessionJavaScriptCheckpointRef"][];
        };
        /** @description Durable factory-session result retrieval response for final or partial workflow outputs. Non-ready, unavailable, and failed-with-partial states return typed bodies with session identity, current session status, and actionable failure or availability details when known. */
        FactorySessionResult: {
            /** @description Stable durable factory-session identifier. */
            sessionId: string;
            resultStatus: components["schemas"]["FactorySessionResultStatus"];
            /** @description Current durable session lifecycle status when known. */
            sessionStatus?: components["schemas"]["FactorySessionDurableLifecycleStatus"];
            /** @description Result retrieval mode echoed from the request. */
            mode?: components["schemas"]["FactorySessionResultMode"];
            /** @description Whether artifact metadata was included in this response. */
            includeArtifacts?: boolean;
            /** @description Primary workflow output when resultStatus is PARTIAL or FINAL. */
            primaryResult?: components["schemas"]["WorkContent"];
            /** @description Artifact identifiers for materialized outputs when bodies are omitted or includeArtifacts is false. */
            artifactIds?: string[];
            /** @description Artifact refs for large or non-text outputs when includeArtifacts is true. */
            artifactRefs?: components["schemas"]["FactoryArtifactRef"][];
            /** @description Failure details when resultStatus is FAILED_WITH_PARTIAL. */
            failureDetail?: components["schemas"]["FailureDetail"];
            /** @description Whether partial results remain inspectable after the failure. */
            partialResultAvailable?: boolean;
            /** @description Availability details when resultStatus is NOT_READY or UNAVAILABLE. */
            availability?: components["schemas"]["FactorySessionResultAvailabilityDetail"];
        };
        /**
         * @description Durable session result retrieval mode.
         * @enum {string}
         */
        FactorySessionResultMode: FactorySessionResultMode;
        FactorySessionResultAvailabilityDetail: {
            /** @description Stable availability reason code when the result is not ready or unavailable. */
            reason?: string;
            /** @description Customer-visible availability message when known. */
            message?: string;
            /** @description Whether polling or a later retry may return a ready result. */
            retryable?: boolean;
        };
        /** @description Durable factory-session dispatch summary for list responses. Exposes shared dispatch fields plus bounded orchestrator-specific inspection data when available. */
        FactorySessionDispatchSummary: {
            /** @description Stable dispatch identifier. */
            id: string;
            status: components["schemas"]["FactoryDispatchStatus"];
            dispatchKind: components["schemas"]["FactoryDispatchKind"];
            /** @description Workflow phase when the dispatch was created or observed. */
            phase?: string;
            /** @description Customer-visible dispatch label. */
            label?: string;
            /**
             * Format: int32
             * @description One-based attempt number for retried dispatches.
             */
            attempt?: number;
            /** @description Whether the provider failure that produced the current failed state was retryable. */
            retryable?: boolean;
            /** @description Stable canonical classification recorded for the current provider failure. */
            failureClassification?: components["schemas"]["WorkFailureType"];
            /** @description Selected runner identifier when applicable. */
            runnerId?: string;
            /** @description Resolved operator worker preset identifier when one was selected. */
            presetId?: string;
            /** @description Resolved canonical model-provider identifier when applicable. */
            modelProvider?: string;
            /** @description Selected model identifier when applicable. */
            model?: string;
            /** @description Resolved canonical reasoning effort when applicable. */
            reasoningEffort?: string;
            /** @description Selected provider identifier when applicable. */
            provider?: string;
            /** @description Provider-session correlation refs for model-backed dispatches. */
            providerSessionRefs?: components["schemas"]["LoadableProviderSessionRef"][];
            usage?: components["schemas"]["FactoryDispatchUsage"];
            warnings?: components["schemas"]["FactoryDispatchWarning"][];
            /** @description Artifact identifiers produced by the dispatch. */
            outputArtifactIds?: string[];
            failureDetail?: components["schemas"]["FailureDetail"];
            javascript?: components["schemas"]["FactoryDispatchJavaScriptProjection"];
        };
        ListFactorySessionDispatchesResponse: {
            /** @description Stable factory-session identifier that owns the listed dispatches. */
            sessionId: string;
            /** @description Dispatch summaries for the targeted session. */
            dispatches: components["schemas"]["FactorySessionDispatchSummary"][];
        };
        /** @description Safe API retrieval reference for one factory-session artifact. Identifiers and href values are API-relative and must not expose unrestricted host filesystem paths by default. */
        FactorySessionArtifactRetrievalRef: {
            /** @description API-relative retrieval path for the artifact payload. */
            href: string;
            /**
             * @description HTTP method clients should use to retrieve the referenced payload.
             * @enum {string}
             */
            method?: FactorySessionArtifactRetrievalRefMethod;
        };
        /** @description Durable factory-session artifact metadata for list responses without raw artifact bodies or unrestricted host filesystem paths. */
        FactorySessionArtifactSummary: {
            /** @description Stable artifact identifier. */
            id: string;
            kind: components["schemas"]["FactoryArtifactKind"];
            visibility: components["schemas"]["FactoryArtifactVisibility"];
            /** @description Customer-visible artifact label. */
            label?: string;
            /** @description Stable hash of the stored artifact payload. */
            contentHash?: string;
            /**
             * Format: int64
             * @description Stored artifact payload size in bytes.
             */
            sizeBytes?: number;
            /**
             * Format: date-time
             * @description Timestamp when the artifact was created or captured.
             */
            createdAt?: string;
            /** @description Dispatch identifier that produced the artifact when applicable. */
            dispatchId?: string;
            auditMode?: components["schemas"]["FactoryArtifactAuditMode"];
            redactionCounts?: components["schemas"]["FactoryArtifactRedactionCounts"];
            /** @description Safe retrieval reference when artifact content is not inlined. */
            retrievalRef?: components["schemas"]["FactorySessionArtifactRetrievalRef"];
        };
        /** @description Durable factory-session artifact detail with metadata and either inlined content or a safe retrieval ref according to visibility and payload size. */
        FactorySessionArtifactDetail: {
            /** @description Stable factory-session identifier that owns the artifact. */
            sessionId: string;
            /** @description Stable artifact identifier. */
            id: string;
            kind: components["schemas"]["FactoryArtifactKind"];
            visibility: components["schemas"]["FactoryArtifactVisibility"];
            /** @description Customer-visible artifact label. */
            label?: string;
            /** @description Customer-visible artifact summary. */
            summary?: string;
            /** @description Stable hash of the stored artifact payload. */
            contentHash?: string;
            /**
             * Format: int64
             * @description Stored artifact payload size in bytes.
             */
            sizeBytes?: number;
            /**
             * Format: date-time
             * @description Timestamp when the artifact was created or captured.
             */
            createdAt?: string;
            /** @description Dispatch identifier that produced the artifact when applicable. */
            dispatchId?: string;
            auditMode?: components["schemas"]["FactoryArtifactAuditMode"];
            redactionCounts?: components["schemas"]["FactoryArtifactRedactionCounts"];
            captureMetadata?: components["schemas"]["FactoryArtifactCaptureMetadata"];
            /** @description Inlined artifact content when visibility and size allow direct return. */
            content?: components["schemas"]["WorkContent"];
            /** @description Safe retrieval reference when content is omitted from the response body. */
            contentRef?: components["schemas"]["FactorySessionArtifactRetrievalRef"];
        };
        ListFactorySessionArtifactsResponse: {
            /** @description Stable factory-session identifier that owns the listed artifacts. */
            sessionId: string;
            /** @description Artifact metadata rows for the targeted session. */
            artifacts: components["schemas"]["FactorySessionArtifactSummary"][];
        };
        FactorySessionPartialResult: {
            /** @description Live factory session identifier for this partial-result read. */
            sessionId: string;
            /** @description Current JavaScript workflow phase for the partial result. */
            phase: string;
            /** @description Partial-result artifact reference without raw checkpoint bodies. */
            partialResultArtifactRef?: components["schemas"]["FactoryArtifactRef"];
            /** @description Checkpoint refs associated with the current partial result. */
            checkpointRefs?: components["schemas"]["FactorySessionJavaScriptCheckpointRef"][];
        };
        FactoryDispatch: {
            /** @description Stable dispatch identifier. */
            id: string;
            /** @description Factory session that owns this dispatch. */
            sessionId: string;
            orchestratorKind: components["schemas"]["FactoryOrchestratorKind"];
            dispatchKind: components["schemas"]["FactoryDispatchKind"];
            /** @description JavaScript workflow phase when the dispatch was created or observed. */
            phase?: string;
            status: components["schemas"]["FactoryDispatchStatus"];
            /** @description Customer-visible dispatch label. */
            label?: string;
            /**
             * Format: int32
             * @description One-based attempt number for retried dispatches.
             */
            attempt?: number;
            /** @description Whether the provider failure that produced the current failed state was retryable. */
            retryable?: boolean;
            /** @description Stable canonical classification recorded for the current provider failure. */
            failureClassification?: components["schemas"]["WorkFailureType"];
            /** @description Selected runner identifier when applicable. */
            runnerId?: string;
            /** @description Resolved operator worker preset identifier when one was selected. */
            presetId?: string;
            /** @description Resolved canonical model-provider identifier when applicable. */
            modelProvider?: string;
            /** @description Selected model identifier when applicable. */
            model?: string;
            /** @description Resolved canonical reasoning effort when applicable. */
            reasoningEffort?: string;
            /** @description Selected provider identifier when applicable. */
            provider?: string;
            /** @description Provider-session correlation refs for model-backed dispatches. */
            providerSessionRefs?: components["schemas"]["LoadableProviderSessionRef"][];
            /** @description Stable digest of rendered prompt material. */
            promptDigest?: string;
            /** @description Stable digest of the output schema when applicable. */
            schemaDigest?: string;
            /** @description Related work identifiers consumed or produced by the dispatch. */
            relatedWorkIds?: string[];
            /** @description Artifact identifiers produced by the dispatch. */
            artifactIds?: string[];
            /** @description Ordered durable status history observed for the dispatch. */
            statusTransitions?: components["schemas"]["FactoryDispatchStatus"][];
            usage?: components["schemas"]["FactoryDispatchUsage"];
            warnings?: components["schemas"]["FactoryDispatchWarning"][];
            failureDetail?: components["schemas"]["FailureDetail"];
            /** @description Petri-specific dispatch projection. Present for Petri transition dispatches. */
            petri?: components["schemas"]["FactoryDispatchPetriProjection"];
            /** @description JavaScript-specific dispatch projection. Present for JavaScript workflow task dispatches. */
            javascript?: components["schemas"]["FactoryDispatchJavaScriptProjection"];
        };
        /**
         * @description Canonical dispatch kind shared across Petri transitions and JavaScript workflow tasks.
         * @enum {string}
         */
        FactoryDispatchKind: FactoryDispatchKind;
        /**
         * @description Canonical dispatch lifecycle status shared across orchestrators.
         * @enum {string}
         */
        FactoryDispatchStatus: FactoryDispatchStatus;
        /**
         * @description JavaScript workflow task kind for one child dispatch.
         * @enum {string}
         */
        FactoryDispatchJavaScriptTaskKind: FactoryDispatchJavaScriptTaskKind;
        FactoryDispatchPetriProjection: {
            /** @description Petri transition identifier for this dispatch. */
            transitionId: string;
            /** @description Workstation name that owns the transition. */
            workstationName?: string;
            /** @description Worker type selected for the transition dispatch. */
            workerType?: string;
        };
        FactoryDispatchJavaScriptProjection: {
            taskKind: components["schemas"]["FactoryDispatchJavaScriptTaskKind"];
            /** @description Customer-visible label for the JavaScript workflow task. */
            taskLabel?: string;
            /** @description Durable child execution mode recorded for the JavaScript workflow task when available. */
            executionMode?: string;
        };
        FactoryDispatchUsage: {
            /** Format: int64 */
            inputTokens?: number;
            /** Format: int64 */
            outputTokens?: number;
            /** Format: int64 */
            totalTokens?: number;
            /** Format: double */
            costUsd?: number;
            /** Format: int64 */
            durationMillis?: number;
            /** Format: int32 */
            retryCount?: number;
        };
        FactoryDispatchWarning: {
            /** @description Stable warning code for the dispatch projection. */
            code: string;
            /** @description Customer-visible warning message. */
            message: string;
        };
        FailureDetail: {
            reason: components["schemas"]["WorkFailureType"];
            /** @description Customer-safe, actionable explanation of the failure. */
            message: string;
        };
        FactoryArtifact: {
            /** @description Stable artifact identifier referenced by session projections. */
            id: string;
            kind: components["schemas"]["FactoryArtifactKind"];
            visibility: components["schemas"]["FactoryArtifactVisibility"];
            /** @description Customer-visible artifact label. */
            label?: string;
            /** @description Customer-visible artifact summary. */
            summary?: string;
            auditMode?: components["schemas"]["FactoryArtifactAuditMode"];
            redactionCounts?: components["schemas"]["FactoryArtifactRedactionCounts"];
            captureMetadata?: components["schemas"]["FactoryArtifactCaptureMetadata"];
            /** @description Stable hash of the stored artifact payload. */
            contentHash?: string;
            /**
             * Format: int64
             * @description Stored artifact payload size in bytes.
             */
            sizeBytes?: number;
        };
        FactoryArtifactRef: {
            /** @description Stable artifact identifier referenced by session projections. */
            id: string;
            kind: components["schemas"]["FactoryArtifactKind"];
            visibility: components["schemas"]["FactoryArtifactVisibility"];
            /** @description Stable hash of the stored artifact payload. */
            contentHash?: string;
            /**
             * Format: int64
             * @description Stored artifact payload size in bytes.
             */
            sizeBytes?: number;
        };
        /**
         * @description Canonical factory artifact kind for session-owned outputs.
         * @enum {string}
         */
        FactoryArtifactKind: FactoryArtifactKind;
        /**
         * @description Visibility boundary for one factory artifact projection.
         * @enum {string}
         */
        FactoryArtifactVisibility: FactoryArtifactVisibility;
        /**
         * @description Audit mode applied when one factory artifact was captured.
         * @enum {string}
         */
        FactoryArtifactAuditMode: FactoryArtifactAuditMode;
        FactoryArtifactRedactionCounts: {
            /** Format: int32 */
            secrets?: number;
            /** Format: int32 */
            paths?: number;
            /** Format: int32 */
            tokens?: number;
        };
        FactoryArtifactCaptureMetadata: {
            /**
             * Format: date-time
             * @description Timestamp when the artifact payload was captured.
             */
            capturedAt?: string;
            /** @description Dispatch identifier that produced the artifact when applicable. */
            sourceDispatchId?: string;
            /** @description MIME type of the stored artifact payload when known. */
            mimeType?: string;
        };
        /**
         * @description Customer-visible session result availability for result update events.
         * @enum {string}
         */
        FactoryEventSessionResultStatus: FactoryEventSessionResultStatus;
        /**
         * @description Canonical workflow phase lifecycle status for orchestrator phase events.
         * @enum {string}
         */
        OrchestratorPhaseStatus: OrchestratorPhaseStatus;
        /**
         * @description Whether a recorded checkpoint can be used to resume session execution.
         * @enum {string}
         */
        CheckpointResumabilityStatus: CheckpointResumabilityStatus;
        /**
         * @description Source that produced a dispatch reconciliation fact.
         * @enum {string}
         */
        DispatchReconciliationSource: DispatchReconciliationSource;
        /** @description Session execution start recorded on the canonical factory event stream. Session and orchestrator identity live in FactoryEvent.context; this payload carries replay-safe factory and source facts only. */
        SessionStartedEventPayload: {
            /** @description Stable factory identifier for the session runtime. */
            factoryId?: string;
            /** @description Authored workflow or factory source reference when applicable. */
            sourceRef?: string;
            /** @description Stable hash of the authored source material. */
            sourceHash?: string;
            /** @description Stable hash of the effective orchestrator policy. */
            policyHash?: string;
            /** @description Stable digest of effective session arguments. */
            argsDigest?: string;
            /**
             * Format: date-time
             * @description When durable session execution started.
             */
            startedAt: string;
        };
        /** @description Factory Session lifecycle pause recorded on the canonical factory event stream. Session identity lives in FactoryEvent.context; this payload carries replay-safe control-transition facts only. */
        SessionPausedEventPayload: {
            /** @description Lifecycle status after a successful pause control. */
            status: components["schemas"]["FactorySessionDurableLifecycleStatus"];
            /**
             * Format: date-time
             * @description When the Factory Session entered PAUSED.
             */
            pausedAt: string;
        };
        /** @description Factory Session lifecycle resume recorded on the canonical factory event stream. Session identity lives in FactoryEvent.context; this payload carries replay-safe control-transition facts only. */
        SessionResumedEventPayload: {
            /** @description Lifecycle status after a successful resume control. */
            status: components["schemas"]["FactorySessionDurableLifecycleStatus"];
            /**
             * Format: date-time
             * @description When the Factory Session returned to RUNNING.
             */
            resumedAt: string;
        };
        /** @description Durable Factory Session lifecycle control recorded on the canonical factory event stream. Session identity lives in FactoryEvent.context; this payload carries replay-safe control facts only. */
        SessionLifecycleControlEventPayload: {
            operation: components["schemas"]["FactorySessionLifecycleControlKind"];
            outcome: components["schemas"]["FactorySessionLifecycleControlOutcome"];
            previousStatus: components["schemas"]["FactorySessionDurableLifecycleStatus"];
            newStatus: components["schemas"]["FactorySessionDurableLifecycleStatus"];
            /**
             * Format: date-time
             * @description When the lifecycle control took effect.
             */
            occurredAt: string;
            /** @description Optional operator-provided reason for the control request. */
            reason?: string;
        };
        /** @description Partial or final session result availability on the canonical factory event stream. Identity and ordering live in FactoryEvent.context. */
        SessionResultUpdatedEventPayload: {
            resultStatus: components["schemas"]["FactoryEventSessionResultStatus"];
            /** @description Artifact identifiers associated with this result update. */
            artifactIds?: string[];
            /** @description Bounded customer-visible result summary without raw prompts or secrets. */
            resultSummary?: components["schemas"]["WorkContent"];
        };
        /** @description Authoritative terminal session lifecycle marker on the canonical factory event stream. Session identity lives in FactoryEvent.context. */
        SessionCompletedEventPayload: {
            finalStatus: components["schemas"]["FactorySessionDurableLifecycleStatus"];
            /**
             * Format: date-time
             * @description When durable session execution reached a terminal state.
             */
            completedAt: string;
            /**
             * Format: int64
             * @description Total session execution duration in milliseconds.
             */
            durationMillis?: number;
            resultStatus?: components["schemas"]["FactoryEventSessionResultStatus"];
            /** @description Artifact identifiers associated with the terminal session outcome. */
            artifactIds?: string[];
            /** @description Dispatch queue, running, and completed counts at terminal completion. */
            dispatchCounts?: components["schemas"]["FactorySessionJavaScriptChildDispatchCounts"];
            /** @description Canonical failure details when the session completed unsuccessfully. */
            failureDetail?: components["schemas"]["FailureDetail"];
        };
        /** @description Orchestrator workflow phase transition recorded on the canonical factory event stream. Current phase identity lives in FactoryEvent.context. */
        OrchestratorPhaseChangedEventPayload: {
            /** @description Previous workflow phase identifier when available. */
            previousPhaseId?: string;
            /** @description Previous workflow phase name when available. */
            previousPhaseName?: string;
            phaseStatus: components["schemas"]["OrchestratorPhaseStatus"];
            /**
             * Format: date-time
             * @description When the current phase started, when applicable.
             */
            startedAt?: string;
            /**
             * Format: date-time
             * @description When the previous phase completed, when applicable.
             */
            completedAt?: string;
            /** @description Bounded customer-visible phase progress summary. */
            progressSummary?: string;
        };
        /** @description Orchestrator checkpoint reference recorded on the canonical factory event stream. Checkpoint identity lives in FactoryEvent.context and raw VM bodies remain orchestrator-owned. */
        OrchestratorCheckpointWrittenEventPayload: {
            /** @description Customer-visible checkpoint label. */
            label: string;
            /**
             * Format: date-time
             * @description When the checkpoint was recorded.
             */
            timestamp?: string;
            /** @description Stable hash of the authored workflow source at checkpoint time. */
            sourceHash?: string;
            /** @description Stable digest of replay-safe runtime snapshot metadata. */
            runtimeSnapshotDigest?: string;
            /** @description Checkpoint artifact reference without raw VM checkpoint bodies. */
            artifactRef?: components["schemas"]["FactoryArtifactRef"];
            resumabilityStatus: components["schemas"]["CheckpointResumabilityStatus"];
            /** @description Customer-visible checkpoint warnings. */
            warnings?: components["schemas"]["FactoryDispatchWarning"][];
        };
        /** @description Dispatch queued for execution on the canonical factory event stream. Dispatch identity lives in FactoryEvent.context and Petri transition fields are not required for JavaScript workflow dispatches. */
        DispatchQueuedEventPayload: {
            dispatchKind: components["schemas"]["FactoryDispatchKind"];
            /** @description Customer-visible dispatch label. */
            label?: string;
            /** @description Optional coordination reference for grouped child work. */
            coordinationRef?: string;
            /** @description Selected runner identifier when applicable. */
            runnerId?: string;
            /** @description Resolved operator worker preset identifier when one was selected. */
            presetId?: string;
            /** @description Resolved canonical model-provider identifier when applicable. */
            modelProvider?: string;
            /** @description Selected model identifier when applicable. */
            model?: string;
            /** @description Resolved canonical reasoning effort when applicable. */
            reasoningEffort?: string;
            /** @description Selected provider identifier when applicable. */
            provider?: string;
            /** @description Parent dispatch identifier when this dispatch was spawned from another dispatch. */
            parentDispatchId?: string;
            /** @description Prior dispatch identifier when this dispatch is a retry. */
            retryOfDispatchId?: string;
            /** @description Queue position when known. */
            queuePosition?: number;
            /** @description Stable digest of rendered prompt material. */
            promptDigest?: string;
            /** @description Stable digest of the output schema when applicable. */
            schemaDigest?: string;
            /** @description Input artifact identifiers consumed by the dispatch. */
            inputArtifactIds?: string[];
            /** @description Input work identifiers consumed by the dispatch. */
            inputWorkIds?: string[];
        };
        /** @description Dispatch interruption recorded on the canonical factory event stream. Dispatch identity lives in FactoryEvent.context. */
        DispatchInterruptedEventPayload: {
            /** @description Customer-visible interruption reason. */
            reason: string;
            observedStatus: components["schemas"]["FactoryDispatchStatus"];
            /**
             * Format: date-time
             * @description When the interruption was observed.
             */
            interruptedAt: string;
            /** @description Whether a retry dispatch is planned. */
            retryPlanned: boolean;
            /** @description Related provider-session reference when applicable. */
            providerSessionRef?: components["schemas"]["LoadableProviderSessionRef"];
            /** @description Related checkpoint reference when applicable. */
            checkpointRef?: components["schemas"]["FactorySessionJavaScriptCheckpointRef"];
        };
        /** @description Dispatch reconciliation recorded on the canonical factory event stream. Dispatch identity lives in FactoryEvent.context. */
        DispatchReconciledEventPayload: {
            reconciledStatus: components["schemas"]["FactoryDispatchStatus"];
            reconciliationSource: components["schemas"]["DispatchReconciliationSource"];
            /** @description Whether reconciliation facts were emitted during stream replay. */
            replayed: boolean;
            /** @description Usage summary after reconciliation when available. */
            usage?: components["schemas"]["FactoryDispatchUsage"];
            /** @description Result artifact reference without raw artifact bodies. */
            resultArtifactRef?: components["schemas"]["FactoryArtifactRef"];
            /** @description Artifact identifiers produced or updated by reconciliation. */
            artifactIds?: string[];
            /** @description Canonical failure details when reconciliation failed. */
            failureDetail?: components["schemas"]["FailureDetail"];
        };
        /** @description Customer-visible JavaScript checkpoint reference recorded on the canonical factory event stream. Raw VM checkpoint bodies remain orchestrator-owned and are not included in this payload. */
        JavaScriptCheckpointRefEventPayload: {
            /** @description Stable checkpoint identifier referenced by the session runtime. */
            checkpointId: string;
            /** @description Customer-visible checkpoint label. */
            label?: string;
            /**
             * Format: date-time
             * @description When the checkpoint was recorded.
             */
            timestamp?: string;
            /** @description Short customer-visible checkpoint summary without raw VM state. */
            summary?: string;
            artifactRef: components["schemas"]["FactoryArtifactRef"];
        };
        /** @description JavaScript workflow phase transition recorded on the canonical factory event stream. JavaScript workflow progress is represented through phase changes, not Petri WORK_STATE_CHANGE marking events. */
        JavaScriptPhaseChangeEventPayload: {
            /** @description Current JavaScript workflow phase name after this event. */
            phase: string;
            /** @description Ordered phase names visible in the session runtime. */
            phases: string[];
            /** @description Stable digest of the effective workflow arguments. */
            argsDigest?: string;
            scriptStatus: components["schemas"]["FactorySessionJavaScriptScriptStatus"];
            childDispatchCounts: components["schemas"]["FactorySessionJavaScriptChildDispatchCounts"];
        };
        /** @description Customer-visible artifact creation recorded on the canonical factory event stream. Artifact bodies remain orchestrator-owned and are not included in this payload. */
        ArtifactCreatedEventPayload: {
            artifact: components["schemas"]["FactoryArtifact"];
            /**
             * Format: date-time
             * @description When the artifact payload was captured.
             */
            capturedAt?: string;
        };
        ListFactorySessionsResponse: {
            /** @description Applied list scope echoed in the response when provided by the server. */
            scope?: components["schemas"]["FactorySessionListScope"];
            /** @description Live workspace session summaries when scope is LIVE or ALL. */
            sessions: components["schemas"]["FactorySessionSummary"][];
            /** @description Persisted durable session summaries when scope is PERSISTED or ALL. */
            durableSessions?: components["schemas"]["FactorySessionDurableSummary"][];
        };
        /**
         * @description Session list scope. live returns workspace sessions kept open by the runtime host. persisted returns durable execution sessions stored outside the live workspace. all returns both live and persisted session summaries.
         * @default live
         * @enum {string}
         */
        FactorySessionListScope: FactorySessionListScope;
        FactorySessionDurableSummary: {
            /** @description Stable durable factory-session identifier. */
            sessionId: string;
            status: components["schemas"]["FactorySessionDurableLifecycleStatus"];
            orchestratorKind: components["schemas"]["FactoryOrchestratorKind"];
            /** @description Resolved orchestrator dialect when orchestratorKind = JAVASCRIPT. */
            dialect?: string;
            resolvedSource: components["schemas"]["FactorySessionResolvedSourceIdentity"];
            /** @description Stable hash of the resolved workflow or factory source when available. */
            sourceHash?: string;
            /** @description Caller-requested policy from the original execution request when available. */
            requestedPolicy?: components["schemas"]["FactorySessionRequestedPolicy"];
            /** @description Effective approved orchestrator policy after any required approval. */
            effectivePolicy?: components["schemas"]["FactorySessionEffectivePolicy"];
            /** @description Stable hash of the effective approved orchestrator policy when available. Mirrors effectivePolicy.policyHash when both are present. */
            effectivePolicyHash?: string;
            /** @description Current workflow phase when execution is in progress. */
            phase?: string;
            progress?: components["schemas"]["FactorySessionDurableProgressCounts"];
            resultSummary?: components["schemas"]["FactorySessionDurableResultSummary"];
            /** @description Number of customer-visible artifacts associated with the session. */
            artifactCount?: number;
            /** @description True when the durable session is interrupted or has a stale lease while still appearing active. */
            recoverable?: boolean;
            actions?: components["schemas"]["FactorySessionDurableActionAvailability"];
            /** @description True when the durable session lease is stale or interrupted while status still appears active. */
            staleLease?: boolean;
            lifecycle?: components["schemas"]["FactorySessionDurableLifecycleTimestamps"];
            /** @description Polling and inspection links for durable session clients. */
            links?: components["schemas"]["FactorySessionExecutionLinks"];
        };
        /** @description Durable factory-session inspection read model. Exposes public source refs and hashes without raw workflow source, unrestricted host paths, or diagnostic artifacts. */
        FactorySessionDurableReadModel: {
            /** @description Stable durable factory-session identifier. */
            sessionId: string;
            status: components["schemas"]["FactorySessionDurableLifecycleStatus"];
            orchestratorKind: components["schemas"]["FactoryOrchestratorKind"];
            /** @description Resolved orchestrator dialect when orchestratorKind = JAVASCRIPT. */
            dialect?: string;
            resolvedSource: components["schemas"]["FactorySessionResolvedSourceIdentity"];
            /** @description Stable hash of the resolved workflow or factory source when available. */
            sourceHash?: string;
            /** @description Caller-requested policy from the original execution request when available. */
            requestedPolicy?: components["schemas"]["FactorySessionRequestedPolicy"];
            /** @description Effective approved orchestrator policy after any required approval. */
            effectivePolicy?: components["schemas"]["FactorySessionEffectivePolicy"];
            /** @description Stable hash of the effective approved orchestrator policy when available. Mirrors effectivePolicy.policyHash when both are present. */
            effectivePolicyHash?: string;
            /** @description Current workflow phase when execution is in progress. */
            phase?: string;
            /** @description Per-phase dispatch summaries for workflow inspection. */
            phaseSummaries?: components["schemas"]["FactorySessionDurablePhaseSummary"][];
            /** @description Latest durable checkpoint, absent when no checkpoint has been written. */
            latestCheckpoint?: components["schemas"]["FactorySessionCheckpointRef"];
            progress?: components["schemas"]["FactorySessionDurableProgressCounts"];
            budgets?: components["schemas"]["FactorySessionBudgets"];
            usage?: components["schemas"]["FactorySessionUsage"];
            /** @description Customer-visible artifact refs without raw artifact bodies. */
            artifactRefs?: components["schemas"]["FactoryArtifactRef"][];
            resultSummary?: components["schemas"]["FactorySessionDurableResultSummary"];
            failureDetail?: components["schemas"]["FailureDetail"];
            /** @description Whether partial results remain inspectable after the failure. */
            partialResultAvailable?: boolean;
            lifecycle?: components["schemas"]["FactorySessionDurableLifecycleTimestamps"];
            /** @description True when the durable session lease is stale or interrupted while status still appears active. */
            staleLease?: boolean;
            /** @description Polling and inspection links for durable session clients. */
            links?: components["schemas"]["FactorySessionExecutionLinks"];
        };
        /** @description Factory session inspection response. Live workspace sessions return the existing FactorySession projection. Durable execution sessions return the durable read model. */
        FactorySessionGetResponse: components["schemas"]["FactorySession"] | components["schemas"]["FactorySessionDurableReadModel"];
        FactorySessionDurablePhaseSummary: {
            /** @description Workflow phase name for this summary row. */
            phase: string;
            /** @description Customer-visible phase label when different from the phase name. */
            label?: string;
            /** @description Total dispatches attributed to this phase. */
            dispatchCount?: number;
            /** @description Dispatches that reached a terminal success state in this phase. */
            completedDispatchCount?: number;
            /** @description Dispatches that failed in this phase. */
            failedDispatchCount?: number;
        };
        FactorySessionCheckpointRef: {
            /** @description Stable checkpoint identifier used for later inspection or resume. */
            id: string;
            /** @description Customer-visible checkpoint label when supplied by the orchestrator. */
            label?: string;
            /** @description Phase active when the checkpoint was written. */
            phase?: string;
        };
        FactorySessionDurableProgressCounts: {
            /** @description Total durable dispatches recorded for the session. */
            totalDispatches?: number;
            /** @description Dispatches that reached a terminal success state. */
            completedDispatches?: number;
            /** @description Dispatches that reached a terminal failure state. */
            failedDispatches?: number;
            /** @description Dispatches currently running or awaiting completion. */
            inFlightDispatches?: number;
            /** @description Dispatches waiting to start. */
            queuedDispatches?: number;
            /** @description Dispatches currently running. */
            runningDispatches?: number;
            /** @description Dispatches canceled before completion. */
            canceledDispatches?: number;
            /** @description Dispatches that exceeded their execution deadline. */
            timedOutDispatches?: number;
            /** @description Dispatches skipped by orchestration policy. */
            skippedDispatches?: number;
            /** @description Dispatches interrupted after starting. */
            interruptedDispatches?: number;
            /** @description Number of workflow phases represented in phase summaries. */
            phaseCount?: number;
        };
        /** @description Lifecycle controls currently available for one listed durable factory session. */
        FactorySessionDurableActionAvailability: {
            /** @description True when pause is currently valid for the session status. */
            canPause?: boolean;
            /** @description True when resume is currently valid for the session status. */
            canResume?: boolean;
            /** @description True when cancel is currently valid for the session status. */
            canCancel?: boolean;
            /** @description True when terminate is currently valid for the session status. */
            canTerminate?: boolean;
            /** @description True when approval is currently required and available. */
            canApprove?: boolean;
            /** @description True when retry-dispatch is currently valid for the session status. */
            canRetryDispatch?: boolean;
            /** @description True when interrupt-dispatch is currently valid for the session status. */
            canInterruptDispatch?: boolean;
        };
        FactorySessionDurableResultSummary: {
            resultStatus: components["schemas"]["FactorySessionResultStatus"];
            /** @description Short customer-visible summary of the current or final result. */
            summary?: string;
            /** @description Artifact refs for large or non-text outputs without raw bodies. */
            artifactRefs?: components["schemas"]["FactoryArtifactRef"][];
        };
        FactorySessionDurableLifecycleTimestamps: {
            /**
             * Format: date-time
             * @description When the durable session entered the queued state.
             */
            queuedAt?: string;
            /**
             * Format: date-time
             * @description When the durable session began awaiting approval.
             */
            awaitingApprovalAt?: string;
            /**
             * Format: date-time
             * @description When durable execution started.
             */
            startedAt?: string;
            /**
             * Format: date-time
             * @description When the durable session was most recently paused.
             */
            pausedAt?: string;
            /**
             * Format: date-time
             * @description When the durable session was most recently resumed.
             */
            resumedAt?: string;
            /**
             * Format: date-time
             * @description When the durable session reached a terminal finished state.
             */
            finishedAt?: string;
            /**
             * Format: date-time
             * @description When the durable session projection was last refreshed.
             */
            updatedAt?: string;
            /**
             * Format: date-time
             * @description When the durable session was interrupted.
             */
            interruptedAt?: string;
            /**
             * Format: date-time
             * @description When the durable session was explicitly terminated.
             */
            terminatedAt?: string;
        };
        /**
         * @description Customer-visible durable session result availability for session read models and result retrieval endpoints.
         * @enum {string}
         */
        FactorySessionResultStatus: FactorySessionResultStatus;
        OpenFactorySessionRequest: {
            folderPath: string;
            target?: components["schemas"]["FactorySessionTargetRef"];
            /** @description When true, validate the folder and optional target selection without creating a live session. */
            validateOnly?: boolean;
            /** @description When true, write the default init scaffold at folderPath and open a live session. Mutually exclusive with validateOnly. */
            initNewFactory?: boolean;
        };
        OpenFactorySessionResponse: {
            session?: components["schemas"]["FactorySessionSummary"];
            targets?: components["schemas"]["FactorySessionTarget"][];
            /** @description When true, validate-only inspection found a readable folder with no runnable factory targets; the client may offer to create the default init scaffold at folderPath. */
            initsNewFactory?: boolean;
            /** @description Absolute resolved session folder path when initsNewFactory is true. */
            folderPath?: string;
        };
        /** @description Normalized durable factory-session execution request shared by async and sync start routes. Idempotency compares requestId against the normalized tuple of source, args, orchestrator, and requestedPolicy. Replaying the same requestId with the same normalized tuple returns the existing session or sync result instead of starting duplicate work. Reusing requestId with a materially different tuple returns 409 Conflict with EXECUTION_REQUEST_ID_CONFLICT. */
        FactorySessionExecutionRequest: {
            /** @description Caller-supplied idempotency key. Normalization includes source kind and kind-specific selector, JSON-canonical args, orchestrator when present, and requestedPolicy when present (preferring policyHash when supplied). Replays with the same normalized tuple return the existing session instead of starting duplicate work. */
            requestId: string;
            source: components["schemas"]["FactorySessionExecutionSource"];
            /** @description Structured workflow invocation arguments validated by the resolved source. */
            args?: {
                [key: string]: unknown;
            };
            /** @description Optional orchestrator override when the resolved source does not fully determine orchestration. */
            orchestrator?: components["schemas"]["FactoryOrchestrator"];
            /** @description Caller-requested orchestrator policy before approval, if required. */
            requestedPolicy?: components["schemas"]["FactorySessionRequestedPolicy"];
            /** @description Optional timeout and cancel-on-timeout behavior, primarily for sync execution. */
            wait?: components["schemas"]["FactorySessionExecutionWaitOptions"];
        };
        /** @description Durable execution source selector. Exactly one payload field matching `kind` must be supplied. WORKFLOW_FILE and WORKFLOW_NAME sources resolve using FactorySessionWorkflowSourceResolutionOrder: project `.claude/workflows`, user `~/.you-agent-factory/workflows`, package-relative workflow directories, built-in/global JavaScript factories, then explicit factory lookup when requested or required by the reference. */
        FactorySessionExecutionSource: {
            kind: components["schemas"]["FactorySessionExecutionSourceKind"];
            /** @description Stored named factory identifier when kind = FACTORY_ID. */
            factoryId?: string;
            /** @description Inline factory definition when kind = FACTORY_INLINE. */
            factoryInline?: components["schemas"]["Factory"];
            /** @description Workflow file path or reference when kind = WORKFLOW_FILE. */
            workflowFile?: string;
            /** @description Authored workflow name when kind = WORKFLOW_NAME. */
            workflowName?: string;
            /** @description Inline workflow source when kind = INLINE_WORKFLOW. */
            inlineWorkflow?: components["schemas"]["FactorySessionExecutionInlineWorkflow"];
        };
        /**
         * @description Durable execution source category. Each kind selects which source field on FactorySessionExecutionSource is authoritative for workflow resolution.
         * @enum {string}
         */
        FactorySessionExecutionSourceKind: FactorySessionExecutionSourceKind;
        /**
         * @example {
         *       "factorySessionId": "session-alpha",
         *       "outcome": "CURSOR_STALE",
         *       "retry": {
         *         "omitAfterEventId": true,
         *         "omitAfterSequence": true
         *       }
         *     }
         */
        FactorySessionEventStreamRecovery: {
            /** @description Session identifier for the event stream being probed. */
            factorySessionId: string;
            outcome: components["schemas"]["FactorySessionEventStreamRecoveryOutcome"];
            retry: components["schemas"]["FactorySessionEventStreamRecoveryRetry"];
        };
        /**
         * @description Structured session event reconnect probe outcome for one session-scoped event stream.
         * @example CURSOR_STALE
         * @enum {string}
         */
        FactorySessionEventStreamRecoveryOutcome: FactorySessionEventStreamRecoveryOutcome;
        /**
         * @example {
         *       "omitAfterEventId": true,
         *       "omitAfterSequence": true
         *     }
         */
        FactorySessionEventStreamRecoveryRetry: {
            /** @description True when the next reconnect must omit after_event_id and replay from the start of the session stream. */
            omitAfterEventId: boolean;
            /** @description True when the next reconnect must omit after_sequence and replay from the start of the session stream. */
            omitAfterSequence: boolean;
        };
        /** @description Inline workflow source carried directly in a durable execution request. */
        FactorySessionExecutionInlineWorkflow: {
            /** @description Optional JavaScript workflow dialect label for the inline source. */
            dialect?: string;
            inlineSource: components["schemas"]["FactoryOrchestratorJavaScriptInlineSource"];
            /** @description Optional exported entrypoint or phase name used to start the workflow. */
            entrypoint?: string;
            /** @description Free-form workflow metadata for authoring and diagnostics. */
            metadata?: components["schemas"]["StringMap"];
        };
        /** @description Caller-requested orchestrator policy for one durable execution before approval. Runtimes may require approval before this payload becomes effective. Responses return the approved policy separately as FactorySessionEffectivePolicy. */
        FactorySessionRequestedPolicy: {
            /** @description Optional stable hash of the requested policy object when the caller already computed one for idempotency comparisons. */
            policyHash?: string;
        } & {
            [key: string]: unknown;
        };
        /** @description Effective approved orchestrator policy for one durable execution after any required approval. Distinct from FactorySessionRequestedPolicy, which captures caller intent before approval. */
        FactorySessionEffectivePolicy: {
            /** @description Stable hash of the effective approved policy object when available. */
            policyHash?: string;
        } & {
            [key: string]: unknown;
        };
        /**
         * @description Documented workflow and factory source resolution order for durable execution. WORKFLOW_FILE and WORKFLOW_NAME sources are resolved in this order: (1) project `.claude/workflows`, (2) user `~/.you-agent-factory/workflows`, (3) package-relative workflow directories for the active project or package, (4) built-in/global JavaScript factories, (5) explicit named factory lookup when `source.kind` is FACTORY_ID or when a workflow reference requires factory fallback. FACTORY_ID resolves a stored named factory directly. FACTORY_INLINE and INLINE_WORKFLOW use the inline payload from the request without filesystem search.
         * @enum {string}
         */
        FactorySessionWorkflowSourceResolutionOrder: FactorySessionWorkflowSourceResolutionOrder;
        /** @description Optional wait and timeout controls for durable execution. Sync routes use these options to bound how long the server waits for a terminal result. Async routes may accept them for future compatibility but do not block on terminal completion. */
        FactorySessionExecutionWaitOptions: {
            /**
             * Format: int64
             * @description Maximum wait budget in milliseconds for sync execution.
             */
            timeoutMillis?: number;
            /**
             * @description When true and a sync wait ends by timeout, the server may cancel the session. When false or omitted, timeout responses must not imply the session was canceled.
             * @default false
             */
            cancelOnTimeout: boolean;
        };
        /** @description Resolved durable execution source identity exposed to API clients without raw workflow source, unrestricted host paths, or diagnostic artifacts. */
        FactorySessionResolvedSourceIdentity: {
            kind: components["schemas"]["FactorySessionExecutionSourceKind"];
            /** @description Safe customer-facing source reference after resolution. */
            sourceRef?: string;
            /** @description Stable hash of the resolved workflow or factory source when available. */
            sourceHash?: string;
            /** @description Resolved workflow dialect when applicable. */
            dialect?: string;
            /** @description Safe resolved source metadata for clients and dashboards. */
            metadata?: components["schemas"]["StringMap"];
            /** @description Resolution stages that matched for WORKFLOW_FILE and WORKFLOW_NAME sources. Omitted for inline and direct factory-id sources. */
            resolutionOrder?: components["schemas"]["FactorySessionWorkflowSourceResolutionOrder"][];
        };
        /**
         * @description Durable factory-session lifecycle status returned by execution start routes and later session read models. Live-session runtime statuses remain separate on the existing FactorySessionStatus schema.
         * @enum {string}
         */
        FactorySessionDurableLifecycleStatus: FactorySessionDurableLifecycleStatus;
        /** @description Relative links for polling and inspecting one durable factory session. */
        FactorySessionExecutionLinks: {
            /** @description Relative URL for GET /factory-sessions/{session_id}. */
            session?: string;
            /** @description Relative URL for GET /factory-sessions/{session_id}/events. */
            events?: string;
            /** @description Relative URL for GET /factory-sessions/{session_id}/results. */
            results?: string;
            /** @description Relative URL for polling durable session status. */
            status?: string;
        };
        FactorySessionExecutionResponse: {
            /** @description Stable durable factory-session identifier. */
            sessionId: string;
            status: components["schemas"]["FactorySessionDurableLifecycleStatus"];
            orchestratorKind: components["schemas"]["FactoryOrchestratorKind"];
            /** @description Resolved orchestrator dialect when orchestratorKind = JAVASCRIPT. */
            dialect?: string;
            resolvedSource: components["schemas"]["FactorySessionResolvedSourceIdentity"];
            /** @description Stable hash of the resolved workflow or factory source when available. */
            sourceHash?: string;
            /** @description Caller-requested policy echoed from the execution request when available. */
            requestedPolicy?: components["schemas"]["FactorySessionRequestedPolicy"];
            /** @description Effective approved orchestrator policy after any required approval. */
            effectivePolicy?: components["schemas"]["FactorySessionEffectivePolicy"];
            /** @description Stable hash of the effective approved orchestrator policy when available. Mirrors effectivePolicy.policyHash when both are present. */
            effectivePolicyHash?: string;
            /** @description Polling and inspection links for async clients. */
            links?: components["schemas"]["FactorySessionExecutionLinks"];
        };
        /**
         * @description Sync durable execution wait outcome. TIMED_OUT does not imply the session was canceled unless the request set wait.cancelOnTimeout to true.
         * @enum {string}
         */
        FactorySessionSyncExecutionOutcome: FactorySessionSyncExecutionOutcome;
        /** @description Sync durable execution response. Returns the normalized execution identity plus sync wait outcome and, when available before timeout, the terminal FactorySessionResult. */
        FactorySessionSyncExecutionResponse: {
            /** @description Stable durable factory-session identifier. */
            sessionId: string;
            status: components["schemas"]["FactorySessionDurableLifecycleStatus"];
            orchestratorKind: components["schemas"]["FactoryOrchestratorKind"];
            /** @description Resolved orchestrator dialect when orchestratorKind = JAVASCRIPT. */
            dialect?: string;
            resolvedSource: components["schemas"]["FactorySessionResolvedSourceIdentity"];
            /** @description Stable hash of the resolved workflow or factory source when available. */
            sourceHash?: string;
            /** @description Caller-requested policy echoed from the execution request when available. */
            requestedPolicy?: components["schemas"]["FactorySessionRequestedPolicy"];
            /** @description Effective approved orchestrator policy after any required approval. */
            effectivePolicy?: components["schemas"]["FactorySessionEffectivePolicy"];
            /** @description Stable hash of the effective approved orchestrator policy when available. Mirrors effectivePolicy.policyHash when both are present. */
            effectivePolicyHash?: string;
            /** @description Inspection links for the started session. */
            links?: components["schemas"]["FactorySessionExecutionLinks"];
            syncOutcome: components["schemas"]["FactorySessionSyncExecutionOutcome"];
            /** @description Terminal session result when syncOutcome = COMPLETED. */
            result?: components["schemas"]["FactorySessionResult"];
            /** @description True when syncOutcome = TIMED_OUT. */
            timedOut?: boolean;
            /** @description True only when timedOut is true and the request explicitly set wait.cancelOnTimeout to true. */
            sessionCanceledByTimeout?: boolean;
        };
        /**
         * @description Durable factory-session lifecycle control operation requested by the client.
         * @enum {string}
         */
        FactorySessionLifecycleControlKind: FactorySessionLifecycleControlKind;
        PackagedFactoryCatalogResponse: {
            /** @description Built-in Factory definitions in stable lexical name order. */
            factories: components["schemas"]["PackagedFactoryCatalogEntry"][];
        };
        PackagedFactoryCatalogEntry: {
            /** @description Public built-in Factory name, such as '@you/goal'. */
            name: string;
            /** @description Stable Factory project identifier. */
            project: string;
            /** @description URL-safe Factory catalog identity. */
            slug: string;
            /** @description Localized customer-facing explanation of what this packaged Factory does. */
            description: components["schemas"]["NameValue"];
            /** @description Representative runnable invocations published by this packaged Factory. */
            examples: components["schemas"]["FactoryInvocationExample"][];
            /** @description Canonical Factory JSON artifact. */
            json: {
                [key: string]: unknown;
            };
            /** @description Equivalent Factory YAML artifact. */
            yaml: string;
        };
        /**
         * @description Typed lifecycle-control outcome. ACCEPTED means the control request was accepted and may complete asynchronously. NO_OP means the session was already in the requested end state. INVALID_STATE means the current session state does not allow the requested control. TERMINAL_SESSION means the session is already terminal and cannot accept the requested control. CONFLICT means another in-flight or incompatible control prevents the request.
         * @enum {string}
         */
        FactorySessionLifecycleControlOutcome: FactorySessionLifecycleControlOutcome;
        /** @description Relative links for inspecting durable session state after lifecycle controls. Partial results, dispatches, and artifacts remain inspectable after pause, resume, cancel, and terminate operations. */
        FactorySessionLifecycleControlLinks: {
            /** @description Relative URL for GET /factory-sessions/{session_id}. */
            session?: string;
            /** @description Relative URL for GET /factory-sessions/{session_id}/results. */
            results?: string;
            /** @description Relative URL for GET /factory-sessions/{session_id}/dispatches. */
            dispatches?: string;
            /** @description Relative URL for GET /factory-sessions/{session_id}/artifacts. */
            artifacts?: string;
            /** @description Relative URL for GET /factory-sessions/{session_id}/events. */
            events?: string;
            /** @description Relative URL for polling durable session status. */
            status?: string;
        };
        /** @description Optional metadata shared by durable session lifecycle control requests. */
        FactorySessionLifecycleControlRequest: {
            /** @description Optional idempotency key for one lifecycle control request. Replaying the same requestId with the same operation and target must return the prior control outcome instead of applying a second mutation. */
            requestId?: string;
            /** @description Optional operator-provided reason for audit and diagnostics. */
            reason?: string;
        };
        /** @description Approval request for one durable factory session awaiting policy approval. */
        FactorySessionApproveRequest: {
            /** @description Optional idempotency key for one lifecycle control request. Replaying the same requestId with the same operation and target must return the prior control outcome instead of applying a second mutation. */
            requestId?: string;
            /** @description Optional operator-provided reason for audit and diagnostics. */
            reason?: string;
            /** @description Optional approval preview identity when the caller reviewed a server-side approval preview before submitting approval. */
            approvalPreviewId?: string;
            /** @description Optional approved policy payload when the caller explicitly approves a policy object distinct from the originally requested policy. */
            approvedPolicy?: components["schemas"]["FactorySessionRequestedPolicy"];
        };
        /** @description Retry request for one durable factory-session dispatch. */
        FactorySessionRetryDispatchRequest: {
            /** @description Optional idempotency key for one lifecycle control request. Replaying the same requestId with the same operation and target must return the prior control outcome instead of applying a second mutation. */
            requestId?: string;
            /** @description Optional operator-provided reason for audit and diagnostics. */
            reason?: string;
            /** @description Stable dispatch identifier to retry within the targeted session. */
            dispatchId: string;
            /**
             * @description When true, request a new retry attempt even if the dispatch already has a successful or in-flight retry.
             * @default false
             */
            forceNewAttempt: boolean;
            /**
             * @description When true, reset the dispatch attempt counter before retrying. Runtimes may ignore this when policy forbids attempt resets.
             * @default false
             */
            resetAttemptCount: boolean;
        };
        /** @description Interrupt request for one active durable factory-session dispatch. */
        FactorySessionInterruptDispatchRequest: {
            /** @description Optional idempotency key for one lifecycle control request. Replaying the same requestId with the same operation and target must return the prior control outcome instead of applying a second mutation. */
            requestId?: string;
            /** @description Optional operator-provided reason for audit and diagnostics. */
            reason?: string;
            /** @description Stable dispatch identifier to interrupt within the targeted session. */
            dispatchId: string;
        };
        FactorySessionLifecycleControlResponse: {
            /** @description Stable durable factory-session identifier. */
            sessionId: string;
            operation: components["schemas"]["FactorySessionLifecycleControlKind"];
            outcome: components["schemas"]["FactorySessionLifecycleControlOutcome"];
            /** @description Current durable session lifecycle status after evaluating the control request. */
            status: components["schemas"]["FactorySessionDurableLifecycleStatus"];
            /** @description Updated durable session read model when immediately available. */
            session?: components["schemas"]["FactorySessionDurableReadModel"];
            /** @description Stable hash of the effective approved orchestrator policy after approval or other policy-affecting controls. */
            effectivePolicyHash?: string;
            /** @description Approval preview identity associated with the approved policy when available. */
            approvalPreviewId?: string;
            /** @description Target dispatch identifier for retry-dispatch controls. */
            dispatchId?: string;
            /** @description Identifier of the dispatch created or selected by a retry-dispatch control when the runtime materializes a distinct retry dispatch. */
            retryDispatchId?: string;
            /** @description Optional human-readable detail explaining NO_OP or rejected outcomes. */
            detail?: string;
            /** @description Inspection links for session, results, dispatches, and artifacts. */
            links?: components["schemas"]["FactorySessionLifecycleControlLinks"];
        };
        LoadableProviderSessionRef: {
            provider: components["schemas"]["LoadableProviderSessionProvider"];
            kind: components["schemas"]["LoadableProviderSessionKind"];
            /** @description Provider-session identifier to resolve. This is an identifier, not a filesystem path. */
            id: string;
        };
        /**
         * @description Canonical provider value for provider-session detail requests that can be loaded by the API.
         * @enum {string}
         */
        LoadableProviderSessionProvider: LoadableProviderSessionProvider;
        /**
         * @description Canonical provider-session identifier kind for provider-session detail requests that can be loaded by the API.
         * @enum {string}
         */
        LoadableProviderSessionKind: LoadableProviderSessionKind;
        ProviderSessionSourceMetadata: {
            /** @description Path to the loaded session file relative to the configured provider sessions root. */
            relativePath: string;
            /**
             * Format: int64
             * @description Size of the loaded session file in bytes.
             */
            sizeBytes: number;
            /**
             * Format: date-time
             * @description Filesystem modification time when available.
             */
            modifiedAt?: string;
        };
        ProviderSessionParseSummary: {
            /** @description Number of JSON event records parsed from the session stream. */
            eventCount: number;
            /** @description Number of non-empty event-stream lines inspected. */
            lineCount: number;
            /** @description Number of non-empty lines that could not be parsed as JSON objects. */
            malformedLineCount: number;
            /** @description Number of parsed JSON events without a recognized type field. */
            unknownEventCount: number;
            /** @description Chronological execution turns inferred from turn boundaries and response activity. */
            turns: components["schemas"]["ProviderSessionTurnSummary"][];
            /** @description Function and tool calls observed in chronological order. */
            functionCalls: components["schemas"]["ProviderSessionFunctionCallSummary"][];
            /** @description Reasoning entries or summaries observed in chronological order. */
            reasoning: components["schemas"]["ProviderSessionReasoningSummary"][];
            tokenUsage?: components["schemas"]["ProviderSessionTokenUsage"];
            /** @description Line-level parse errors for malformed event-stream records. */
            parseErrors: components["schemas"]["ProviderSessionLineError"][];
            /** @description Compact list of events with unknown or unsupported type fields. */
            unknownEvents: components["schemas"]["ProviderSessionUnknownEvent"][];
        };
        ProviderSessionTurnSummary: {
            /** @description One-based chronological execution turn index. */
            index: number;
            /** @description Number of parsed events associated with the turn. */
            eventCount: number;
            /** @description Number of response_item records associated with the turn. */
            responseItemCount: number;
            /** @description Number of function or tool calls associated with the turn. */
            functionCallCount: number;
            /** @description Number of reasoning entries associated with the turn. */
            reasoningCount: number;
            /**
             * Format: date-time
             * @description First event timestamp associated with the turn when present.
             */
            startedAt?: string;
        };
        ProviderSessionFunctionCallSummary: {
            /** @description Chronological order of the function or tool call in the session stream. */
            order: number;
            /** @description One-based execution turn index associated with the call when inferable. */
            turnIndex?: number;
            /** @description Provider call identifier when present in the session stream. */
            callId?: string;
            /** @description Raw response item type for the call, such as function_call or custom_tool_call. */
            type: string;
            /** @description Function or tool name when present. */
            name?: string;
            /** @description Compact argument payload when present. */
            arguments?: string;
            /** @description Compact output payload when present. */
            output?: string;
            /** @description Result status inferred from the call output or explicit status fields. */
            status?: string;
        };
        ProviderSessionReasoningSummary: {
            /** @description Chronological order of the reasoning entry in the session stream. */
            order: number;
            /** @description One-based execution turn index associated with the reasoning entry when inferable. */
            turnIndex?: number;
            /** @description Event or response item type that carried the reasoning entry. */
            sourceType: string;
            /** @description Reasoning text when plaintext content is present. */
            text?: string;
            /** @description Compact reasoning summary when present. */
            summary?: string;
            /** @description Whether the reasoning entry only exposed encrypted content. */
            encrypted?: boolean;
            /** @description Compact encrypted reasoning payload when the provider exposes it. */
            encryptedContent?: string;
        };
        ProviderSessionTokenUsage: {
            inputTokens?: number;
            cachedInputTokens?: number;
            cacheWriteTokens?: number;
            outputTokens?: number;
            reasoningOutputTokens?: number;
            totalTokens?: number;
        };
        ProviderSessionLineError: {
            /** @description One-based line number of the malformed event-stream record. */
            lineNumber: number;
            /** @description Client-safe parse error message for the malformed line. */
            message: string;
        };
        ProviderSessionUnknownEvent: {
            /** @description One-based line number of the unknown event. */
            lineNumber: number;
            /** @description Raw top-level event type when present. */
            type?: string;
            /** @description Raw nested payload type when present. */
            payloadType?: string;
        };
        /**
         * @description Canonical transcript entry type used by the dashboard transcript view.
         * @enum {string}
         */
        ProviderSessionTranscriptEntryType: ProviderSessionTranscriptEntryType;
        ProviderSessionTranscriptEntry: {
            /** @description Stable chronological order of the transcript entry in the session stream. */
            order: number;
            type: components["schemas"]["ProviderSessionTranscriptEntryType"];
            /** @description One-based inferred turn index when the session parser can associate the entry with a turn. */
            turnIndex?: number;
            /**
             * Format: date-time
             * @description Provider event timestamp when present in the source session stream.
             */
            timestamp?: string;
            /** @description One-based JSONL line number that produced this transcript entry when applicable. */
            lineNumber?: number;
            /** @description Raw provider event or item type that produced this transcript entry. */
            sourceType?: string;
            /** @description Provider tool-call identifier when present. */
            callId?: string;
            /** @description Tool or function name when present. */
            name?: string;
            /** @description Provider or inferred status value when present. */
            status?: string;
            /** @description Plaintext transcript body when present. */
            text?: string;
            /** @description Compact summary text when the provider emits a separate summary channel. */
            summary?: string;
            /** @description Compact tool-call arguments when present. */
            arguments?: string;
            /** @description Compact tool output when present. */
            output?: string;
            /** @description Whether the entry only exposed encrypted content instead of plaintext. */
            encrypted?: boolean;
            /** @description Compact encrypted reasoning payload when the provider exposes it. */
            encryptedContent?: string;
        };
        StringMap: {
            [key: string]: string;
        };
        IntegerMap: {
            [key: string]: number;
        };
        /** @description Customer-facing identifier for one stored named factory. `GET /factory-sessions/~default/factory` may also return the reserved `UNDEFINED` identifier when the active runtime is still the default root factory and no durable current-factory pointer exists. Semantic validation failures return `INVALID_FACTORY_NAME`, including attempts to activate a named factory with the reserved identifier. */
        FactoryName: string;
        /** @description A customer-facing value with a required base fallback and optional exact locale overrides. Locale tags must use their canonical BCP 47 spelling. */
        NameValue: {
            /**
             * @description Discriminator for localized customer-facing metadata.
             * @enum {string}
             */
            type: NameValueType;
            /** @description Required base value returned when no exact locale override exists. */
            value: string;
            /** @description Canonical BCP 47 locales for which the base value was authored. */
            locales?: string[];
            /** @description Exact canonical BCP 47 locale tags mapped to localized overrides. */
            values?: {
                [key: string]: string;
            };
            /** @description Optional stable metadata identifier; consumers must not render it as display copy. */
            id?: string;
        };
        /** @description Additive dashboard read-model contract slice that publishes workstation-request projections keyed by dispatch ID without reintroducing removed `/dashboard` endpoints. */
        FactoryWorldWorkstationRequestProjectionSlice: {
            workstationRequestsByDispatchId?: {
                [key: string]: components["schemas"]["FactoryWorldWorkstationRequestView"];
            };
        };
        /** @description Additive dashboard read-model contract slice that publishes per-work move operations derived from canonical WORK_STATE_CHANGE events without reintroducing removed `/dashboard` endpoints. */
        FactoryWorldWorkMoveOperationProjectionSlice: {
            workMoveOperationsByWorkId?: {
                [key: string]: components["schemas"]["FactoryWorldWorkMoveOperationView"][];
            };
        };
        FactoryWorldWorkMoveOperationView: {
            workId: string;
            workTypeName?: string;
            fromState: string;
            toState: string;
            fromPlaceId: string;
            toPlaceId: string;
            source: components["schemas"]["WorkStateChangeSource"];
            requestId?: string;
            tick: number;
            sequence: number;
            /** Format: date-time */
            eventTime?: string;
        };
        FactoryWorldRenderedPromptDiagnostic: {
            systemPromptHash?: string;
            userMessageHash?: string;
            variables?: components["schemas"]["StringMap"];
        };
        FactoryWorldProviderDiagnostic: {
            provider?: string;
            model?: string;
            requestMetadata?: components["schemas"]["StringMap"];
            responseMetadata?: components["schemas"]["StringMap"];
        };
        FactoryWorldInvocationDiagnostic: {
            signatureHash?: string;
            parameters?: components["schemas"]["FactoryWorldInvocationParameterDiagnostic"][];
        };
        FactoryWorldInvocationParameterDiagnostic: {
            name?: string;
            sourceKinds?: string[];
            /** Format: int64 */
            valueCount?: number;
            redacted?: boolean;
        };
        FactoryWorldWorkDiagnostics: {
            renderedPrompt?: components["schemas"]["FactoryWorldRenderedPromptDiagnostic"];
            provider?: components["schemas"]["FactoryWorldProviderDiagnostic"];
            agentRun?: components["schemas"]["SafeAgentRunDiagnostic"];
            invocation?: components["schemas"]["FactoryWorldInvocationDiagnostic"];
        };
        FactoryWorldWorkItemRef: {
            workId: string;
            workTypeId?: string;
            state?: string;
            displayName?: string;
            chainingTraceDepth?: number;
            currentChainingTraceId?: string;
            previousChainingTraceIds?: string[];
            traceId?: string;
            content?: components["schemas"]["WorkContent"];
            /** @enum {string} */
            payloadStatus?: FactoryWorldWorkItemRefPayloadStatus;
            payloadUnavailableReason?: string;
            lineageLogicalWorkId?: string;
            /** @enum {string} */
            lineageSourceKind?: FactoryWorldWorkItemRefLineageSourceKind;
            /** @enum {string} */
            lineageContinuity?: FactoryWorldWorkItemRefLineageContinuity;
            lineageParentWorkIds?: string[];
        };
        FactoryWorldTokenView: {
            tokenId: string;
            placeId: string;
            name?: string;
            workId?: string;
            workTypeId?: string;
            chainingTraceDepth?: number;
            currentChainingTraceId?: string;
            previousChainingTraceIds?: string[];
            traceId?: string;
            tags?: components["schemas"]["StringMap"];
        };
        FactoryWorldMutationView: {
            type: string;
            tokenId: string;
            fromPlace?: string;
            toPlace?: string;
            reason?: string;
            token?: components["schemas"]["FactoryWorldTokenView"];
        };
        FactoryWorldScriptRequestView: {
            scriptRequestId?: string;
            attempt?: number;
            command?: string;
            args?: string[];
        };
        FactoryWorldScriptResponseView: {
            scriptRequestId?: string;
            attempt?: number;
            outcome?: string;
            stdout?: string;
            stderr?: string;
            /** Format: int64 */
            durationMillis?: number;
            exitCode?: number;
            failureType?: string;
        };
        /** @description Customer-visible agent-run inspection for one workstation dispatch response. */
        FactoryWorldAgentRunInspectionView: {
            /** @description Stable execution behavior marker for agent-loop runs. */
            executionBehavior?: string;
            /** @description Stable agent-run failure class when execution failed. */
            failureClass?: string;
            /** @description Customer-visible recovery guidance for actionable agent-run failures. */
            recoveryAction?: string;
            /** @description Effective agent tool policy for the run. */
            toolPolicy?: string;
            /**
             * Format: int32
             * @description Number of recorded tool lifecycle events for the run.
             */
            toolCallCount?: number;
            /** @description Bounded tool diagnostics separate from final agent output. */
            toolDiagnostics?: components["schemas"]["AgentRunToolDiagnosticEntry"][];
            /** @description Bounded transcript metadata separate from tool diagnostics and final output. */
            transcript?: components["schemas"]["AgentRunTranscriptEntry"][];
        };
        FactoryWorldSelectedRunnerView: {
            runnerId?: components["schemas"]["RunnerID"];
            displayName?: string;
            selectionSource?: components["schemas"]["RunnerSelectionSource"];
            capabilities?: components["schemas"]["FactoryWorldRunnerCapabilitiesView"];
        };
        /** @enum {string} */
        FactoryWorldRunnerBaselineCapability: FactoryWorldRunnerBaselineCapability;
        /** @enum {string} */
        FactoryWorldRunnerOptionalCapability: FactoryWorldRunnerOptionalCapability;
        /** @enum {string} */
        FactoryWorldRunnerOptionalCapabilityStatus: FactoryWorldRunnerOptionalCapabilityStatus;
        FactoryWorldRunnerOptionalCapabilitySupportView: {
            capability: components["schemas"]["FactoryWorldRunnerOptionalCapability"];
            status: components["schemas"]["FactoryWorldRunnerOptionalCapabilityStatus"];
            detail?: string;
        };
        FactoryWorldRunnerCapabilitiesView: {
            baselineCapabilities: components["schemas"]["FactoryWorldRunnerBaselineCapability"][];
            optionalCapabilities: components["schemas"]["FactoryWorldRunnerOptionalCapabilitySupportView"][];
        };
        FactoryWorldWorkstationRequestCountView: {
            dispatchedCount: number;
            respondedCount: number;
            erroredCount: number;
        };
        FactoryWorldWorkstationRequestRequestView: {
            runner?: components["schemas"]["FactoryWorldSelectedRunnerView"];
            /** Format: date-time */
            startedAt?: string;
            inputWorkItems?: components["schemas"]["FactoryWorldWorkItemRef"][];
            inputWorkTypeIds?: string[];
            currentChainingTraceId?: string;
            previousChainingTraceIds?: string[];
            traceIds?: string[];
            consumedTokens?: components["schemas"]["FactoryWorldTokenView"][];
            scriptRequest?: components["schemas"]["FactoryWorldScriptRequestView"];
        };
        FactoryWorldWorkstationRequestResponseView: {
            runner?: components["schemas"]["FactoryWorldSelectedRunnerView"];
            outcome?: string;
            feedback?: string;
            selectedClassificationLabel?: string;
            failureDetail?: components["schemas"]["FailureDetail"];
            scriptResponse?: components["schemas"]["FactoryWorldScriptResponseView"];
            agentRunInspection?: components["schemas"]["FactoryWorldAgentRunInspectionView"];
            /** Format: date-time */
            endTime?: string;
            /** Format: int64 */
            durationMillis?: number;
            outputWorkItems?: components["schemas"]["FactoryWorldWorkItemRef"][];
            outputMutations?: components["schemas"]["FactoryWorldMutationView"][];
        };
        FactoryWorldWorkstationRequestView: {
            dispatchId: string;
            transitionId: string;
            workstationName?: string;
            counts: components["schemas"]["FactoryWorldWorkstationRequestCountView"];
            request: components["schemas"]["FactoryWorldWorkstationRequestRequestView"];
            response?: components["schemas"]["FactoryWorldWorkstationRequestResponseView"];
        };
        /** @description Versioned Agent Factory event message. This is the intended canonical schema for customer event streams, history projection, record/replay artifacts, and runtime diagnostics. New fields use camelCase even when older REST resource schemas still contain legacy snake_case fields. */
        FactoryEvent: {
            /**
             * @description Version of the factory event envelope schema.
             * @enum {string}
             */
            schemaVersion: FactoryEventSchemaVersion;
            /** @description Stable event identifier. Record/replay artifacts must preserve this value. */
            id: string;
            type: components["schemas"]["FactoryEventType"];
            context: components["schemas"]["FactoryEventContext"];
            payload: components["schemas"]["RunRequestEventPayload"] | components["schemas"]["InitialStructureRequestEventPayload"] | components["schemas"]["FactoryChangeEventPayload"] | components["schemas"]["WorkRequestEventPayload"] | components["schemas"]["RelationshipChangeRequestEventPayload"] | components["schemas"]["DispatchRequestEventPayload"] | components["schemas"]["DispatchWorkerSessionAssociationEventPayload"] | components["schemas"]["ModelRequestEventPayload"] | components["schemas"]["ModelResponseEventPayload"] | components["schemas"]["InferenceRequestEventPayload"] | components["schemas"]["InferenceResponseEventPayload"] | components["schemas"]["ScriptRequestEventPayload"] | components["schemas"]["ScriptResponseEventPayload"] | components["schemas"]["AgentRunResponseEventPayload"] | components["schemas"]["DispatchResponseEventPayload"] | components["schemas"]["WorkStateChangeEventPayload"] | components["schemas"]["FactoryStateResponseEventPayload"] | components["schemas"]["RunResponseEventPayload"] | components["schemas"]["SessionStartedEventPayload"] | components["schemas"]["SessionPausedEventPayload"] | components["schemas"]["SessionResumedEventPayload"] | components["schemas"]["SessionResultUpdatedEventPayload"] | components["schemas"]["SessionCompletedEventPayload"] | components["schemas"]["SessionLifecycleControlEventPayload"] | components["schemas"]["OrchestratorPhaseChangedEventPayload"] | components["schemas"]["OrchestratorCheckpointWrittenEventPayload"] | components["schemas"]["DispatchQueuedEventPayload"] | components["schemas"]["DispatchInterruptedEventPayload"] | components["schemas"]["DispatchReconciledEventPayload"] | components["schemas"]["JavaScriptCheckpointRefEventPayload"] | components["schemas"]["JavaScriptPhaseChangeEventPayload"] | components["schemas"]["ArtifactCreatedEventPayload"];
        };
        /** @description Chapter-free recording of canonical Factory Events for exactly one Factory Session. Events remain in their recorded canonical order. */
        FactoryRecording: {
            /**
             * @description Version of the Factory Recording envelope schema.
             * @enum {string}
             */
            schemaVersion: FactoryRecordingSchemaVersion;
            /** @description Canonical identity of the Factory Session represented by every event. */
            sessionId: string;
            /** @description Canonical Factory Events in their original recorded order. */
            events: components["schemas"]["FactoryEvent"][];
        };
        /**
         * @description Canonical event vocabulary for customer-visible runtime changes. Work entering the factory is represented as WORK_REQUEST, including single-work submissions that are normalized into one-work requests.
         * @enum {string}
         */
        FactoryEventType: FactoryEventType;
        FactoryEventContext: {
            /** @description Append-only event-log sequence number. */
            sequence: number;
            /** @description Logical engine tick observed by the runtime. */
            tick: number;
            /**
             * Format: date-time
             * @description Wall-clock event timestamp for customer explanation and diagnostics. ISO8601 timestamp.
             */
            eventTime: string;
            /** @description Canonical factory session identity for session-scoped events; payloads must not restate it. */
            sessionId?: string;
            /** @description Monotonic per-session ordering used for replay deduplication within one session. */
            sessionSequence?: number;
            /** @description Canonical orchestrator kind for session-scoped events; payloads must not restate it. */
            orchestratorKind?: components["schemas"]["FactoryOrchestratorKind"];
            /** @description Optional JavaScript workflow dialect when orchestrator.kind = JAVASCRIPT. */
            orchestratorDialect?: string;
            /** @description Canonical workflow phase identifier; payloads must not restate it. */
            phaseId?: string;
            /** @description Canonical workflow phase name for customer-visible diagnostics. */
            phaseName?: string;
            /** @description Canonical checkpoint identifier for checkpoint-scoped events; payloads must not restate it. */
            checkpointId?: string;
            /** @description Canonical request identity for all request-scoped events; payload metadata must not restate it. */
            requestId?: string;
            /** @description Canonical trace identifiers that contributed to this event; payloads must not restate them. */
            traceIds?: string[];
            /** @description Canonical work identities correlated to this event; payloads must not restate them. */
            workIds?: string[];
            /** @description Canonical dispatch identity for dispatch and inference events; payloads must not restate it. */
            dispatchId?: string;
            /** @description Canonical chaining-trace identifier for the dispatch currently represented by this event context. */
            currentChainingTraceId?: string;
            /** @description Canonical predecessor chaining traces consumed by the dispatch in deterministic order. */
            previousChainingTraceIds?: string[];
            /** @description Human-readable source such as api, filewatcher, replay, cron, or worker. */
            source?: string;
        };
        /**
         * @description Origin of a WORK_STATE_CHANGE event.
         * @enum {string}
         */
        WorkStateChangeSource: WorkStateChangeSource;
        /** @description Ordered reference to one consumed work item on a dispatch boundary. Dispatch-request payloads keep only the consumed work identity here; work type, trace, display, and other work facts must be derived from prior WORK_REQUEST events plus FactoryEvent.context. */
        DispatchConsumedWorkRef: {
            /** @description Canonical work identity for one consumed dispatch input. */
            workId: string;
        };
        /** @description Optional non-identity dispatch metadata retained on dispatch-request events. Request, trace, work, and dispatch identity must remain on FactoryEvent.context rather than reappearing here. */
        DispatchRequestEventMetadata: {
            /** @description Stable replay correlation key for recorded dispatch reconstruction. */
            replayKey?: string;
            runnerId?: components["schemas"]["RunnerID"];
            runnerSelectionSource?: components["schemas"]["RunnerSelectionSource"];
        };
        RunRequestEventPayload: {
            /** Format: date-time */
            recordedAt: string;
            factory: components["schemas"]["Factory"];
            wallClock?: components["schemas"]["WallClock"];
            diagnostics?: components["schemas"]["Diagnostics"];
        };
        /** @description Runtime topology snapshot before work moves. */
        InitialStructureRequestEventPayload: {
            factory: components["schemas"]["Factory"];
            sourceDirectory?: string;
            metadata?: components["schemas"]["StringMap"];
        };
        /** @description Runtime topology snapshot after a live factory definition change replaces the running factory. */
        FactoryChangeEventPayload: {
            factory: components["schemas"]["Factory"];
            sourceDirectory?: string;
            metadata?: components["schemas"]["StringMap"];
        };
        /** @description Normalized work request entering the factory. Single-work submissions accepted by POST /work are converted into this one-work request shape before an event is emitted. */
        WorkRequestEventPayload: {
            type: components["schemas"]["WorkRequestType"];
            works?: components["schemas"]["Work"][];
            relations?: components["schemas"]["Relation"][];
            source?: string;
            parentLineage?: string[];
        };
        RelationshipChangeRequestEventPayload: {
            relation: components["schemas"]["Relation"];
        };
        /** @description Customer-visible dispatch start event. FactoryEvent.context owns dispatch, request, trace, and work identity. This payload keeps only non-derived dispatch facts first known when execution starts; workstation and worker topology must be reconstructed from the initial structure and the retained transition identifier. Ordered inputs carry consumed work references only; work type, trace, display, and other work facts must be rebuilt from prior work-request history. */
        DispatchRequestEventPayload: {
            transitionId: string;
            /**
             * @deprecated
             * @description Deprecated compatibility copy of the dispatch chaining-trace identifier; prefer FactoryEvent.context.currentChainingTraceId.
             */
            currentChainingTraceId?: string;
            /**
             * @deprecated
             * @description Deprecated compatibility copy of predecessor chaining traces; prefer FactoryEvent.context.previousChainingTraceIds.
             */
            previousChainingTraceIds?: string[];
            inputs: components["schemas"]["DispatchConsumedWorkRef"][];
            resources?: components["schemas"]["Resource"][];
            metadata?: components["schemas"]["DispatchRequestEventMetadata"];
        };
        /** @description Canonical association between one Factory dispatch and the Worker Session allocated to execute it. Dispatch identity remains authoritative in FactoryEvent.context.dispatchId and is not repeated in this payload. */
        DispatchWorkerSessionAssociationEventPayload: {
            /** @description Non-empty Worker Session identity allocated for the dispatch. */
            workerSessionId: string;
        };
        /** @description Request details captured immediately before a model-backed worker invocation enters resource, load, and execution boundaries. FactoryEvent.context owns dispatch, request, trace, and work identity, and the matching dispatch-request event owns the transition identifier. */
        ModelRequestEventPayload: {
            /** @description Stable identifier correlating this model execution request with its response. */
            modelRequestId: string;
            /** @description One-based model execution attempt number for this dispatch. */
            attempt: number;
            /** @description Uppercase model operation requested by the workstation, such as TTS. */
            operation: string;
            /** @description Runtime worker name selected for the invocation. */
            worker: string;
            /** @description Concrete model identity resolved for this invocation. */
            model: string;
            /** @description Worker-declared model locality, such as LOCAL or CLOUD. */
            providerLocality: string;
            /** @description Concrete resources attached to the model worker execution path. */
            resources?: components["schemas"]["ModelResourceSummary"][];
            /** @description Deterministically resolved operation-slot bindings used for invocation. */
            bindings?: components["schemas"]["ResolvedModelOperationBinding"][];
            /** @description Working directory resolved for the model execution when present. */
            workingDirectory?: string;
            /** @description Worktree path resolved for the model execution when present. */
            worktree?: string;
        };
        /** @description Response details captured after a model-backed worker invocation returns, including resource wait, local load, binding-resolution, output, and failure evidence correlated to the matching model request event. Large binary audio must remain represented through content references or bounded previews instead of unbounded inline payloads. */
        ModelResponseEventPayload: {
            /** @description Identifier from the matching model request event. */
            modelRequestId: string;
            /** @description One-based model execution attempt number for this dispatch. */
            attempt: number;
            /** @description Uppercase model operation requested by the workstation, such as TTS. */
            operation: string;
            /** @description Runtime worker name selected for the invocation. */
            worker: string;
            /** @description Concrete model identity resolved for this invocation. */
            model: string;
            /** @description Worker-declared model locality, such as LOCAL or CLOUD. */
            providerLocality: string;
            outcome: components["schemas"]["InferenceOutcome"];
            /**
             * Format: int64
             * @description End-to-end model invocation duration in milliseconds.
             */
            durationMillis: number;
            /** @description Concrete resources attached to the model worker execution path. */
            resources?: components["schemas"]["ModelResourceSummary"][];
            /** @description Deterministically resolved operation-slot bindings used for invocation. */
            bindings?: components["schemas"]["ResolvedModelOperationBinding"][];
            /**
             * Format: int64
             * @description Time spent waiting for local model resources before acquisition.
             */
            resourceWaitMillis?: number;
            /** @description Whether the invocation acquired the required local model resources. */
            resourceAcquired?: boolean;
            /** @description Whether this invocation asked the managed local-model runtime to load a handle. */
            loadRequested?: boolean;
            /** @description Whether an already-loaded local model handle was reused instead of loading again. */
            loadReused?: boolean;
            /**
             * Format: int64
             * @description Duration of the managed local-model load call when one occurred.
             */
            loadDurationMillis?: number;
            /** @description Bounded output preview for non-binary model responses when present. */
            outputPreview?: string;
            outputContent?: components["schemas"]["WorkContent"];
            diagnostics?: components["schemas"]["SafeWorkDiagnostics"];
            providerSession?: components["schemas"]["ProviderSessionMetadata"];
            failureDetail?: components["schemas"]["FailureDetail"];
        };
        /** @description Request details captured immediately before a model-worker provider attempt is invoked. FactoryEvent.context owns dispatch, request, trace, and work identity, and the matching dispatch-request event owns the transition identifier. Prompt content is intentionally present and should be treated as sensitive in recordings and diagnostics. */
        InferenceRequestEventPayload: {
            /** @description Stable identifier correlating this provider request with its response. */
            inferenceRequestId: string;
            /** @description One-based provider attempt number for this dispatch. */
            attempt: number;
            /** @description Working directory resolved for the provider attempt. */
            workingDirectory: string;
            /** @description Worktree path resolved for the provider attempt. */
            worktree: string;
            /** @description Rendered prompt sent to the provider. */
            prompt: string;
        };
        /** @description Response details captured after a model-worker provider attempt returns, including success and failure outcomes correlated to the request event. FactoryEvent.context owns dispatch identity, and the matching dispatch request owns the transition identifier for this provider attempt. Safe provider diagnostics and provider-session identifiers stay on this provider-boundary event instead of being copied onto DispatchResponse. */
        InferenceResponseEventPayload: {
            /** @description Identifier from the matching inference request event. */
            inferenceRequestId: string;
            /** @description One-based provider attempt number for this dispatch. */
            attempt: number;
            outcome: components["schemas"]["InferenceOutcome"];
            /** @description Provider response text when present. */
            response?: string;
            /**
             * Format: int64
             * @description Provider call duration in milliseconds.
             */
            durationMillis: number;
            providerSession?: components["schemas"]["ProviderSessionMetadata"];
            diagnostics?: components["schemas"]["SafeWorkDiagnostics"];
            /** @description Process exit code when the provider failure exposes one. */
            exitCode?: number;
            failureDetail?: components["schemas"]["FailureDetail"];
        };
        /** @description Request details captured immediately before a script-backed worker invokes a concrete command. Raw environment values and raw stdin content are intentionally excluded from the public script event contract. */
        ScriptRequestEventPayload: {
            /** @description Stable identifier correlating this script request with its response. */
            scriptRequestId: string;
            dispatchId: string;
            transitionId: string;
            /** @description One-based script attempt number for this dispatch. */
            attempt: number;
            /** @description Concrete command name executed for this script attempt. */
            command: string;
            /** @description Fully resolved command arguments passed to the script command runner. */
            args: string[];
        };
        /** @description Response details captured after a script-backed worker command returns or fails before a normal exit code. Raw environment values and raw stdin content are intentionally excluded from the public script event contract. */
        ScriptResponseEventPayload: {
            /** @description Identifier from the matching script request event. */
            scriptRequestId: string;
            dispatchId: string;
            transitionId: string;
            /** @description One-based script attempt number for this dispatch. */
            attempt: number;
            outcome: components["schemas"]["ScriptExecutionOutcome"];
            /** @description Captured stdout text from the script execution boundary. */
            stdout: string;
            /** @description Captured stderr text from the script execution boundary. */
            stderr: string;
            /**
             * Format: int64
             * @description Script execution duration in milliseconds.
             */
            durationMillis: number;
            /** @description Process exit code when the command returned one. */
            exitCode?: number;
            failureType?: components["schemas"]["ScriptFailureType"];
        };
        /** @description Response details captured after an AGENT_RUN workstation completes an agent loop. Final output stays on DispatchResponse; bounded agent-run diagnostics and transcript metadata stay on this agent-boundary event instead of being copied onto provider-session inspection surfaces. */
        AgentRunResponseEventPayload: {
            /** @description Stable identifier for this agent-run boundary event. */
            agentRunId: string;
            outcome: components["schemas"]["WorkOutcome"];
            /**
             * Format: int64
             * @description Agent-loop execution duration in milliseconds.
             */
            durationMillis: number;
            diagnostics?: components["schemas"]["SafeWorkDiagnostics"];
        };
        /** @description Customer-visible dispatch completion event. Output work is represented with the same Work schema used by request submission rather than token or marking-mutation internals. FactoryEvent.context owns dispatch, trace, and work identity; workstation and worker topology must be derived from the matching dispatch-request event plus the initial structure. Provider-attempt session and safe diagnostic facts stay on inference response events instead of being copied onto dispatch completion payloads. */
        DispatchResponseEventPayload: {
            completionId?: string;
            transitionId: string;
            /**
             * @deprecated
             * @description Deprecated compatibility copy of the dispatch chaining-trace identifier; prefer FactoryEvent.context.currentChainingTraceId.
             */
            currentChainingTraceId?: string;
            /**
             * @deprecated
             * @description Deprecated compatibility copy of predecessor chaining traces; prefer FactoryEvent.context.previousChainingTraceIds.
             */
            previousChainingTraceIds?: string[];
            outcome: components["schemas"]["WorkOutcome"];
            output?: string;
            error?: string;
            feedback?: string;
            selectedClassificationLabel?: string;
            failureDetail?: components["schemas"]["FailureDetail"];
            providerFailure?: components["schemas"]["ProviderFailureMetadata"];
            metrics?: components["schemas"]["WorkMetrics"];
            /** Format: int64 */
            durationMillis?: number;
            outputWork?: components["schemas"]["Work"][];
            outputResources?: components["schemas"]["Resource"][];
            metadata?: components["schemas"]["StringMap"];
        };
        /** @description Canonical Petri marking position change for work items in Petri-backed factories. JavaScript workflow progress is represented by JAVASCRIPT_PHASE_CHANGE events instead of WORK_STATE_CHANGE. Operator moves use source api or cli; automatic cascade propagation uses cascading-failure. FactoryEvent.context carries workIds and optional requestId for operator idempotency. */
        WorkStateChangeEventPayload: {
            workId: string;
            workTypeName: string;
            /** @description Authored state name before the move. */
            fromState: string;
            /** @description Authored state name after the move. */
            toState: string;
            /** @description Marking place identifier before the move. */
            fromPlaceId: string;
            /** @description Marking place identifier after the move. */
            toPlaceId: string;
            source: components["schemas"]["WorkStateChangeSource"];
            /** @description Optional work identifier that triggered a cascade move. */
            triggerWorkId?: string;
            /** @description Optional human-readable reason for the move. */
            reason?: string;
        };
        FactoryStateResponseEventPayload: {
            previousState?: components["schemas"]["FactoryState"];
            state: components["schemas"]["FactoryState"];
            reason?: string;
        };
        RunResponseEventPayload: {
            state?: components["schemas"]["FactoryState"];
            reason?: string;
            wallClock?: components["schemas"]["WallClock"];
            diagnostics?: components["schemas"]["Diagnostics"];
        };
        /**
         * @description Result category returned by a provider inference attempt.
         * @enum {string}
         */
        InferenceOutcome: InferenceOutcome;
        /**
         * @description Result category returned by one public script execution boundary.
         * @enum {string}
         */
        ScriptExecutionOutcome: ScriptExecutionOutcome;
        /**
         * @description Stable failure classification for script responses without a normal process exit code.
         * @enum {string}
         */
        ScriptFailureType: ScriptFailureType;
        /**
         * @description Lifecycle state of the running factory.
         * @enum {string}
         */
        FactoryState: FactoryState;
        /**
         * @description Result category returned by a workstation execution.
         * @enum {string}
         */
        WorkOutcome: WorkOutcome;
        /**
         * @description Stable machine-readable failure family used to decide retry and routing behavior for failed work.
         * @enum {string}
         */
        WorkFailureFamily: WorkFailureFamily;
        /**
         * @description Stable machine-readable failure type used to classify failed work across providers and runtimes.
         * @enum {string}
         */
        WorkFailureType: WorkFailureType;
        ProviderFailureMetadata: {
            family?: components["schemas"]["WorkFailureFamily"];
            type?: components["schemas"]["WorkFailureType"];
        };
        ProviderSessionMetadata: {
            provider?: string;
            kind?: string;
            id?: string;
        };
        WorkMetrics: {
            /** Format: int64 */
            durationMillis?: number;
            /** Format: double */
            cost?: number;
            retryCount?: number;
        };
        WorkDiagnostics: {
            renderedPrompt?: components["schemas"]["RenderedPromptDiagnostic"];
            provider?: components["schemas"]["ProviderDiagnostic"];
            invocation?: components["schemas"]["InvocationDiagnostic"];
            command?: components["schemas"]["CommandDiagnostic"];
            panic?: components["schemas"]["PanicDiagnostic"];
            metadata?: components["schemas"]["StringMap"];
        };
        RenderedPromptDiagnostic: {
            systemPromptHash?: string;
            userMessageHash?: string;
            variables?: components["schemas"]["StringMap"];
        };
        ProviderDiagnostic: {
            provider?: string;
            model?: string;
            requestMetadata?: components["schemas"]["StringMap"];
            responseMetadata?: components["schemas"]["StringMap"];
        };
        InvocationDiagnostic: {
            signatureHash?: string;
            parameters?: components["schemas"]["InvocationParameterDiagnostic"][];
        };
        InvocationParameterDiagnostic: {
            name?: string;
            sourceKinds?: string[];
            /** Format: int64 */
            valueCount?: number;
            redacted?: boolean;
        };
        CommandDiagnostic: {
            command?: string;
            args?: string[];
            stdin?: string;
            env?: components["schemas"]["StringMap"];
            stdout?: string;
            stderr?: string;
            exitCode?: number;
            timedOut?: boolean;
            /** Format: int64 */
            durationNanos?: number;
            workingDir?: string;
        };
        PanicDiagnostic: {
            message?: string;
            stack?: string;
        };
        Diagnostics: {
            notes?: string[];
            workers?: {
                [key: string]: components["schemas"]["SafeWorkDiagnostics"];
            };
        };
        /** @description Dashboard-facing execution diagnostics that omit raw prompts, command stdin, and command environment values. */
        SafeWorkDiagnostics: {
            renderedPrompt?: components["schemas"]["RenderedPromptDiagnostic"];
            provider?: components["schemas"]["ProviderDiagnostic"];
            agentRun?: components["schemas"]["SafeAgentRunDiagnostic"];
            invocation?: components["schemas"]["InvocationDiagnostic"];
        };
        /** @description Dashboard-safe agent-run inspection metadata distinct from provider-session transcript ownership. */
        SafeAgentRunDiagnostic: {
            /**
             * @description Stable execution behavior marker for agent-loop runs.
             * @enum {string}
             */
            executionBehavior?: SafeAgentRunDiagnosticExecutionBehavior;
            /** @description Stable agent-run failure class when execution failed. */
            failureClass?: string;
            /** @description Customer-visible recovery guidance for actionable agent-run failures. */
            recoveryAction?: string;
            /** @description Effective agent tool policy for the run. */
            toolPolicy?: string;
            /**
             * Format: int32
             * @description Number of recorded tool lifecycle events for the run.
             */
            toolCallCount?: number;
            /** @description Bounded tool diagnostics separate from final agent output. */
            toolDiagnostics?: components["schemas"]["AgentRunToolDiagnosticEntry"][];
            /** @description Bounded transcript metadata separate from tool diagnostics and final output. */
            transcript?: components["schemas"]["AgentRunTranscriptEntry"][];
        };
        /** @description Bounded summary for one agent tool lifecycle event. */
        AgentRunToolDiagnosticEntry: {
            /** @description Tool name invoked by the agent loop. */
            toolName?: string;
            /** @description Tool lifecycle phase such as start, success, failure, or denied. */
            phase?: string;
            /** @description Safe diagnostic detail without raw process output or secrets. */
            detail?: string;
        };
        /** @description Bounded transcript metadata for one agent-loop message without exposing full prompt bodies. */
        AgentRunTranscriptEntry: {
            /** @description Message role such as system, user, assistant, or tool. */
            role?: string;
            /** @description Bounded summary of the message content for inspection. */
            summary?: string;
        };
        WallClock: {
            /** Format: date-time */
            startedAt?: string;
            /** Format: date-time */
            finishedAt?: string;
        };
        /** @description Provider-neutral envelope for transient agent activity observed during one Factory Session run. Unlike canonical factory events, these records are ephemeral observation records and must not derive canonical work state after replay. */
        FactoryResponseEvent: {
            /**
             * @description Version of the FactoryResponseEvent envelope schema.
             * @enum {string}
             */
            schemaVersion: FactoryResponseEventSchemaVersion;
            /** @description Stable identifier for this response event within the session stream. */
            eventId: string;
            /**
             * Format: int64
             * @description Monotonic session-scoped cursor for published events. Sequence zero is reserved for synthetic out-of-band read markers such as retention gaps; those markers do not consume or reuse a published sequence.
             */
            sequence: number;
            /**
             * Format: date-time
             * @description Wall-clock timestamp when the response event was recorded.
             */
            recordedAt: string;
            /** @description Factory Session identity that owns this response-event stream. */
            factorySessionId: string;
            /** @description Run identity within the Factory Session that produced this event. */
            runId: string;
            kind: components["schemas"]["FactoryResponseEventKind"];
            phase: components["schemas"]["FactoryResponseEventPhase"];
            provenance: components["schemas"]["FactoryResponseEventProvenance"];
            payload: components["schemas"]["FactoryResponseEventPayload"];
            /** @description Optional dispatch correlation identifier. */
            dispatchId?: string;
            /** @description Optional turn correlation identifier. */
            turnId?: string;
            /** @description Optional stable item correlation identifier. */
            itemId?: string;
            /** @description Optional parent item correlation identifier. */
            parentItemId?: string;
            /** @description Optional provider session reference for diagnostics. */
            providerSessionRef?: string;
        };
        /**
         * @description Semantic category of one FactoryResponseEvent. Response events are ephemeral observation records and must not derive canonical factory replay state.
         * @enum {string}
         */
        FactoryResponseEventKind: FactoryResponseEventKind;
        /**
         * @description Lifecycle position of one FactoryResponseEvent within its kind. Allowed phase/kind combinations are validated before publication.
         * @enum {string}
         */
        FactoryResponseEventPhase: FactoryResponseEventPhase;
        /** @description Provider-neutral fidelity metadata for one response event. Exposes diagnostic identity without promoting provider-native schemas into the public vocabulary. */
        FactoryResponseEventProvenance: {
            /** @description Provider identifier for the originating adapter session. */
            provider: string;
            /** @description Provider-native event type label retained for diagnostics only. */
            nativeEventType: string;
            /** @description Optional provider-native event subtype label retained for diagnostics only. */
            nativeEventSubtype?: string;
            delivery: components["schemas"]["FactoryResponseEventProvenanceDelivery"];
            representation: components["schemas"]["FactoryResponseEventProvenanceRepresentation"];
            fidelity: components["schemas"]["FactoryResponseEventProvenanceFidelity"];
        };
        /**
         * @description How the response event entered the Factory vocabulary.
         * @enum {string}
         */
        FactoryResponseEventProvenanceDelivery: FactoryResponseEventProvenanceDelivery;
        /**
         * @description Shape fidelity model used for the public payload.
         * @enum {string}
         */
        FactoryResponseEventProvenanceRepresentation: FactoryResponseEventProvenanceRepresentation;
        /**
         * @description How closely the public payload preserves provider detail.
         * @enum {string}
         */
        FactoryResponseEventProvenanceFidelity: FactoryResponseEventProvenanceFidelity;
        /** @description Declares which response-event features a provider session supports. Adapters publish capability flags so consumers can interpret fidelity and phase availability without depending on provider-native schemas. */
        FactoryResponseEventCapabilities: {
            /** @description Provider session exposes native streaming observation. */
            nativeStreaming: boolean;
            /** @description Provider session can emit incremental message deltas. */
            messageDeltas: boolean;
            /** @description Provider session can emit message snapshots. */
            messageSnapshots: boolean;
            /** @description Provider session can emit reasoning summaries or deltas. */
            reasoningSummaries: boolean;
            /** @description Provider session can emit tool lifecycle metadata. */
            toolLifecycle: boolean;
            /** @description Provider session can emit incremental tool output deltas. */
            toolOutputDeltas: boolean;
            /** @description Provider session can emit observed file changes. */
            fileChanges: boolean;
            /** @description Provider session can emit plan updates. */
            plans: boolean;
            /** @description Provider session can emit usage accounting. */
            usage: boolean;
            /** @description Provider session assigns stable item identifiers across events. */
            stableItemIds: boolean;
            /** @description Provider session supports reconnect after stream interruption. */
            providerReconnect: boolean;
        };
        /** @description Public typed payload union for FactoryResponseEvent. Variants align with envelope kind and phase semantics from the Story 01 vocabulary. MESSAGE and TOOL kinds use distinct snapshot and delta payload shapes; consumers select the variant using envelope kind and phase together with structural decoding. */
        FactoryResponseEventPayload: components["schemas"]["FactoryResponseEventSessionPayload"] | components["schemas"]["FactoryResponseEventRunPayload"] | components["schemas"]["FactoryResponseEventTurnPayload"] | components["schemas"]["FactoryResponseEventMessagePayload"] | components["schemas"]["FactoryResponseEventMessageDeltaPayload"] | components["schemas"]["FactoryResponseEventReasoningPayload"] | components["schemas"]["FactoryResponseEventToolPayload"] | components["schemas"]["FactoryResponseEventToolDeltaPayload"] | components["schemas"]["FactoryResponseEventFileChangePayload"] | components["schemas"]["FactoryResponseEventPlanPayload"] | components["schemas"]["FactoryResponseEventProgressPayload"] | components["schemas"]["FactoryResponseEventUsagePayload"] | components["schemas"]["FactoryResponseEventErrorPayload"] | components["schemas"]["FactoryResponseEventStreamGapPayload"];
        /** @description One typed slice of assistant-visible message content. Discriminated by the content block kind field. */
        FactoryResponseEventContentBlock: components["schemas"]["FactoryResponseEventTextContentBlock"] | components["schemas"]["FactoryResponseEventReasoningSummaryContentBlock"] | components["schemas"]["FactoryResponseEventToolRequestContentBlock"] | components["schemas"]["FactoryResponseEventImageRefContentBlock"] | components["schemas"]["FactoryResponseEventResourceRefContentBlock"] | components["schemas"]["FactoryResponseEventStructuredOutputContentBlock"];
        /**
         * @description Identifies one provider-neutral message content block kind.
         * @enum {string}
         */
        FactoryResponseEventContentBlockKind: FactoryResponseEventContentBlockKind;
        /** @description Inline text content block. */
        FactoryResponseEventTextContentBlock: {
            /**
             * @description discriminator enum property added by openapi-typescript
             * @enum {string}
             */
            kind: FactoryResponseEventTextContentBlockKind;
            /** @description Inline text content. */
            text: string;
        };
        /** @description Reasoning summary text content block. */
        FactoryResponseEventReasoningSummaryContentBlock: {
            /**
             * @description discriminator enum property added by openapi-typescript
             * @enum {string}
             */
            kind: FactoryResponseEventReasoningSummaryContentBlockKind;
            /** @description Reasoning summary text. */
            text: string;
        };
        /** @description Tool invocation request content block with bounded argument summary. */
        FactoryResponseEventToolRequestContentBlock: {
            /**
             * @description discriminator enum property added by openapi-typescript
             * @enum {string}
             */
            kind: FactoryResponseEventToolRequestContentBlockKind;
            /** @description Stable tool call identifier within the message. */
            toolCallId: string;
            /** @description Declared tool name for the invocation request. */
            toolName: string;
            /** @description Bounded summary of tool arguments. Not a raw provider protocol payload. */
            argumentsSummary?: {
                [key: string]: unknown;
            };
        };
        /** @description Image reference content block. */
        FactoryResponseEventImageRefContentBlock: {
            /**
             * @description discriminator enum property added by openapi-typescript
             * @enum {string}
             */
            kind: FactoryResponseEventImageRefContentBlockKind;
            /** @description Reference to an image artifact or URL. */
            imageRef: string;
        };
        /** @description Factory resource reference content block. */
        FactoryResponseEventResourceRefContentBlock: {
            /**
             * @description discriminator enum property added by openapi-typescript
             * @enum {string}
             */
            kind: FactoryResponseEventResourceRefContentBlockKind;
            /** @description Reference to a factory resource or artifact. */
            resourceRef: string;
        };
        /** @description Structured JSON output content block. */
        FactoryResponseEventStructuredOutputContentBlock: {
            /**
             * @description discriminator enum property added by openapi-typescript
             * @enum {string}
             */
            kind: FactoryResponseEventStructuredOutputContentBlockKind;
            /** @description Structured JSON output value. */
            structuredOutput: {
                [key: string]: unknown;
            };
        };
        /** @description Session-scoped lifecycle and capability metadata payload. */
        FactoryResponseEventSessionPayload: {
            /** @description Session lifecycle status when applicable. */
            status?: string;
            capabilities?: components["schemas"]["FactoryResponseEventCapabilities"];
        };
        /** @description Run-scoped lifecycle metadata payload. */
        FactoryResponseEventRunPayload: {
            /** @description Run lifecycle status when applicable. */
            status?: string;
        };
        /** @description Turn-scoped lifecycle metadata payload. */
        FactoryResponseEventTurnPayload: {
            /**
             * Format: int32
             * @description Zero-based turn index within the run when applicable.
             */
            turnIndex?: number;
            /** @description Turn lifecycle status when applicable. */
            status?: string;
        };
        /** @description Message snapshot payload with typed content blocks. */
        FactoryResponseEventMessagePayload: {
            /** @description Message role such as assistant or user. */
            role: string;
            /** @description Ordered typed content blocks for the message snapshot. */
            contentBlocks: components["schemas"]["FactoryResponseEventContentBlock"][];
            /** @description When true, the snapshot carries bounded timeout or cancellation capture and must not be treated as an authoritative final response. */
            partial?: boolean;
        };
        /** @description Incremental message content delta for one content block. */
        FactoryResponseEventMessageDeltaPayload: {
            /**
             * Format: int32
             * @description Zero-based index of the content block receiving the delta.
             */
            contentBlockIndex: number;
            contentBlockKind: components["schemas"]["FactoryResponseEventContentBlockKind"];
            /** @description Incremental text appended to the targeted content block. */
            textDelta?: string;
        };
        /** @description Reasoning summary snapshot or delta payload. */
        FactoryResponseEventReasoningPayload: {
            /** @description Full reasoning summary text when emitting a snapshot. */
            summary?: string;
            /** @description Incremental reasoning summary text when emitting a delta. */
            summaryDelta?: string;
        };
        /** @description Tool lifecycle metadata with bounded argument and result summaries. */
        FactoryResponseEventToolPayload: {
            /** @description Stable tool call identifier within the run. */
            toolCallId: string;
            /** @description Declared tool name for the invocation. */
            toolName: string;
            /** @description Tool lifecycle status when applicable. */
            status?: string;
            /** @description Bounded summary of tool arguments. Not a raw provider protocol payload. */
            argumentsSummary?: {
                [key: string]: unknown;
            };
            /** @description Bounded summary of tool results. Not a raw provider protocol payload. */
            resultSummary?: {
                [key: string]: unknown;
            };
        };
        /** @description Incremental tool output delta payload. */
        FactoryResponseEventToolDeltaPayload: {
            /** @description Stable tool call identifier receiving output. */
            toolCallId: string;
            /** @description Incremental tool output text. */
            outputDelta: string;
        };
        /** @description Observed file mutation payload. */
        FactoryResponseEventFileChangePayload: {
            /** @description Observed file path relative to the workspace or artifact root. */
            path: string;
            /** @description Observed file operation such as create, update, or delete. */
            operation: string;
            /** @description Optional human-readable summary of the mutation. */
            summary?: string;
        };
        /** @description Published plan update payload. */
        FactoryResponseEventPlanPayload: {
            /** @description Ordered plan steps when emitting a plan snapshot. */
            steps?: components["schemas"]["FactoryResponseEventPlanStep"][];
            /** @description Optional plan summary text. */
            summary?: string;
        };
        /** @description One step in a published plan snapshot. */
        FactoryResponseEventPlanStep: {
            /** @description Stable plan step identifier. */
            id: string;
            /** @description Human-readable step description. */
            description: string;
            /** @description Plan step status when applicable. */
            status?: string;
        };
        /** @description Coarse progress notification payload. */
        FactoryResponseEventProgressPayload: {
            /** @description Short progress label for UI or CLI consumers. */
            label: string;
            /** @description Optional longer progress message. */
            message?: string;
            /**
             * Format: double
             * @description Optional completion percentage when known.
             */
            percentComplete?: number;
        };
        /** @description Token or model usage accounting payload. */
        FactoryResponseEventUsagePayload: {
            /**
             * Format: int64
             * @description Reported input token count when available.
             */
            inputTokens?: number;
            /**
             * Format: int64
             * @description Reported output token count when available.
             */
            outputTokens?: number;
            /**
             * Format: int64
             * @description Reported total token count when available.
             */
            totalTokens?: number;
            /** @description Model identifier associated with the usage report. */
            model?: string;
        };
        /** @description Provider-neutral error payload with optional retry metadata. */
        FactoryResponseEventErrorPayload: {
            /** @description Stable provider-neutral error code. */
            code: string;
            /** @description Human-readable error message. */
            message: string;
            /** @description Whether the error may be retried. */
            retryable?: boolean;
            /**
             * Format: int64
             * @description Suggested retry delay in seconds when retryable.
             */
            retryAfterSeconds?: number;
            /**
             * Format: int32
             * @description Retry attempt count when applicable.
             */
            retryAttempt?: number;
        };
        /** @description Discontinuity marker for either unavailable retained response-event sequences or an affected provider item whose lifecycle could not be fully observed. Retention gaps include fromSequence, toSequence, and firstAvailableSequence; item-scoped gaps include affectedItemId and reason. The alternatives are exclusive so empty, partial, and mixed payloads are rejected. */
        FactoryResponseEventStreamGapPayload: {
            /**
             * Format: int64
             * @description Lowest unavailable published sequence greater than the reader's cursor.
             */
            fromSequence: number;
            /**
             * Format: int64
             * @description Highest unavailable published sequence in the reader's catch-up window.
             */
            toSequence: number;
            /**
             * Format: int64
             * @description First retained sequence available after the gap.
             */
            firstAvailableSequence: number;
            /** @description Retention-gap reason such as retention_window. */
            reason?: string;
        } | {
            /** @description Stable item identifier affected by a provider lifecycle discontinuity. */
            affectedItemId: string;
            /** @description Provider tool-call identifier when the affected item is a tool lifecycle. */
            toolCallId?: string;
            /** @description Provider gap reason such as provider_reconnect or provider_terminated. */
            reason: string;
        };
        /**
         * @description Explicit save mode for session-scoped factory submission. Omitted mode on PUT /factory-sessions/{session_id}/factory defaults to REPLACE_CURRENT.
         * @default REPLACE_CURRENT
         * @enum {string}
         */
        FactorySaveMode: FactorySaveMode;
        /**
         * @description Session-scoped factory submission payload for PUT /factory-sessions/{session_id}/factory.
         * @example {
         *       "mode": "REPLACE_CURRENT",
         *       "factory": {
         *         "name": "alpha",
         *         "version": {
         *           "logical": "2",
         *           "physical": "2026-05-30T12:00:00.000000000Z"
         *         },
         *         "workTypes": [
         *           {
         *             "name": "task",
         *             "states": [
         *               {
         *                 "name": "init",
         *                 "type": "INITIAL"
         *               },
         *               {
         *                 "name": "done",
         *                 "type": "TERMINAL"
         *               }
         *             ]
         *           }
         *         ],
         *         "workers": [
         *           {
         *             "name": "planner",
         *             "type": "MODEL_WORKER",
         *             "modelProvider": "CLAUDE",
         *             "executorProvider": "SCRIPT_WRAP",
         *             "model": "claude-sonnet-4-20250514"
         *           }
         *         ],
         *         "workstations": [
         *           {
         *             "name": "plan-task",
         *             "behavior": "STANDARD",
         *             "type": "MODEL_WORKSTATION",
         *             "worker": "planner",
         *             "inputs": [
         *               {
         *                 "workType": "task",
         *                 "state": "init"
         *               }
         *             ],
         *             "outputs": [
         *               {
         *                 "workType": "task",
         *                 "state": "done"
         *               }
         *             ]
         *           }
         *         ]
         *       }
         *     }
         */
        SaveFactoryForSessionRequest: {
            /** @default REPLACE_CURRENT */
            mode: components["schemas"]["FactorySaveMode"];
            factory: components["schemas"]["Factory"];
        };
        /** @description Top-level factory.json contract. Declare the work types, resources, portability resources, workers, and workstations that make up one authored factory here. Guarded loop breakers should be authored as guarded LOGICAL_MOVE workstations using VISIT_COUNT guards instead of a top-level exhaustion-rules field. */
        Factory: {
            name: components["schemas"]["FactoryName"];
            /** @description Optional localized customer-facing explanation of this Factory. */
            description?: components["schemas"]["NameValue"];
            /** @description Factory identifier used as the factory-level template context fallback. */
            id?: string;
            /** @description Default runner selection for the factory when a workstation does not declare its own runner override. */
            runner?: components["schemas"]["RunnerID"];
            /** @description Directory that contained the factory.json used for this serialized runtime config. */
            factoryDirectory?: string;
            /** @description Original source directory for record/replay and drift diagnostics. */
            sourceDirectory?: string;
            /** @description Server-managed current-factory version metadata. Clients should echo this value on complete replacement saves when they want stale-write detection, but durable factory configuration does not treat it as customer-authored topology. */
            version?: components["schemas"]["HybridLogicalTimestamp"];
            /** @description Free-form factory-level metadata carried through runtime serialization and replay diagnostics. */
            metadata?: components["schemas"]["StringMap"];
            /** @description Authored orchestrator identity for this factory. When omitted, existing Petri factories load through compatibility defaulting to orchestrator.kind = PETRI. */
            orchestrator?: components["schemas"]["FactoryOrchestrator"];
            /** @description Named input kinds accepted by the factory. The default input type is implicit and must not be declared. */
            inputTypes?: components["schemas"]["InputType"][];
            /** @description Optional factory-authored invocation primary-result policy shared by CLI and API entrypoints. When omitted, runtimes use the SUBMITTED_WORK_TERMINAL fallback and return the first terminal content for the work item originally submitted by the invocation. */
            invocationReturn?: components["schemas"]["InvocationReturn"];
            /** @description Optional canonical callable argument contract shared by CLI, API, dashboard, docs, and packaged factories. When omitted, callers use the factory's compatibility invocation behavior. */
            invocationSignature?: components["schemas"]["FactoryInvocationSignature"];
            /** @description Ordered runnable invocation examples. Canonical Factory documents write examples here; legacy invocationSignature.examples are accepted only by the Factory input compatibility mapper. */
            examples?: components["schemas"]["FactoryInvocationExample"][];
            /** @description Root-level guards that apply across the factory instead of one specific workstation or input. */
            guards?: components["schemas"]["FactoryGuard"][];
            /** @description Customer-authored work item categories and the lifecycle states each one can occupy. */
            workTypes?: components["schemas"]["WorkType"][];
            /** @description Shared capacity pools that workers or workstations can consume while work is executing. */
            resources?: components["schemas"]["Resource"][];
            /** @description Optional portability manifest for validation-only external tools and portable bundled files. During v1 factory sharing, bundled INPUT files represent a share-time snapshot of the source factory's current inputs work so recipients restore detached starter-work copies that no longer sync back to the original factory. This contract is distinct from runtime-capacity resources. */
            supportingFiles?: components["schemas"]["ResourceManifest"];
            /** @description Optional non-executable graph editor layout metadata keyed by canonical graph node and edge ids. */
            layout?: components["schemas"]["FactoryLayout"];
            /** @description Reusable worker definitions that workstations reference by name when dispatching work. */
            workers?: components["schemas"]["Worker"][];
            /** @description Processing steps that consume work, invoke workers, and emit the next work states. */
            workstations?: components["schemas"]["Workstation"][];
        };
        /** @description Authored orchestrator identity for one factory. When omitted, existing Petri factories load through compatibility defaulting to orchestrator.kind = PETRI. */
        FactoryOrchestrator: {
            kind: components["schemas"]["FactoryOrchestratorKind"];
            /** @description Petri-specific orchestrator configuration. Required only when kind = PETRI and additional Petri options are authored. */
            petri?: components["schemas"]["FactoryOrchestratorPetriConfig"];
            /** @description JavaScript-specific orchestrator configuration. Required when kind = JAVASCRIPT. */
            javascript?: components["schemas"]["FactoryOrchestratorJavaScriptConfig"];
        };
        /**
         * @description Authored orchestration engine for one factory. PETRI factories use the existing Petri graph semantics. JAVASCRIPT factories use workflow source identity and policy instead of Petri graph fields.
         * @enum {string}
         */
        FactoryOrchestratorKind: FactoryOrchestratorKind;
        /** @description Petri-specific orchestrator configuration. Existing Petri factories may omit this block and rely on compatibility defaulting to orchestrator.kind = PETRI. */
        FactoryOrchestratorPetriConfig: Record<string, never>;
        /** @description JavaScript-specific orchestrator configuration. JavaScript factories do not require Petri graph fields and instead declare workflow source identity, metadata, args schema, and default policy here. */
        FactoryOrchestratorJavaScriptConfig: {
            /** @description Optional JavaScript dialect label for the authored workflow source. */
            dialect?: string;
            /** @description Factory-relative or authored reference to the workflow source file. */
            sourceRef?: string;
            /** @description Inline workflow source when the factory carries source text directly. */
            inlineSource?: components["schemas"]["FactoryOrchestratorJavaScriptInlineSource"];
            /** @description Optional content hash for the resolved workflow source. */
            sourceHash?: string;
            /** @description Optional exported entrypoint or phase name used to start the workflow. */
            entrypoint?: string;
            /** @description Free-form JavaScript orchestrator metadata for authoring and diagnostics. */
            metadata?: components["schemas"]["StringMap"];
            /** @description JSON Schema object describing workflow invocation arguments. */
            argsSchema?: {
                [key: string]: unknown;
            };
            /** @description Default JavaScript workflow policy object applied when no runtime override exists. */
            defaultPolicy?: {
                [key: string]: unknown;
            };
            /** @description Named child-agent roles and their operator worker preset defaults. */
            agents?: {
                [key: string]: components["schemas"]["FactoryOrchestratorJavaScriptAgent"];
            };
        };
        /** @description Inline JavaScript workflow source carried directly in the factory definition. */
        FactoryOrchestratorJavaScriptInlineSource: {
            /**
             * @description Declared content encoding for the inline workflow source.
             * @enum {string}
             */
            encoding: FactoryOrchestratorJavaScriptInlineSourceEncoding;
            /** @description Inline JavaScript workflow source text. */
            inline: string;
        };
        /** @description Canonical callable argument contract for invoking one factory. When present, CLI, API, dashboard, docs, and packaged-factory surfaces should discover and normalize invocation inputs from this shared schema instead of transport- or factory-specific argument definitions. */
        FactoryInvocationSignature: {
            /** @description Declared invocation parameters keyed by canonical parameter name. */
            parameters?: components["schemas"]["FactoryInvocationParameter"][];
            /** @description Policy for named inputs that do not match any declared parameter binding. */
            unknownNamedArgumentPolicy?: components["schemas"]["FactoryInvocationUnknownNamedArgumentPolicy"];
            /** @description Optional customer-facing hint for the factory's primary output shape. */
            outputContract?: components["schemas"]["FactoryInvocationOutputContract"];
        };
        /** @description One canonical invocation parameter declared on a factory. */
        FactoryInvocationParameter: {
            /** @description Internal canonical parameter name used for normalized argument maps and interpolation. */
            name: string;
            /** @description Customer-facing description rendered in help, docs, and form controls. */
            description?: string;
            /** @description Preferred named-argument key shown to callers, such as `output`. */
            externalName?: string;
            /** @description Additional accepted named-argument keys that normalize to this parameter. */
            aliases?: string[];
            /** @description String-first hint that guides parsing, docs, and dashboard form selection. */
            typeHint?: components["schemas"]["FactoryInvocationParameterTypeHint"];
            /** @description Declares whether the parameter consumes one value, repeated values, variadic values, or file contents. */
            valueMode?: components["schemas"]["FactoryInvocationParameterValueMode"];
            /** @description When true, invocation normalization must reject requests that omit this parameter. */
            required?: boolean;
            /** @description When true, diagnostics must preserve names and source metadata but redact concrete values. */
            sensitive?: boolean;
            /** @description Optional allowed string values for this parameter. */
            choices?: string[];
            /** @description Default string value used when an omitted parameter resolves to one effective value. */
            defaultValue?: string;
            /** @description Default string values used when an omitted parameter resolves to multiple effective values. */
            defaultValues?: string[];
            /** @description Accepted invocation bindings for this parameter across positional, named, and stdin sources. */
            bindings?: components["schemas"]["FactoryInvocationParameterBinding"][];
        };
        /** @description One public binding that exposes a parameter to callers. */
        FactoryInvocationParameterBinding: {
            /** @description Binding kind used to route invocation input into the parameter. */
            kind: components["schemas"]["FactoryInvocationParameterBindingKind"];
            /** @description 1-based positional slot used when kind is POSITIONAL. */
            position?: number;
        };
        /**
         * @description Public invocation binding kinds supported by factory signatures.
         * @enum {string}
         */
        FactoryInvocationParameterBindingKind: FactoryInvocationParameterBindingKind;
        /**
         * @description String-first parsing and UI hint for one factory invocation parameter.
         * @enum {string}
         */
        FactoryInvocationParameterTypeHint: FactoryInvocationParameterTypeHint;
        /**
         * @description Declares how one invocation parameter consumes one or more string values.
         * @enum {string}
         */
        FactoryInvocationParameterValueMode: FactoryInvocationParameterValueMode;
        /**
         * @description Policy for named inputs that do not match any declared parameter binding.
         * @enum {string}
         */
        FactoryInvocationUnknownNamedArgumentPolicy: FactoryInvocationUnknownNamedArgumentPolicy;
        /** @description Customer-facing output hint for a factory invocation signature. */
        FactoryInvocationOutputContract: {
            /** @description High-level output contract mode exposed to callers. */
            mode?: components["schemas"]["FactoryInvocationOutputContractMode"];
            /** @description Parameter name that controls the destination path when the factory writes output to disk. */
            pathParameter?: string;
            /** @description Output media type hint for docs, API consumers, and dashboard affordances. */
            contentType?: string;
            /** @description Suggested file extension when the output mode writes a file. */
            fileExtension?: string;
            /** @description Human-readable summary of the primary output contract. */
            description?: string;
        };
        /**
         * @description High-level output shape hint exposed by a factory invocation signature.
         * @enum {string}
         */
        FactoryInvocationOutputContractMode: FactoryInvocationOutputContractMode;
        /** @description One example invocation for docs, help, and packaged-factory inspection. */
        FactoryInvocationExample: {
            /** @description Stable example name. */
            name: string;
            /** @description Localized customer-facing explanation of what the example does. */
            description: components["schemas"]["NameValue"];
            /** @description Structured invocation arguments; values are never parsed or executed while loading the Factory. */
            args: components["schemas"]["FactoryInvocationArguments"];
        };
        /** @description Structured Factory invocation arguments keyed by parameter name, external name, or alias. Each value is either one string or an ordered array of strings. */
        FactoryInvocationArguments: {
            [key: string]: string | string[];
        };
        /** @description Factory-authored policy for selecting the primary result returned by CLI and API invocations. When omitted from a Factory, runtimes use the documented SUBMITTED_WORK_TERMINAL fallback. */
        InvocationReturn: {
            /** @description Return selection policy for this factory. */
            policy: components["schemas"]["InvocationReturnPolicy"];
            /** @description Work type name used by EXPLICIT policy selection. */
            workTypeName?: string;
            /** @description Authored terminal state name used by EXPLICIT policy selection. */
            terminalState?: string;
            /** @description Optional authored work name filter used by EXPLICIT policy selection. */
            workName?: string;
        };
        /**
         * @description Primary-result selection policy for factory invocation responses. SUBMITTED_WORK_TERMINAL traces the work submitted by the invocation until it reaches its first terminal output. EXPLICIT selects configured work content from the invocation submit scope.
         * @enum {string}
         */
        InvocationReturnPolicy: InvocationReturnPolicy;
        /** @description Factory-level guard attached at the root factory definition. */
        FactoryGuard: {
            /** @description Factory-level guard condition to evaluate before dispatch-ready transitions can proceed. */
            type: components["schemas"]["FactoryGuardType"];
            /** @description Provider whose inference-throttle history controls this factory-level guard. */
            modelProvider: components["schemas"]["ProviderIdentity"];
            /** @description Optional model name to scope throttling more narrowly than the provider-level window. */
            model?: string;
            /** @description Duration string that controls how long the factory should keep re-checking throttle history before allowing the lane again. */
            refreshWindow: string;
        };
        /** @description Canonical portability manifest for Agent Factory bundles. Required tools are validation-only PATH dependencies; bundled files carry portable content for restoration inside the factory boundary. */
        ResourceManifest: {
            /** @description Declarative external tools that must already resolve on PATH. These entries are validated but not embedded or installed. */
            requiredTools?: components["schemas"]["RequiredTool"][];
            /** @description Portable bundled files that belong inside the factory boundary. Entries are explicit only, use factory-relative target paths, and must stay under the canonical script, docs, or inputs roots for SCRIPT, DOC, or INPUT entries, or match the supported root-helper allowlist for ROOT_HELPER entries. Export, share, flatten, and materialize flows auto-discover SCRIPT and DOC files under the documented factory subtrees, but ROOT_HELPER entries such as Makefile are opt-in manifest entries that travel only when explicitly declared here. In v1 shared-factory flows, INPUT entries capture the source factory's current starter work at share time and are restored as independent recipient copies. */
            bundledFiles?: components["schemas"]["BundledFile"][];
        };
        /** @description One declarative external tool dependency for a portable factory. */
        RequiredTool: {
            /** @description Human-readable tool name used in manifests and validation output. */
            name: string;
            /** @description Executable lookup token that must resolve on PATH. */
            command: string;
            /** @description Optional explanation of why the portable factory requires this tool. */
            purpose?: string;
            /** @description Optional argument vector used by future validation flows to probe the tool version without changing the executable lookup token. */
            versionArgs?: string[];
        };
        /** @description One explicit portable bundled file entry carried by the factory portability manifest. SCRIPT files target factory/scripts/..., DOC files target factory/docs/..., INPUT files target factory/inputs/<work-type>/<channel>/..., and ROOT_HELPER files target supported project-root helper paths such as Makefile only when declared explicitly in bundledFiles. Export and flatten do not auto-discover project-root helpers. In v1 shared-factory exports, INPUT entries encode a share-time snapshot of starter work that is copied into the recipient factory as detached seeded work. */
        BundledFile: {
            /** @description Durable bundled-file identifier used by portable layout and graph editor references. When omitted on input, the canonical targetPath is materialized as the stable identifier. */
            id?: string;
            /**
             * @description Portable file class. SCRIPT entries target factory/scripts/..., DOC entries target factory/docs/..., INPUT entries target factory/inputs/<work-type>/<channel>/..., and ROOT_HELPER entries target supported project-root helper files such as Makefile only when explicitly declared in bundledFiles. Shared-factory INPUT entries snapshot current source inputs at share time instead of creating a live link.
             * @enum {string}
             */
            type: BundledFileType;
            /** @description Canonical factory-relative restoration target for the bundled file. Absolute paths, backslash-separated paths, and paths that require dot-segment normalization are rejected. */
            targetPath: string;
            content: components["schemas"]["BundledFileContent"];
        };
        /** @description Inline content payload for a portable bundled file. */
        BundledFileContent: {
            /**
             * @description Declared content encoding for the inline payload. V1 bundled files use UTF-8 text content.
             * @enum {string}
             */
            encoding: BundledFileContentEncoding;
            /** @description Inline bundled file content carried in the manifest. SCRIPT and DOC files under factory/scripts/ and factory/docs/ may be discovered during flatten, but supported root helper paths such as Makefile are bundled only when they appear as explicit ROOT_HELPER entries in bundledFiles. */
            inline: string;
        };
        /** @description Declared types of inputs. Used to force the inputs of a certain work type to be of a certain shape, like a specific JSON structure. */
        InputType: {
            /** @description Input type name. The reserved name "default" is implicit. */
            name: string;
            type: components["schemas"]["InputKind"];
        };
        /**
         * @description Kinds of input. `DEFAULT` passes opaque input through to workstations as-is.
         * @enum {string}
         */
        InputKind: InputKind;
        /** @description A named category of work that can move through the factory. Each work type declares the lifecycle states its work items can occupy. */
        WorkType: {
            /** @description Optional durable public identifier for this work type. When present, graph and layout references should use this id instead of the mutable name. */
            id?: string;
            /** @description Customer-authored work type name referenced by workstation inputs, outputs, and submitted work. */
            name: string;
            /** @description Optional localized customer-facing explanation of this work type. */
            description?: components["schemas"]["NameValue"];
            /** @description Lifecycle states available for work items of this type. */
            states: components["schemas"]["WorkState"][];
            /** @description Optional CLI routing markers for this work type. Factories used with you run --factory must declare handlingBehavior DEFAULT on exactly one work type. */
            handlingBehavior?: components["schemas"]["WorkTypeHandlingBehavior"][];
        };
        /** @description A lifecycle state that a work item can occupy inside one work type. */
        WorkState: {
            /** @description Optional durable public identifier for this state within its work type. When present, graph and layout references should use this id instead of the mutable name. */
            id?: string;
            /** @description Customer-authored state name referenced by workstation inputs and outputs. */
            name: string;
            /** @description Lifecycle category for this state, such as initial, processing, terminal, or failed. */
            type: components["schemas"]["WorkStateType"];
        };
        /**
         * @description Categories of work states. The factory runtime treats these categories differently for lifecycle tracking and metrics purposes. Initial: The work is waiting to be picked up by a workstation. Processing: The work has been partially processed, and is continuing through its lifecycle. Terminal: The work has completed successfully. Failed: The work has failed.
         * @enum {string}
         */
        WorkStateType: WorkStateType;
        /** @description Shared capacity that limits how much work the factory can run at once, such as worker slots or external service quotas. */
        Resource: {
            /** @description Optional durable public identifier for this resource. When present, graph and layout references should use this id instead of the mutable name. */
            id?: string;
            /** @description Resource name referenced from worker requirements and workstation resourceUsage entries. */
            name: string;
            /** @description Optional uppercase resource family, such as `MODEL`, `PROVIDER_QUOTA`, or `INVOCATION_SLOT`. */
            type?: components["schemas"]["ResourceType"];
            /** @description Total units of this resource available to the factory at one time. */
            capacity: number;
            /** @description Stable managed runtime identity for `MODEL` resources, such as `OMNIVOICE_Q4_K_M`. Packaged and authored factories declare the same managed-runtime dependency through this field plus matching `MODEL_WORKER.model` values. */
            model?: string;
            /** @description Managed runtime backend identifier for `MODEL` resources, such as `LLAMACPP`. Backend selection stays provider-agnostic in customer-facing factory config. */
            backend?: string;
            /** @description Managed runtime load policy for `MODEL` resources, such as `ON_DEMAND` or `EAGER`. */
            loadPolicy?: string;
            /** @description Provider identity associated with this resource, especially for `PROVIDER_QUOTA` resources. */
            provider?: string;
        };
        /**
         * @description Uppercase resource families supported by the public factory-config contract.
         * @enum {string}
         */
        ResourceType: ResourceType;
        /** @description A reusable worker definition that tells the factory how a workstation should execute work, such as through a model-backed agent or a script. */
        Worker: {
            /** @description Optional durable public identifier for this worker. When present, graph and layout references should use this id instead of the mutable name. */
            id?: string;
            /** @description Worker name referenced by Workstation.worker. */
            name: string;
            /** @description Optional localized customer-facing explanation of this worker. */
            description?: components["schemas"]["NameValue"];
            /** @description Worker implementation family to instantiate for this definition. */
            type?: components["schemas"]["WorkerType"];
            /** @description Built-in hosted provider identity when this worker uses repository-owned hosted execution. */
            provider?: components["schemas"]["HostedWorkerProvider"];
            /** @description Model identifier to request from the configured model provider when this worker uses model execution. */
            model?: string;
            /** @description Canonical provider identity used for model routing and provider diagnostics, or an exact invocation-parameter placeholder such as `${modelProvider}`. For `executorProvider: ACP`, this names the configured ACP integration, such as `cursor-acp`. Extension identities use lowercase standardized syntax; built-in values such as `CLAUDE` and `CODEX` remain compatibility conveniences. */
            modelProvider?: components["schemas"]["ProviderIdentity"] | string;
            reasoningEffort?: components["schemas"]["ReasoningEffort"];
            /** @description Provider locality for this model capability declaration. Use `LOCAL` for embedded or host-managed inference and `CLOUD` for remote provider execution. */
            modelLocality?: components["schemas"]["WorkerModelLocality"];
            /** @description Execution mechanism. Use `ACP` for ACP-backed workers and put the configured integration identity (for example `cursor-acp`) in modelProvider. `SCRIPT_WRAP` remains the command-wrapper compatibility value; legacy named executor identities remain accepted during migration. */
            executorProvider?: components["schemas"]["WorkerProvider"];
            /** @description Provider-agnostic model operations that this worker can execute, including named input and output slots. */
            operations?: components["schemas"]["ModelOperation"][];
            /** @description Command to execute when this worker runs through a command or script provider. */
            command?: string;
            /** @description Additional command arguments passed to the configured command. */
            args?: string[];
            /** @description Resource capacity this worker requires before it can be dispatched. */
            resources?: components["schemas"]["ResourceRequirement"][];
            /** @description Optional Go duration that caps one worker execution attempt. */
            timeout?: string;
            /** @description Marker that tells model-oriented workers where to stop generated output when the provider supports it. */
            stopToken?: string;
            /** @description When true, bypasses permission checks for providers that support permission gating. */
            skipPermissions?: boolean;
            /** @description Hosted-worker authentication contract. V1 hosted workers accept only auth.secretRef. */
            auth?: components["schemas"]["HostedWorkerAuth"];
            /** @description Provider-specific configuration for the built-in hosted LINEAR worker. */
            linear?: components["schemas"]["HostedLinearWorkerConfig"];
            /** @description Explicit agent-loop tool policy for AGENT_WORKER definitions. Omit or set policy DISABLED to run agent loops without advertising or executing tools. */
            agentTools?: components["schemas"]["AgentWorkerToolsConfig"];
            /** @description Inline worker instructions or script body when the worker is authored directly in factory config. */
            body?: string;
        };
        /** @description Explicit agent-loop tool policy for AGENT_WORKER definitions. Tool execution stays disabled unless this block is present with a non-DISABLED policy. */
        AgentWorkerToolsConfig: {
            /** @description Required executor policy for agent-loop tool use on this worker. */
            policy: components["schemas"]["AgentWorkerToolPolicy"];
        };
        /**
         * @description Explicit tool execution policy for AGENT_WORKER agent loops. DISABLED runs the harness in no-tools mode. READ_ONLY exposes bounded filesystem read tools. ENABLED adds bounded filesystem write capability for the first supported tool set.
         * @enum {string}
         */
        AgentWorkerToolPolicy: AgentWorkerToolPolicy;
        /**
         * @description Worker implementation families supported by the public factory-config contract.
         * @enum {string}
         */
        WorkerType: WorkerType;
        /**
         * @description Built-in model-provider constants retained as generated-client conveniences. Authored modelProvider fields use the open ProviderIdentity contract, so this list is not an exhaustive provider inventory.
         * @enum {string}
         */
        WorkerModelProvider: WorkerModelProvider;
        /** @description Open provider identity used by authored modelProvider fields. Extension identities use lowercase letters and digits separated by dots or hyphens. Built-in identities and documented legacy aliases remain accepted compatibility spellings. For example, `customer.provider` is a valid extension identity. */
        ProviderIdentity: string;
        /** @description Versioned public collection of provider manifests. */
        ProviderCatalog: {
            /**
             * @description Provider Catalog document format version.
             * @enum {string}
             */
            formatVersion: ProviderCatalogFormatVersion;
            /**
             * Format: uri
             * @description Immutable JSON Schema identifier used to validate every provider entry.
             * @enum {string}
             */
            providerSchema: ProviderCatalogProviderSchema;
            /** @description Optional source-revision provenance supplied by a publication staging process. */
            publicationProvenance?: {
                /**
                 * Format: uri
                 * @description Public source repository from which the catalog was published.
                 */
                sourceRepository: string;
                /** @description Full immutable Git commit identifying the published source tree. */
                sourceCommit: string;
            };
            /** @description Provider manifests in canonical provider-ID order. */
            providers: components["schemas"]["ProviderManifest"][];
        };
        /** @description Public, data-only metadata for one model-provider integration. A manifest describes evidenced maximum behavior and publication posture; it never reports current-machine installation, authentication, readiness, pricing, or runtime registration. */
        ProviderManifest: {
            /** @description Stable canonical lowercase provider identifier. */
            id: string;
            /** @description Alternate lowercase identifiers; aliases must not equal or shadow any catalog ID or alias. */
            aliases: string[];
            /** @description Localizable customer-facing provider name. */
            displayName: components["schemas"]["NameValue"];
            /** @description Localizable customer-facing provider summary. */
            description: components["schemas"]["NameValue"];
            /** @description Stable public documentation links for this provider. */
            documentation: components["schemas"]["ProviderDocumentationLink"][];
            technicalSupportLevel: components["schemas"]["ProviderTechnicalSupportLevel"];
            implementationAvailability: components["schemas"]["ProviderImplementationAvailability"];
            maximumExecutionCapabilities: components["schemas"]["ProviderExecutionCapabilities"];
            maximumResponseFidelityCapabilities: components["schemas"]["ProviderResponseFidelityCapabilities"];
            discovery: components["schemas"]["ProviderDiscoveryPrerequisites"];
            deprecation?: components["schemas"]["ProviderDeprecation"];
        };
        /**
         * @description Maintainer-verified technical support posture for a provider integration. This value does not describe whether the provider is installed or ready on the current machine.
         * @enum {string}
         */
        ProviderTechnicalSupportLevel: ProviderTechnicalSupportLevel;
        /**
         * @description How an implementation is supplied. Availability is publication metadata, not a live readiness or installation result.
         * @enum {string}
         */
        ProviderImplementationAvailability: ProviderImplementationAvailability;
        /** @description One stable public documentation resource for a provider. */
        ProviderDocumentationLink: {
            kind: components["schemas"]["ProviderDocumentationLinkKind"];
            /**
             * Format: uri
             * @description Public HTTPS documentation URL with a DNS hostname. Machine-local, IP-address, and credential-bearing URLs are invalid.
             */
            url: string;
        };
        /**
         * @description Purpose of one stable public provider documentation link.
         * @enum {string}
         */
        ProviderDocumentationLinkKind: ProviderDocumentationLinkKind;
        /** @description Maximum evidenced execution features of the provider integration. These values are independent of support posture and do not imply current-machine readiness. */
        ProviderExecutionCapabilities: {
            /** @description Accepts authored prompt input for execution. */
            promptSubmission: boolean;
            /** @description Accepts image content as invocation input. */
            imageInput: boolean;
            /** @description Can continue an identified provider session. */
            sessionResume: boolean;
            /** @description Can constrain authoritative output using a structured schema. */
            structuredOutput: boolean;
            /** @description Can execute provider-managed tools during an invocation. */
            toolExecution: boolean;
            /** @description Can execute with an explicit working directory. */
            workingDirectory: boolean;
            /** @description Can execute against an isolated source-control worktree. */
            worktree: boolean;
        };
        /** @description Maximum evidenced response-event fidelity of the provider integration. Capabilities describe observable output independently of support posture. */
        ProviderResponseFidelityCapabilities: {
            /** @description Exposes native streaming observations. */
            nativeStreaming: boolean;
            /** @description Emits incremental assistant-message deltas. */
            messageDeltas: boolean;
            /** @description Emits assistant-message snapshots. */
            messageSnapshots: boolean;
            /** @description Emits reasoning summaries or reasoning deltas. */
            reasoningSummaries: boolean;
            /** @description Emits correlated tool lifecycle metadata. */
            toolLifecycle: boolean;
            /** @description Emits incremental tool-output deltas. */
            toolOutputDeltas: boolean;
            /** @description Emits observed file changes. */
            fileChanges: boolean;
            /** @description Emits plan updates. */
            plans: boolean;
            /** @description Emits usage accounting. */
            usage: boolean;
            /** @description Assigns stable item identifiers across response events. */
            stableItemIds: boolean;
            /** @description Supports reconnecting an interrupted provider response stream. */
            providerReconnect: boolean;
        };
        /** @description Static, credential-free facts that tooling may use to explain how a provider can be discovered. Only names and endpoint kinds are published: credential values, environment values, endpoint addresses, machine-local paths, installation/readiness state, and pricing are outside this contract. */
        ProviderDiscoveryPrerequisites: {
            /** @description Executable basenames that may supply the provider integration. */
            executableNames: string[];
            /** @description Credential-free endpoint transport kinds; addresses and live status are not published. */
            endpointKinds: components["schemas"]["ProviderDiscoveryEndpointKind"][];
            /** @description Required configuration-key names only; configuration and environment values are forbidden. */
            configurationKeys: string[];
        };
        /**
         * @description Static endpoint transport kind that may be checked without credentials.
         * @enum {string}
         */
        ProviderDiscoveryEndpointKind: ProviderDiscoveryEndpointKind;
        /** @description Coherent metadata for a deprecated provider entry. Presence of this object means the provider is deprecated. replacementProviderId, when present, must name a different canonical provider in the same catalog; it cannot identify the deprecated provider itself. */
        ProviderDeprecation: {
            /**
             * Format: date
             * @description UTC calendar date on which the catalog began marking the provider deprecated.
             */
            deprecatedSince: string;
            /** @description Localizable explanation of why the provider is deprecated. */
            reason: components["schemas"]["NameValue"];
            /** @description Canonical ID of a different, non-deprecated replacement provider in this catalog. */
            replacementProviderId?: string;
        };
        /**
         * @description Provider locality for a model worker capability declaration.
         * @enum {string}
         */
        WorkerModelLocality: WorkerModelLocality;
        /** @description Worker execution mechanism. Canonical values are ACP and SCRIPT_WRAP; extensible lowercase identities remain accepted for compatibility with existing factories. */
        WorkerProvider: string;
        /** @description One provider-agnostic operation exposed by a model worker, such as `TTS`. */
        ModelOperation: {
            name: components["schemas"]["ModelOperationName"];
            /** @description Named operation input slots this worker can consume. */
            inputs?: components["schemas"]["ModelOperationSlot"][];
            /** @description Named operation output slots this worker can produce. */
            outputs?: components["schemas"]["ModelOperationSlot"][];
        };
        /** @description One named capability slot declared by a model operation. */
        ModelOperationSlot: {
            /** @description Stable slot name used by workstation-side bindings and diagnostics. */
            name: string;
            /** @description Uppercase content types accepted or produced by this slot. */
            contentTypes: components["schemas"]["ModelOperationContentType"][];
            /** @description Whether this input slot must be resolved before invocation starts. Output slots omit this field when not needed. */
            required?: boolean;
        };
        /**
         * @description Uppercase content-part categories supported by worker model-operation capability slots.
         * @enum {string}
         */
        ModelOperationContentType: ModelOperationContentType;
        /**
         * @description Stable built-in runner identifiers supported by factory and workstation runner selection.
         * @enum {string}
         */
        RunnerID: RunnerID;
        /**
         * @description Configuration layer that supplied the resolved built-in runner selection for a dispatch.
         * @enum {string}
         */
        RunnerSelectionSource: RunnerSelectionSource;
        /** @description A processing step in the factory graph. Workstations consume authored work states, run a worker or logical move, and emit the next work states. */
        Workstation: {
            /** @description Optional durable public identifier for this workstation. Graph and layout references should use this id instead of the mutable name. */
            id?: string;
            /** @description Customer-authored workstation name used by guards, diagnostics, and authored references. */
            name: string;
            /** @description Optional localized customer-facing explanation of this workstation. */
            description?: components["schemas"]["NameValue"];
            /** @description Scheduling behavior for this workstation, such as STANDARD, REPEATER, or CRON execution. */
            behavior?: components["schemas"]["WorkstationKind"];
            /** @description Runtime workstation implementation type, equivalent to the workstation AGENTS.md frontmatter type. */
            type?: components["schemas"]["WorkstationType"];
            /** @description Uppercase provider-agnostic operation requested by `MODEL_INVOKE` workstations, such as `TTS`. */
            operation?: components["schemas"]["ModelOperationName"];
            /** @description Optional workstation-authored slot bindings that resolve operation inputs from runtime content or static config content. */
            operationBindings?: components["schemas"]["WorkstationOperationBinding"][];
            /** @description Name of a worker declared in the workers list. */
            worker: string;
            /** @description Optional workstation-specific runner override. When omitted, dispatch falls back to the factory runner, then worker modelProvider compatibility when no explicit runner is configured, then the default codex runner. */
            runner?: components["schemas"]["RunnerID"];
            /** @description Path to a prompt template file loaded for model-oriented workstation execution. */
            promptFile?: string;
            /** @description JSON schema string used to validate or parse structured model output when configured. */
            outputSchema?: string;
            /** @description Optional worker-output parsing mode for model workstations. When set to `decision-envelope`, agent output is parsed as a reviewer/checker JSON envelope that maps directly onto WorkResult outcome, feedback, output, and optional recorded output work instead of stop-token routing. */
            outcomeFormat?: components["schemas"]["WorkstationOutcomeFormat"];
            /** @description Retry and execution ceilings applied to this workstation. */
            limits?: components["schemas"]["WorkstationLimits"];
            /** @description Optional policy for whether downstream work uses the workstation output payload or preserves the consumed input payload. */
            workPropagation?: components["schemas"]["WorkPropagation"];
            /** @description Inline workstation instructions or script body when authored directly in factory config. */
            body?: string;
            /** @description Cron trigger configuration for workstations whose behavior is CRON. */
            cron?: components["schemas"]["WorkstationCron"];
            /** @description Work states this workstation can consume before it dispatches. */
            inputs: components["schemas"]["WorkstationIO"][];
            /** @description Work states emitted after a non-classifier workstation succeeds. Classifier workstations must use classificationRoutes instead of normal success outputs. */
            outputs?: components["schemas"]["WorkstationIO"][];
            /** @description Explicit label-to-destination routing used only by CLASSIFIER_WORKSTATION definitions. Each route must declare a unique non-empty label and one or more outputs. */
            classificationRoutes?: components["schemas"]["ClassificationRoute"][];
            /** @description Optional destination emitted when the workstation makes partial progress and should continue iterating. Classifier workstations must not declare onContinue. */
            onContinue?: components["schemas"]["WorkstationIO"][];
            /** @description Optional destination emitted when the worker rejects the current work without a hard failure. Classifier workstations must not declare onRejection. */
            onRejection?: components["schemas"]["WorkstationIO"][];
            /** @description Optional destination emitted when the workstation fails permanently. */
            onFailure?: components["schemas"]["WorkstationIO"][];
            /** @description Resource capacity this workstation consumes while one dispatch is in flight. */
            resources?: components["schemas"]["ResourceRequirement"][];
            /** @description Copy supported referenced script files into the expanded workstation layout when config expand runs. */
            copyReferencedScripts?: boolean;
            /** @description Guarded loop breakers should use `VISIT_COUNT` guards here with a `LOGICAL_MOVE` workstation instead of top-level exhaustion rules. */
            guards?: components["schemas"]["WorkstationGuard"][];
            /** @description Stop words authored on the topology entry for model-oriented dispatches. */
            stopWords?: string[];
            /** @description Go template resolved from token tags at dispatch time. */
            workingDirectory?: string;
            /** @description Go template resolved and passed as the worktree path to CLI dispatchers. */
            worktree?: string;
            /** @description Environment variables added to the workstation execution context. */
            env?: components["schemas"]["StringMap"];
        };
        /**
         * @description Optional worker-output parsing mode for model workstations. When set to `decision-envelope`, agent output is parsed as a reviewer/checker JSON envelope that maps directly onto WorkResult outcome, feedback, output, and optional recorded output work instead of stop-token routing.
         * @enum {string}
         */
        WorkstationOutcomeFormat: WorkstationOutcomeFormat;
        ClassificationRoute: {
            /** @description Case-sensitive classifier label that must match the trimmed classifier output exactly. */
            label: string;
            /** @description One or more authored destinations emitted when this classifier label is selected. */
            outputs: components["schemas"]["WorkstationIO"][];
        };
        /** @description Retry and execution ceilings applied to one workstation definition. */
        WorkstationLimits: {
            /** @description Maximum number of retry attempts after a failed dispatch before the workstation gives up. */
            maxRetries?: number;
            /** @description Go duration limit for one dispatch attempt before it times out. */
            maxExecutionTime?: string;
            /** @description Fixed maximum number of Work items one accepted worker-emitted FACTORY_REQUEST_BATCH may contain. */
            maxGeneratedWorkItems?: number;
            /** @description Optional invocation argument whose positive integer value tightens the fixed generated-Work ceiling. */
            maxGeneratedWorkItemsArgument?: string;
            /** @description Offset added to the invocation argument before applying the generated-Work ceiling. */
            maxGeneratedWorkItemsArgumentOffset?: number;
        };
        /**
         * @description Scheduling kind for a workstation, which determines how the engine schedules and dispatches work to it. Standard workstations are scheduled as soon as their inputs are ready, and can have multiple work items in-flight at the same time.  Repeater workstations are triggered whenever their inputs change, and will reloop the outputs on rejection back to the initial place. Cron workstations create internal time work and dispatch their configured worker when time and input guards are satisfied. Poller workstations bind a poller-capable worker that the service runtime supervises as a long-lived ingress loop.
         * @default STANDARD
         * @enum {string}
         */
        WorkstationKind: WorkstationKind;
        /**
         * @description Runtime workstation implementation types supported by the public factory-config contract.
         * @enum {string}
         */
        WorkstationType: WorkstationType;
        /** @description Trigger timing for scheduled workstations. Provide exactly one of a five-field cron schedule or a positive duration in every; Factory validation enforces the exclusive choice. */
        WorkstationCron: {
            /** @description Standard five-field cron expression used to produce internal time work while the factory service is running. */
            schedule?: string;
            /** @description Positive Go duration interval, such as 30s, 5m, 1h, or 1h30m, used instead of schedule. */
            every?: string;
            /**
             * @description When true, service startup submits one immediate internal time work item before waiting for the next scheduled cron fire.
             * @default false
             */
            triggerAtStart: boolean;
            /** @description Non-negative Go duration used as the maximum deterministic delay added to scheduled time tokens. Defaults to "0s". */
            jitter?: string;
            /** @description Positive Go duration after due_at before a stale cron time token expires and can be consumed by the system expiry transition. Defaults to the duration until the next scheduled cron fire when omitted. */
            expiryWindow?: string;
        };
        /** @description Optional workstation policy for how downstream work receives payload content after this workstation completes. When omitted, downstream work uses the workstation output payload. */
        WorkPropagation: {
            /** @description Propagation mode for downstream work payload selection after this workstation succeeds. */
            mode: components["schemas"]["WorkPropagationMode"];
        };
        /**
         * @description Work payload propagation mode for a workstation. OUTPUT_AS_PAYLOAD uses the workstation output as the downstream work payload. PRESERVE_INPUT keeps the consumed input payload for downstream work instead of replacing it with the workstation output.
         * @enum {string}
         */
        WorkPropagationMode: WorkPropagationMode;
        /**
         * @description Guard condition attached to a workstation or one of its specific inputs.
         * @enum {string}
         */
        GuardType: GuardType;
        /** @description Shared guard attached either to a workstation as a whole or to one specific workstation input. */
        Guard: {
            /** @description Guard condition to evaluate for this workstation-level or input-level attachment. */
            type: components["schemas"]["GuardType"];
            /** @description For `VISIT_COUNT` guards, the workstation whose visits are counted. */
            workstation?: string;
            /** @description For `VISIT_COUNT` guards, the fixed visit ceiling. */
            maxVisits?: number;
            /** @description Optional invocation argument whose positive integer value tightens the fixed visit ceiling. */
            maxVisitsArgument?: string;
            /** @description For `MATCHES_FIELDS` guards, the field-selector configuration used to compare candidate inputs. */
            matchConfig?: components["schemas"]["GuardMatchConfig"];
            /** @description For parent-aware input guards, the parent workType name from another input in the same workstation. */
            parentInput?: string;
            /** @description For `SAME_NAME` and `SAME_TRACE_ID` input guards, the peer input workType name from another input in the same workstation. */
            matchInput?: string;
            /** @description For dynamic fanout input guards, the workstation that spawns the children for count tracking. */
            spawnedBy?: string;
        };
        GuardMatchConfig: {
            /** @description Field selector resolved against each candidate input, such as `.Name` or `.Tags["_last_output"]`. */
            inputKey: string;
        };
        /** @description One authored work-state reference consumed or emitted by a workstation. */
        WorkstationIO: {
            /** @description Name of the work type consumed or emitted at this edge of the workstation. */
            workType: string;
            /** @description Name of the work state consumed or emitted for the referenced work type. */
            state: string;
            /** @description Per-input guards that must pass before this specific input can be used. */
            guards?: components["schemas"]["InputGuard"][];
        };
        Transition: {
            /** @description Source workstation name. */
            from: string;
            /** @description Destination workstation name. */
            to: string;
        };
        PromptTemplateContract: {
            /** @description Available prompt-template variables for the selected workstation editing context. */
            availableVariables: components["schemas"]["PromptTemplateVariableReference"][];
            /** @description Number of authored inputs on the selected workstation, which controls valid `.Inputs[N]` access. */
            inputCount: number;
            /** @description Unsupported or unavailable variable access patterns for the selected workstation editing context. */
            unavailableAccessPatterns: components["schemas"]["PromptTemplateUnavailableAccessPattern"][];
        };
        PromptTemplateVariableReference: {
            /**
             * @description High-level grouping for the variable reference.
             * @enum {string}
             */
            category: PromptTemplateVariableReferenceCategory;
            /** @description User-readable description of what the variable resolves to. */
            description: string;
            /** @description Go template snippet that shows how to reference the variable. */
            example: string;
            /** @description Canonical variable path summary used in diagnostics and help surfaces. */
            path: string;
        };
        PromptTemplateUnavailableAccessPattern: {
            /** @description Representative unsupported template snippet for this access pattern. */
            example: string;
            /** @description Unsupported or unavailable variable path pattern. */
            path: string;
            /** @description Why the access pattern is unavailable or unsupported in the selected workstation context. */
            reason: string;
        };
        PromptTemplateValidationRequest: {
            /** @description Prompt draft to validate against the selected current-factory workstation contract. */
            prompt: string;
        };
        PromptTemplateValidationResult: {
            /** @description Typed validation diagnostics for the submitted prompt draft. */
            diagnostics: components["schemas"]["PromptTemplateDiagnostic"][];
            /** @description True when the prompt contains no syntax or variable diagnostics. */
            valid: boolean;
        };
        PromptTemplateDiagnostic: {
            /** @description Inclusive 1-based byte offset where the diagnostic source span ends when available. */
            endOffset: number;
            /**
             * @description Diagnostic classification for prompt-template validation.
             * @enum {string}
             */
            kind: PromptTemplateDiagnosticKind;
            /** @description User-readable explanation of the validation failure. */
            message: string;
            /** @description Canonical variable path or access pattern involved in the diagnostic when available. */
            path: string;
            /** @description Source variable or access expression that triggered the diagnostic when available. */
            sourceText: string;
            /** @description Inclusive 1-based byte offset where the diagnostic source span starts when available. */
            startOffset: number;
        };
        WorkflowDiagnostic: {
            /** @description Stable workflow diagnostic code. */
            code: string;
            /** @description Customer-readable diagnostic message. */
            message: string;
            /** @description Optional source or config path for the diagnostic. */
            path?: string;
            /** @description Optional 1-based source line number. */
            line?: number;
            /** @description Optional 1-based source column number. */
            column?: number;
        };
        WorkflowArtifactRootDecision: {
            /** @description Artifact root requested with the workflow source. */
            requested: string;
            /** @description Normalized artifact root when allowed. */
            effective?: string;
            /** @description True when the artifact root satisfies policy checks. */
            allowed: boolean;
            /** @description Diagnostic explaining artifact-root rejection when present. */
            diagnostic?: components["schemas"]["WorkflowDiagnostic"];
        };
        WorkflowSourceResolution: {
            /** @description Requested workflow source kind. */
            requestKind: string;
            /** @description Original requested workflow source value. */
            requestValue?: string;
            /** @description Resolved workflow source kind. */
            resolvedKind?: string;
            /** @description Ordered lookup stage that supplied the resolved source. */
            lookupStage?: string;
            /** @description Safe resolved workflow source reference. */
            sourceRef?: string;
            /** @description Stable hash of the authored workflow source. */
            sourceHash?: string;
            /** @description Resolved orchestrator kind for the workflow source. */
            orchestratorKind?: string;
            /** @description Resolved workflow dialect label. */
            dialect?: string;
            /** @description True when a workflow source was resolved. */
            found: boolean;
            /** @description Lookup or conflict diagnostics when source resolution fails or conflicts. */
            diagnostics?: components["schemas"]["WorkflowDiagnostic"][];
            artifactRoot?: components["schemas"]["WorkflowArtifactRootDecision"];
        };
        WorkflowResultConstraints: {
            /** @description True when workflow return values must be structured-cloneable JSON-compatible values. */
            requiresStructuredCloneableJson: boolean;
            /** @description URI scheme used for session-scoped artifact references. */
            artifactUriScheme: string;
            /**
             * Format: int64
             * @description Maximum embedded JSON payload size before artifact refs are required.
             */
            maxEmbeddedBytes: number;
            /** @description Non-JSON workflow result kinds rejected by the shared contract. */
            rejectedValueKinds: string[];
        };
        WorkflowPolicyPreview: {
            /** @description Effective bounded workflow policy for preview or session start. */
            effectivePolicy: {
                [key: string]: unknown;
            };
            /** @description Stable hash of the effective policy document. */
            policyHash: string;
            /** @description Maximum child agent count allowed by effective policy. */
            maxChildCount: number;
            /** @description Maximum concurrent child dispatches allowed by effective policy. */
            maxConcurrency: number;
            /** @description Capabilities denied by the effective policy before runtime execution. */
            deniedCapabilities: components["schemas"]["WorkflowDiagnostic"][];
            /** @description Policy validation issues for the requested or factory default policy. */
            validationIssues: components["schemas"]["WorkflowDiagnostic"][];
            /** @description Optional runner allowlist decision for preview surfaces. */
            runnerDecision?: {
                [key: string]: unknown;
            };
            /** @description Optional model allowlist decision for preview surfaces. */
            modelDecision?: {
                [key: string]: unknown;
            };
            /** @description Optional route profile allowlist decision for preview surfaces. */
            profileDecision?: {
                [key: string]: unknown;
            };
            /** @description Timeout and budget decisions for preview surfaces. */
            timeoutDecisions?: {
                [key: string]: unknown;
            };
            /** @description Child and concurrency budget decisions for preview surfaces. */
            budgetDecisions?: {
                [key: string]: unknown;
            };
        };
        FactoryPreviewRequest: {
            /**
             * @description JavaScript orchestrator factory source request kind for Factory preview.
             * @enum {string}
             */
            sourceKind: FactoryPreviewRequestSourceKind;
            /** @description Requested workflow name, file ref, factory id, or inline label. */
            sourceValue?: string;
            /** @description Inline orchestrator source text for INLINE_WORKFLOW or FACTORY_INLINE requests. */
            inlineSource?: string;
            /** @description Optional absolute artifact root requested with the factory source. */
            artifactRoot?: string;
            /** @description When true, explicit factory lookup is attempted after ordered workflow lookup. */
            allowFactoryLookup?: boolean;
            /** @description Project root used for ordered JavaScript orchestrator source lookup. */
            projectRoot?: string;
            /** @description Optional JavaScript orchestrator metadata to validate with the source. */
            metadata?: {
                [key: string]: string;
            };
            /** @description Optional JSON Schema object describing factory session invocation arguments. */
            argsSchema?: {
                [key: string]: unknown;
            };
            /** @description Optional factory default policy layer merged into the effective policy preview. */
            defaultPolicy?: {
                [key: string]: unknown;
            };
            /** @description Optional request policy overrides merged into the effective policy preview. */
            requestedPolicy?: {
                [key: string]: unknown;
            };
            /** @description Optional runner requested for preview decision projection. */
            requestedRunner?: string;
            /** @description Optional model requested for preview decision projection. */
            requestedModel?: string;
            /** @description Optional route profile requested for preview decision projection. */
            requestedProfile?: string;
            /**
             * Format: int64
             * @description Optional requested timeout in milliseconds for preview decision projection.
             */
            timeoutMillis?: number;
        };
        FactoryPreviewResult: {
            /** @description True when source resolution, validation, policy, and artifact-root checks pass for Factory preview. */
            valid: boolean;
            sourceResolution: components["schemas"]["WorkflowSourceResolution"];
            /** @description JavaScript orchestrator source, loader, and validation diagnostics. */
            sourceValidationIssues: components["schemas"]["WorkflowDiagnostic"][];
            policyPreview: components["schemas"]["WorkflowPolicyPreview"];
            resultConstraints: components["schemas"]["WorkflowResultConstraints"];
        };
        /**
         * @description Validation severity for one factory validation target.
         * @enum {string}
         */
        FactoryValidationSeverity: FactoryValidationSeverity;
        /**
         * @description Factory-domain component type referenced by one validation target subject.
         * @enum {string}
         */
        FactoryValidationSubjectType: FactoryValidationSubjectType;
        /**
         * @description Factory-domain location within the subject component referenced by one validation target.
         * @enum {string}
         */
        FactoryValidationSubjectLocation: FactoryValidationSubjectLocation;
        FactoryValidationSubject: {
            type: components["schemas"]["FactoryValidationSubjectType"];
            /** @description Stable component identifier or name for the affected factory component. */
            id: string;
            location: components["schemas"]["FactoryValidationSubjectLocation"];
        };
        FactoryValidationTarget: {
            /** @description Stable machine-readable validation rule identifier. */
            code: string;
            severity: components["schemas"]["FactoryValidationSeverity"];
            /** @description Human-readable explanation suitable for dialogs and summaries. */
            message: string;
            subject: components["schemas"]["FactoryValidationSubject"];
            /** @description Canonical Factory definition path for the affected value when one is available. */
            path?: string;
        };
        /**
         * @example {
         *       "targets": [
         *         {
         *           "code": "factory.workstation.missingRejectionRoute",
         *           "severity": "error",
         *           "message": "Workstation repeater must define a reject route.",
         *           "subject": {
         *             "type": "WORKSTATION",
         *             "id": "repeater",
         *             "location": "ON_REJECTION"
         *           }
         *         },
         *         {
         *           "code": "factory.workType.missingCompletionState",
         *           "severity": "error",
         *           "message": "Work type task must declare a completion state.",
         *           "subject": {
         *             "type": "WORK_TYPE",
         *             "id": "task",
         *             "location": "STATES"
         *           }
         *         }
         *       ]
         *     }
         */
        FactoryValidationResult: {
            /** @description Canonical validation targets for the submitted factory definition. */
            targets: components["schemas"]["FactoryValidationTarget"][];
        };
        /** @description Shared operator configuration stored in .you-agent-factory/config.json. */
        GlobalConfig: {
            /** @description Stable identifier for the local provider-backed runtime boundary. */
            backendScopeID?: string;
            defaults?: components["schemas"]["GlobalConfigDefaults"];
            runtime?: components["schemas"]["GlobalConfigRuntime"];
            workers?: components["schemas"]["GlobalConfigWorkers"];
            /** @description Named worker model presets loaded from the shared configuration file. */
            workerPresets?: components["schemas"]["GlobalConfigWorkerPreset"][];
        };
        /** @description Operator defaults that participate independently in file, environment, and flag precedence. */
        GlobalConfigDefaults: {
            /** @description Default worker model provider, including supported aliases and symbolic DEFAULT resolution. */
            workerModelProvider?: string;
            /** @description Default worker model name. */
            workerModel?: string;
        };
        /** @description Runtime observability settings loaded from operator configuration before command-line overrides. */
        GlobalConfigRuntime: {
            /** @description Structured runtime log storage settings. Omitted values use the documented production defaults. */
            logging?: components["schemas"]["GlobalConfigRuntimeArtifactSettings"];
            /** @description Runtime metrics storage settings. Omitted values use the documented production defaults. */
            metrics?: components["schemas"]["GlobalConfigRuntimeArtifactSettings"];
        };
        /** @description Rolling-file storage settings for one runtime observability artifact. */
        GlobalConfigRuntimeArtifactSettings: {
            /** @description Optional artifact root. Omission uses the runtime-owned directory below the operator home. */
            directory?: string;
            /**
             * @description Maximum artifact file size in megabytes before rotation.
             * @default 100
             */
            maxSizeMB: number;
            /**
             * @description Maximum number of rotated artifact files to retain.
             * @default 20
             */
            maxBackups: number;
            /**
             * @description Maximum age in days for rotated artifact files.
             * @default 30
             */
            maxAgeDays: number;
            /**
             * @description Whether rotated artifact files are gzip-compressed.
             * @default false
             */
            compress: boolean;
        };
        /** @description Named worker model selection available to Factory Session runtime opening. */
        GlobalConfigWorkerPreset: {
            /** @description Non-empty preset identifier after surrounding whitespace is trimmed. */
            id: string;
            modelProvider: components["schemas"]["GlobalConfigWorkerPresetModelProvider"];
            /** @description Optional model name, trimmed when present. */
            model?: string;
            reasoningEffort?: components["schemas"]["GlobalConfigWorkerPresetReasoningEffort"];
        };
        /** @description Canonical provider identity or built-in compatibility alias; surrounding whitespace is trimmed, and symbolic DEFAULT is not accepted for presets. */
        GlobalConfigWorkerPresetModelProvider: string;
        /** @description Optional reasoning effort; surrounding whitespace and letter case are normalized, and an empty value is treated as unspecified. */
        GlobalConfigWorkerPresetReasoningEffort: string;
        WorkRequest: {
            /** @description Stable client-provided request identifier used for idempotent batch submission. */
            requestId: string;
            /** @description Optional default chaining-trace identifier applied to submitted work items that omit it. */
            currentChainingTraceId?: string;
            type: components["schemas"]["WorkRequestType"];
            /** @description A batch of work items to be submitted together. */
            works?: components["schemas"]["Work"][];
            /** @description Relationships between various work items. */
            relations?: components["schemas"]["Relation"][];
        };
        /**
         * @description Kind of work request accepted by the factory.
         * @enum {string}
         */
        WorkRequestType: WorkRequestType;
        /** @description A piece of work. */
        Work: {
            /** @description A human readable name for the work, not unique */
            name: string;
            /** @description Unique identifier for the work */
            workId?: string;
            /** @description Identifier for the original request that created this work, if applicable */
            requestId?: string;
            /** @description Configured work type name from factory.json for this submitted work item. */
            workTypeName?: string;
            /** @description Current lifecycle state for this work item when returned by read APIs. Submit requests use the state's name when an explicit initial state is provided. */
            state?: components["schemas"]["WorkState"];
            /** @description Current chaining depth for this work item when the runtime already knows its upstream lineage. */
            chainingTraceDepth?: number;
            /** @description Explicit chaining-trace identifier for this submitted work item. */
            currentChainingTraceId?: string;
            /** @description Explicit predecessor chaining traces that directly caused this work item. */
            previousChainingTraceIds?: string[];
            /** @description Legacy trace identifier retained for compatibility; prefer currentChainingTraceId. */
            traceId?: string;
            /** @description Optional canonical ordered work content parts for this work item. */
            content?: components["schemas"]["WorkContent"];
            /** @description Opaque work payload forwarded as raw JSON, or a binary data, or whatever else. */
            payload?: unknown;
            /** @description Key-value pairs for storing arbitrary metadata about the work. Both keys and values are strings. */
            tags?: components["schemas"]["StringMap"];
            /** @description Current outbound relationships attached to this listed source work item when returned by read APIs. */
            relations?: components["schemas"]["Relation"][];
            /** @description Canonical stopped-state summary for existing work inspection reads when this work item explains paused, blocked, needs-human, or interrupted automation. */
            stopSummary?: components["schemas"]["FactoryStopSummary"];
        };
        /** @description Ordered canonical content parts for one work item. */
        WorkContent: components["schemas"]["WorkContentPart"][];
        /** @description One ordered canonical content part on a work item. */
        WorkContentPart: components["schemas"]["WorkTextContentPart"] | components["schemas"]["WorkImageContentPart"] | components["schemas"]["WorkAudioContentPart"] | components["schemas"]["WorkJsonContentPart"] | components["schemas"]["WorkBinaryContentPart"];
        /**
         * @description Supported canonical work content part types. Legacy lowercase text and image values remain accepted for backward compatibility.
         * @enum {string}
         */
        WorkContentPartType: WorkContentPartType;
        /** @description Optional metadata attached to one work content part. */
        WorkContentMetadata: {
            [key: string]: unknown;
        };
        WorkContentCommonFields: {
            /** @description Optional slot name used by model-operation binding selectors and diagnostics. */
            slot?: string;
            /** @description Optional caller-defined label for slot binding or diagnostics. */
            label?: string;
            /** @description Optional semantic role for model-operation authoring. */
            role?: string;
            /** @description Optional MIME content type for file-backed or structured parts. */
            contentType?: string;
            /** @description Optional artifact identifier for externally materialized content. */
            artifactId?: string;
            metadata?: components["schemas"]["WorkContentMetadata"];
        };
        /** @description Ordered inline text content for one work item. */
        WorkTextContentPart: components["schemas"]["WorkContentCommonFields"] & {
            /** @enum {unknown} */
            type: WorkTextContentPartType;
            /** @description Inline text content preserved in canonical part order. */
            text: string;
        };
        /** @description Ordered image content for one work item. */
        WorkImageContentPart: components["schemas"]["WorkContentCommonFields"] & {
            /** @enum {unknown} */
            type: WorkImageContentPartType;
            url: components["schemas"]["WorkContentURLProperty"];
            file?: components["schemas"]["WorkContentDeprecatedFileProperty"];
        };
        /** @description Ordered audio content for one work item. */
        WorkAudioContentPart: components["schemas"]["WorkContentCommonFields"] & {
            /** @enum {unknown} */
            type: WorkAudioContentPartType;
            url: components["schemas"]["WorkContentURLProperty"];
            file?: components["schemas"]["WorkContentDeprecatedFileProperty"];
        };
        /** @description Ordered JSON content for one work item. */
        WorkJsonContentPart: components["schemas"]["WorkContentCommonFields"] & {
            /** @enum {unknown} */
            type: WorkJsonContentPartType;
            /** @description Arbitrary JSON value preserved in canonical part order. */
            json: unknown;
        };
        /** @description Ordered binary content for one work item. */
        WorkBinaryContentPart: components["schemas"]["WorkContentCommonFields"] & {
            /** @enum {unknown} */
            type: WorkBinaryContentPartType;
            url: components["schemas"]["WorkContentURLProperty"];
            file?: components["schemas"]["WorkContentDeprecatedFileProperty"];
        };
        Relation: {
            type: components["schemas"]["RelationType"];
            targetWorkId?: string;
            targetWorkName: string;
            sourceWorkName: string;
            requiredState?: string;
        };
        /**
         * @description Relationship category between two pieces of work.
         * @enum {string}
         */
        RelationType: RelationType;
        /** @description Canonical content reference for file-backed parts. Supported schemes are file://, http://, https://, data:, and you-artifact:// for session-scoped factory artifact refs. */
        WorkContentURLProperty: string;
        /** @description Deprecated host-local file path. Use url instead. Legacy values may be normalized to url at ingest during migration. */
        WorkContentDeprecatedFileProperty: string;
        /** @description Canonical content URL for the submitted file-backed item. Supported schemes are file://, http://, https://, and data:. */
        SubmitWorkContentURLProperty: string;
        /** @description Uppercase public operation identifier such as `TTS`, `ASR`, or `EMBED`. */
        ModelOperationName: string;
        /** @description Selector fields used to resolve one content part from ordered runtime input. */
        WorkstationOperationBindingSelector: {
            /** @description Match a content part by its authored slot field. */
            slot?: string;
            /** @description Match a content part by its label field. */
            label?: string;
            /** @description Match a content part by its uppercase public type. */
            type?: components["schemas"]["ModelOperationContentType"];
            /** @description Match a content part by its role field. */
            role?: string;
        };
        /** @description One workstation-authored binding for a provider-agnostic model-operation input slot. */
        WorkstationOperationBinding: {
            /** @description Stable input slot name declared by the worker operation. */
            slot: string;
            /** @description Ordered runtime-input selector used before falling back to config or default content. */
            selector?: components["schemas"]["WorkstationOperationBindingSelector"];
            /** @description Static authored content bound directly or used as the first fallback when runtime input does not match. */
            config?: components["schemas"]["WorkContent"];
            /** @description Optional final fallback content when neither runtime input nor config content resolves the slot. */
            defaultContent?: components["schemas"]["WorkContent"];
        };
        /** @description Default worker selection for one named JavaScript child-agent role. */
        FactoryOrchestratorJavaScriptAgent: {
            /** @description Operator worker preset inherited by child calls using this agent id. */
            preset: string;
        };
        /**
         * @description Factory-level guard condition attached at the root factory definition.
         * @enum {string}
         */
        FactoryGuardType: FactoryGuardType;
        /**
         * @description Declares how the CLI should route simplified one-shot prompt submissions for this work type. DEFAULT marks the single work type that receives positional prompts from you run --factory.
         * @enum {string}
         */
        WorkTypeHandlingBehavior: WorkTypeHandlingBehavior;
        /** @description Two-dimensional authored graph layout coordinate. */
        FactoryLayoutPoint: {
            /** @description Horizontal graph layout coordinate in authored canvas space. */
            x: number;
            /** @description Vertical graph layout coordinate in authored canvas space. */
            y: number;
        };
        /** @description Authored node size in graph canvas units. */
        FactoryLayoutSize: {
            /** @description Authored node width. */
            width: number;
            /** @description Authored node height. */
            height: number;
        };
        /** @description Extensible discriminated image-source shape. Version 1 supports only embedded raster data. */
        FactoryLayoutImageSource: {
            /**
             * @description Source variant discriminator. EMBEDDED carries portable base64 raster data.
             * @enum {string}
             */
            kind: FactoryLayoutImageSourceKind;
            /**
             * @description Declared media type for the embedded raster.
             * @enum {string}
             */
            mediaType: FactoryLayoutImageSourceMediaType;
            /**
             * Format: byte
             * @description Strict padded base64 payload for the embedded raster source, limited to 2 MiB after decoding.
             */
            data: string;
        };
        /** @description Inert embedded-raster image content with required alternative text. */
        FactoryLayoutImage: {
            source: components["schemas"]["FactoryLayoutImageSource"];
            /** @description Literal alternative text for the embedded image. */
            alternativeText: string;
        };
        /** @description Inert presentation content for one canonical topology node when it has no live activity. It is definition metadata only and does not create events or runtime behavior. */
        FactoryLayoutEmptyState: {
            /** @description Literal empty-state text. It is not rendered as HTML or Markdown. */
            text?: string;
            image?: components["schemas"]["FactoryLayoutImage"];
        } & ({
            /** @description Literal empty-state text. It is not rendered as HTML or Markdown. */
            text: string;
        } | {
            image: components["schemas"]["FactoryLayoutImage"];
        });
        /** @description Portable graph node layout keyed by canonical graph node id. */
        FactoryLayoutNode: {
            /** @description Canonical graph node id such as workstation:<workstationId>. */
            id: string;
            position: components["schemas"]["FactoryLayoutPoint"];
            size?: components["schemas"]["FactoryLayoutSize"];
            /** @description Optional authored node lock flag for future editor affordances. */
            locked?: boolean;
            emptyState?: components["schemas"]["FactoryLayoutEmptyState"];
        };
        /** @description Portable graph edge layout keyed by canonical graph edge id. */
        FactoryLayoutEdge: {
            /** @description Canonical graph edge id such as workstation-output:workstation:review->work-state:task:done. */
            id: string;
            /** @description Optional authored intermediate edge points in graph canvas space. */
            waypoints?: components["schemas"]["FactoryLayoutPoint"][];
            labelPosition?: components["schemas"]["FactoryLayoutPoint"];
        };
        /** @description Authored rectangular bounds in graph canvas units. */
        FactoryLayoutBounds: {
            /** @description Left graph layout coordinate. */
            x: number;
            /** @description Top graph layout coordinate. */
            y: number;
            /** @description Authored group width. */
            width: number;
            /** @description Authored group height. */
            height: number;
        };
        /** @description Portable background grouping metadata for graph canvas presentation. */
        FactoryLayoutGroup: {
            /** @description Stable authored group id for future layout editing. */
            id: string;
            /** @description Optional visible group label. */
            label?: string;
            bounds: components["schemas"]["FactoryLayoutBounds"];
            /** @description Canonical graph node ids visually contained by this group. */
            nodeIds: string[];
            /** @description Reserved for future nested groups. Omit or set null for flat groups. */
            parentGroupId?: string | null;
            /** @description Optional authored group accent or fill color. */
            color?: string;
            /** @description Optional authored group lock flag for future editor affordances. */
            locked?: boolean;
        };
        /** @description Explicit finite annotation position in canvas units. Each coordinate is bounded to keep portable layout metadata safe to render. */
        FactoryLayoutAnnotationPosition: {
            /** @description Horizontal canvas coordinate between -100,000 and 100,000 inclusive. */
            x: number;
            /** @description Vertical canvas coordinate between -100,000 and 100,000 inclusive. */
            y: number;
        };
        /** @description Optional finite annotation dimensions in canvas units. Image annotations require this size; note annotations may omit it. */
        FactoryLayoutAnnotationSize: {
            /** @description Positive authored width no greater than 10,000 canvas units. */
            width: number;
            /** @description Positive authored height no greater than 10,000 canvas units. */
            height: number;
        };
        /**
         * @description Presentation-only tone for a note annotation.
         * @enum {string}
         */
        FactoryLayoutNoteTone: FactoryLayoutNoteTone;
        /** @description Literal plain-text note content. Line breaks are preserved as authored text and are not interpreted as Markdown or HTML. */
        FactoryLayoutNote: {
            /** @description Optional literal plain-text note title. */
            title?: string;
            /** @description Required literal plain-text note body. */
            body: string;
            tone: components["schemas"]["FactoryLayoutNoteTone"];
        };
        /**
         * @description The inert annotation content variant.
         * @enum {string}
         */
        FactoryLayoutAnnotationKind: FactoryLayoutAnnotationKind;
        /** @description Inert positioned canvas annotation. Its kind selects either note or image content; annotations never identify graph nodes or edges, and connection-like fields are invalid. */
        FactoryLayoutAnnotation: {
            /** @description Stable annotation identifier unique within this layout. */
            id: string;
            kind: components["schemas"]["FactoryLayoutAnnotationKind"];
            position: components["schemas"]["FactoryLayoutAnnotationPosition"];
            size?: components["schemas"]["FactoryLayoutAnnotationSize"];
            note?: components["schemas"]["FactoryLayoutNote"];
            image?: components["schemas"]["FactoryLayoutImage"];
        } & ({
            id: string;
            /** @enum {string} */
            kind: FactoryLayoutAnnotationOneOf0Kind;
            position: components["schemas"]["FactoryLayoutAnnotationPosition"];
            size?: components["schemas"]["FactoryLayoutAnnotationSize"];
            note: components["schemas"]["FactoryLayoutNote"];
        } | {
            id: string;
            /** @enum {string} */
            kind: FactoryLayoutAnnotationOneOf1Kind;
            position: components["schemas"]["FactoryLayoutAnnotationPosition"];
            size: components["schemas"]["FactoryLayoutAnnotationSize"];
            image: components["schemas"]["FactoryLayoutImage"];
        });
        /** @description Shared authored graph camera position. */
        FactoryLayoutViewport: {
            /** @description Authored viewport horizontal offset. */
            x: number;
            /** @description Authored viewport vertical offset. */
            y: number;
            /** @description Authored viewport zoom factor. */
            zoom: number;
        };
        /** @description Portable graph display defaults that do not alter factory topology. */
        FactoryLayoutPreferences: {
            /**
             * @description Preferred authored graph direction for portable layout rendering.
             * @enum {string}
             */
            direction?: FactoryLayoutPreferencesDirection;
        };
        /** @description Non-executable portable graph editor layout metadata keyed by canonical graph ids. */
        FactoryLayout: {
            /**
             * Format: int32
             * @description Portable layout contract schema version. Version 1 is the initial public layout contract.
             */
            schemaVersion: number;
            /** @description Optional authored graph node geometry keyed by canonical graph node id. */
            nodes?: components["schemas"]["FactoryLayoutNode"][];
            /** @description Optional authored graph edge geometry keyed by canonical graph edge id. */
            edges?: components["schemas"]["FactoryLayoutEdge"][];
            /** @description Optional flat background groups keyed independently from topology. */
            groups?: components["schemas"]["FactoryLayoutGroup"][];
            /** @description Optional inert positioned notes and embedded-raster images that decorate the canvas without becoming graph topology. */
            annotations?: components["schemas"]["FactoryLayoutAnnotation"][];
            viewport?: components["schemas"]["FactoryLayoutViewport"];
            preferences?: components["schemas"]["FactoryLayoutPreferences"];
        };
        /**
         * @description Built-in repository-owned hosted worker providers supported by the public factory-config contract.
         * @enum {string}
         */
        HostedWorkerProvider: HostedWorkerProvider;
        /** @description Optional provider-neutral reasoning effort. Surrounding whitespace and letter case are normalized. Omit the field to preserve the selected provider and model default. Factory definitions may use an exact invocation-parameter placeholder such as `${executorReasoningEffort}`. */
        ReasoningEffort: string;
        /** @description Hosted-worker authentication contract. V1 hosted workers accept only secret references rather than inline credentials or OAuth-style fields. */
        HostedWorkerAuth: {
            /** @description Referenced secret name that resolves the hosted provider API key at runtime. */
            secretRef?: string;
        };
        /** @description Deterministic issue-to-work mapping fields owned by a hosted Linear worker. */
        HostedLinearWorkerMapping: {
            /** @description Canonical submitted work type emitted for matched Linear issues. */
            workType?: string;
            /** @description Canonical submitted work state emitted for matched Linear issues. */
            state?: string;
        };
        /** @description Optional claim-related configuration that v1 hosted Linear workers explicitly allow. */
        HostedLinearWorkerClaim: {
            /** @description Linear issue field name to use when deriving optional assignee claim metadata. */
            assigneeField?: string;
        };
        /** @description Provider-specific poller configuration for the built-in hosted Linear worker. */
        HostedLinearWorkerConfig: {
            /** @description Optional Go duration that controls how often the hosted Linear worker polls for updates. */
            pollInterval?: string;
            /** @description Optional Linear team identifiers that bound the poll source. */
            teamIds?: string[];
            /** @description Optional Linear issue-state identifiers that bound the poll source. */
            stateIds?: string[];
            /** @description Deterministic mapping fields for canonical work submission generation. */
            mapping?: components["schemas"]["HostedLinearWorkerMapping"];
            /** @description Optional claim-related configuration that v1 hosted Linear polling allows. */
            claim?: components["schemas"]["HostedLinearWorkerClaim"];
        };
        /**
         * @description Guard condition attached to one specific workstation input.
         * @enum {string}
         */
        InputGuardType: InputGuardType;
        /** @description Guard attached to one specific workstation input. */
        InputGuard: {
            /** @description Guard condition to evaluate for this input-level attachment. */
            type: components["schemas"]["InputGuardType"];
            /** @description For `VISIT_COUNT` guards, the workstation whose visits are counted. */
            workstation?: string;
            /** @description For `VISIT_COUNT` guards, the visit threshold. */
            maxVisits?: number;
            /** @description For `MATCHES_FIELDS` guards, the field-selector configuration used to compare candidate inputs. */
            matchConfig?: components["schemas"]["GuardMatchConfig"];
            /** @description For parent-aware input guards, the parent workType name from another input in the same workstation. */
            parentInput?: string;
            /** @description For `SAME_NAME` and `SAME_TRACE_ID` input guards, the peer input workType name from another input in the same workstation. */
            matchInput?: string;
            /** @description For dynamic fanout input guards, the workstation that spawns the children for count tracking. */
            spawnedBy?: string;
        };
        /**
         * @description Guard condition attached to a workstation as a whole.
         * @enum {string}
         */
        WorkstationGuardType: WorkstationGuardType;
        /** @description Guard attached to a workstation as a whole. */
        WorkstationGuard: {
            /** @description Guard condition to evaluate for this workstation-level attachment. */
            type: components["schemas"]["WorkstationGuardType"];
            /** @description For `VISIT_COUNT` guards, the workstation whose visits are counted. */
            workstation?: string;
            /** @description For `VISIT_COUNT` guards, the fixed visit ceiling. */
            maxVisits?: number;
            /** @description Optional invocation argument whose positive integer value tightens the fixed visit ceiling. */
            maxVisitsArgument?: string;
            /** @description For `MATCHES_FIELDS` guards, the field-selector configuration used to compare candidate inputs. */
            matchConfig?: components["schemas"]["GuardMatchConfig"];
            /** @description For parent-aware input guards, the parent workType name from another input in the same workstation. */
            parentInput?: string;
            /** @description For `SAME_NAME` and `SAME_TRACE_ID` input guards, the peer input workType name from another input in the same workstation. */
            matchInput?: string;
            /** @description For dynamic fanout input guards, the workstation that spawns the children for count tracking. */
            spawnedBy?: string;
        };
        GlobalConfigACPIntegration: {
            /** @description Stable settings-entry identity. This is distinct from the provider name selected by a Worker. */
            id: string;
            /** @description Canonical Providers catalog identity, such as cursor-acp. */
            name: string;
            /**
             * @description ACP transport. P0 supports stdio only.
             * @enum {string}
             */
            transport: GlobalConfigACPIntegrationTransport;
            /** @description Operator-authored ACP launch command preserved as one settings value. It contains no permission or timeout policy. */
            command: string;
        };
        GlobalConfigACPAgentProfile: {
            /** @description Unversioned namespaced Factory target reference, such as factory:@you/factory-builder. Factory Definitions owns enumeration and canonical reference resolution. */
            defaultTarget: string;
            /** @description Ordered allowlist of unversioned namespaced Factory target references. Order is authored and preserved. */
            allowedTargets: string[];
        };
        GlobalConfigACPSettings: {
            /** @description Operator-selected ACP provider integrations. Availability is derived by the Providers catalog and is never persisted here. */
            integrations?: components["schemas"]["GlobalConfigACPIntegration"][];
            agentProfile?: components["schemas"]["GlobalConfigACPAgentProfile"];
        };
        GlobalConfigWorkers: {
            acp?: components["schemas"]["GlobalConfigACPSettings"];
        };
    };
    responses: {
        /** @description Request payload or parameter was invalid. */
        BadRequest: {
            headers: {
                [name: string]: unknown;
            };
            content: {
                "application/json": components["schemas"]["ErrorResponse"];
            };
        };
        /** @description Named factory name or payload was invalid. */
        CreateFactoryBadRequest: {
            headers: {
                [name: string]: unknown;
            };
            content: {
                "application/json": components["schemas"]["ErrorResponse"];
            };
        };
        /** @description Named factory could not be activated because the name already exists or the current runtime is not idle. */
        CreateFactoryConflict: {
            headers: {
                [name: string]: unknown;
            };
            content: {
                "application/json": components["schemas"]["ErrorResponse"];
            };
        };
        /** @description Requested resource was not found. */
        NotFound: {
            headers: {
                [name: string]: unknown;
            };
            content: {
                "application/json": components["schemas"]["ErrorResponse"];
            };
        };
        /** @description Current named factory was not found. */
        CurrentFactoryNotFound: {
            headers: {
                [name: string]: unknown;
            };
            content: {
                "application/json": components["schemas"]["ErrorResponse"];
            };
        };
        /** @description Current factory save request failed validation. */
        SaveCurrentFactoryBadRequest: {
            headers: {
                [name: string]: unknown;
            };
            content: {
                "application/json": components["schemas"]["ErrorResponse"];
            };
        };
        /** @description Current factory could not be saved because the runtime or submitted version is not safe to replace. */
        SaveCurrentFactoryConflict: {
            headers: {
                [name: string]: unknown;
            };
            content: {
                "application/json": components["schemas"]["ErrorResponse"];
            };
        };
        /** @description Operator move request was already applied for the supplied requestId. */
        MoveWorkConflict: {
            headers: {
                [name: string]: unknown;
            };
            content: {
                "application/json": components["schemas"]["ErrorResponse"];
            };
        };
        /** @description The supplied requestId was already used with materially different source, args, orchestrator, or requested policy. */
        ExecutionRequestIdConflict: {
            headers: {
                [name: string]: unknown;
            };
            content: {
                "application/json": components["schemas"]["ErrorResponse"];
            };
        };
        /** @description Lifecycle control request conflicts with current session state, another in-flight control, or a previously applied control requestId. */
        FactorySessionLifecycleControlConflict: {
            headers: {
                [name: string]: unknown;
            };
            content: {
                "application/json": components["schemas"]["FactorySessionLifecycleControlResponse"] | components["schemas"]["ErrorResponse"];
            };
        };
        /** @description Server failed while reading or building runtime state. */
        InternalError: {
            headers: {
                [name: string]: unknown;
            };
            content: {
                "application/json": components["schemas"]["ErrorResponse"];
            };
        };
        /** @description Response-event cursor or filter parameters were invalid. */
        ResponseEventBadRequest: {
            headers: {
                [name: string]: unknown;
            };
            content: {
                "application/json": components["schemas"]["ErrorResponse"];
            };
        };
        /** @description The explicitly selected Factory Session does not exist. Response-event streaming never falls back to the current or default session. */
        ResponseEventSessionNotFound: {
            headers: {
                [name: string]: unknown;
            };
            content: {
                "application/json": components["schemas"]["ErrorResponse"];
            };
        };
        /** @description The retained response-event stream has expired and can no longer be opened. This is distinct from an invalid cursor or filter. */
        ResponseEventStreamExpired: {
            headers: {
                [name: string]: unknown;
            };
            content: {
                "application/json": components["schemas"]["ErrorResponse"];
            };
        };
    };
    parameters: {
        /** @description Stable live factory session identifier. Use `~default` to target the default compatibility session explicitly. */
        SessionID: string;
        /** @description Optional positive page size. Omit to use the default page size; non-positive values fall back to the default after successful integer binding. */
        MaxResults: number;
        /** @description Optional base64-encoded token ID cursor. */
        NextToken: string;
        /** @description Optional current work state name filter. */
        StateName: string;
        /** @description Optional current work state type filter. */
        StateType: components["schemas"]["WorkStateType"];
        /** @description Optional list-work sort field. Use state.type to order by current work state type. */
        SortBy: ComponentsParametersSortBy;
        /** @description Optional work name filter. Matches when the work name contains this value, case-insensitively. */
        WorkListName: string;
        /** @description Optional work type name filter. Matches when workTypeName equals this value exactly. */
        WorkListWorkTypeName: string;
        /** @description Optional trace filter. Matches when traceId or currentChainingTraceId equals this value exactly. */
        WorkListTraceId: string;
        /** @description Work or token identifier, depending on route. */
        WorkOrTokenID: string;
        /** @description Optional session list scope. Defaults to live for backward-compatible live workspace session listing. */
        FactorySessionListScope: components["schemas"]["FactorySessionListScope"];
        /** @description Optional durable result retrieval mode. Defaults to final for terminal outputs. partial returns the latest partial workflow output when available. */
        FactorySessionResultMode: components["schemas"]["FactorySessionResultMode"];
        /** @description When true, include artifact metadata refs for materialized outputs. Defaults to false and may return artifact ids only. */
        FactorySessionResultIncludeArtifacts: boolean;
        /** @description Stable factory-session dispatch identifier. */
        DispatchID: string;
        /** @description Exact canonical phase identifier. Unknown phases return an empty collection. */
        FactoryDispatchPhase: string;
        /** @description Canonical Dispatch lifecycle status. */
        FactoryDispatchStatusFilter: components["schemas"]["FactoryDispatchStatus"];
        /** @description Stable factory-session artifact identifier. */
        ArtifactID: string;
        /** @description Session-scoped reconnect cursor identifying the last acknowledged FactoryEvent.id. The stream replays only events recorded after this stable event identifier. When both after_event_id and after_sequence are present on GET /factory-sessions/{session_id}/events, after_event_id wins. */
        AfterEventId: string;
        /** @description Session-scoped reconnect cursor identifying the last acknowledged ordering point. Session-scoped FactoryEvent streams prefer FactoryEvent.context.sessionSequence when present and otherwise fall back to FactoryEvent.context.sequence. When both after_event_id and after_sequence are present on GET /factory-sessions/{session_id}/events, after_event_id wins. Cursors that no longer match the retained history boundary surface as cursor_stale on JSON reconnect probes or invalid-cursor 400 responses on SSE open. */
        AfterSequence: number;
        /** @description Last acknowledged FactoryResponseEvent.sequence. The stream sends only retained response events with a greater sequence before continuing with live events. Omit this cursor to start at the beginning of retained response-event history. If the cursor predates retained history, the first emitted event is a STREAM_GAP record describing the loss instead of silently skipping it. */
        ResponseEventAfterSequence: number;
        /** @description Return only FactoryResponseEvent records associated with this exact dispatch identifier. Invalid or empty identifiers return the typed bad-request response. */
        ResponseEventDispatchID: string;
        /** @description Return FactoryResponseEvent records matching any requested public kind. The parameter may be repeated, for example kind=MESSAGE&kind=TOOL. Invalid or empty kind values return the typed bad-request response. */
        ResponseEventKind: components["schemas"]["FactoryResponseEventKind"][];
        /** @description Optional backend scope identifier used with logicalSessionKeyId to resolve the current live Factory Session when the requested session selector is missing or stale. When provided, resolution succeeds only when it matches the active backend scope. */
        BackendScopeId: string;
        /** @description Optional canonical logical-session key derived from the normalized factory session target. When the requested session selector is missing or stale, resolution uses backendScopeId plus this key to locate the replacement current live Factory Session. */
        LogicalSessionKeyId: string;
    };
    requestBodies: never;
    headers: never;
    pathItems: never;
}
export type $defs = Record<string, never>;
export interface operations {
    listWorkBySessionId: {
        parameters: {
            query?: {
                /** @description Optional positive page size. Omit to use the default page size; non-positive values fall back to the default after successful integer binding. */
                maxResults?: components["parameters"]["MaxResults"];
                /** @description Optional base64-encoded token ID cursor. */
                nextToken?: components["parameters"]["NextToken"];
                /** @description Optional current work state name filter. */
                "state.name"?: components["parameters"]["StateName"];
                /** @description Optional current work state type filter. */
                "state.type"?: components["parameters"]["StateType"];
                /** @description Optional list-work sort field. Use state.type to order by current work state type. */
                sortBy?: components["parameters"]["SortBy"];
                /** @description Optional work name filter. Matches when the work name contains this value, case-insensitively. */
                name?: components["parameters"]["WorkListName"];
                /** @description Optional work type name filter. Matches when workTypeName equals this value exactly. */
                workTypeName?: components["parameters"]["WorkListWorkTypeName"];
                /** @description Optional trace filter. Matches when traceId or currentChainingTraceId equals this value exactly. */
                traceId?: components["parameters"]["WorkListTraceId"];
            };
            header?: never;
            path: {
                /** @description Stable live factory session identifier. Use `~default` to target the default compatibility session explicitly. */
                session_id: components["parameters"]["SessionID"];
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Current work tokens for the targeted session. */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["ListWorkResponse"];
                };
            };
            404: components["responses"]["NotFound"];
            500: components["responses"]["InternalError"];
        };
    };
    submitWorkBySessionId: {
        parameters: {
            query?: never;
            header?: never;
            path: {
                /** @description Stable live factory session identifier. Use `~default` to target the default compatibility session explicitly. */
                session_id: components["parameters"]["SessionID"];
            };
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["SubmitWorkRequest"];
            };
        };
        responses: {
            /** @description Work was accepted for processing by the targeted session. */
            201: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["SubmitWorkResponse"];
                };
            };
            400: components["responses"]["BadRequest"];
            404: components["responses"]["NotFound"];
            500: components["responses"]["InternalError"];
        };
    };
    invokeFactorySessionBySessionId: {
        parameters: {
            query?: never;
            header?: never;
            path: {
                /** @description Stable live factory session identifier. Use `~default` to target the default compatibility session explicitly. */
                session_id: components["parameters"]["SessionID"];
            };
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["InvocationRequest"];
            };
        };
        responses: {
            /** @description Invocation reached a terminal status for the targeted session. */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["InvocationResponse"];
                };
            };
            400: components["responses"]["BadRequest"];
            404: components["responses"]["NotFound"];
            500: components["responses"]["InternalError"];
        };
    };
    stageSubmitWorkFileBySessionId: {
        parameters: {
            query?: never;
            header?: never;
            path: {
                /** @description Stable live factory session identifier. Use `~default` to target the default compatibility session explicitly. */
                session_id: components["parameters"]["SessionID"];
            };
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["StageSubmitWorkFileRequest"];
            };
        };
        responses: {
            /** @description File payload staged successfully for later session-scoped submit-work use. */
            201: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["StageSubmitWorkFileResponse"];
                };
            };
            400: components["responses"]["BadRequest"];
            404: components["responses"]["NotFound"];
            500: components["responses"]["InternalError"];
        };
    };
    upsertWorkRequestBySessionId: {
        parameters: {
            query?: never;
            header?: never;
            path: {
                /** @description Stable live factory session identifier. Use `~default` to target the default compatibility session explicitly. */
                session_id: components["parameters"]["SessionID"];
                /** @description Stable request identifier used for idempotent submission. */
                request_id: string;
            };
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["WorkRequest"];
            };
        };
        responses: {
            /** @description Work request was accepted or had already been accepted by the targeted session. */
            201: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["UpsertWorkRequestResponse"];
                };
            };
            400: components["responses"]["BadRequest"];
            404: components["responses"]["NotFound"];
            500: components["responses"]["InternalError"];
        };
    };
    getWorkBySessionId: {
        parameters: {
            query?: never;
            header?: never;
            path: {
                /** @description Stable live factory session identifier. Use `~default` to target the default compatibility session explicitly. */
                session_id: components["parameters"]["SessionID"];
                /** @description Work or token identifier, depending on route. */
                id: components["parameters"]["WorkOrTokenID"];
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description One work item for the targeted session. */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Work"];
                };
            };
            404: components["responses"]["NotFound"];
            500: components["responses"]["InternalError"];
        };
    };
    moveWorkBySessionId: {
        parameters: {
            query?: never;
            header?: never;
            path: {
                /** @description Stable live factory session identifier. Use `~default` to target the default compatibility session explicitly. */
                session_id: components["parameters"]["SessionID"];
                /** @description Work or token identifier, depending on route. */
                id: components["parameters"]["WorkOrTokenID"];
            };
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["MoveWorkRequest"];
            };
        };
        responses: {
            /** @description Work item at the new marking position for the targeted session. */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Work"];
                };
            };
            400: components["responses"]["BadRequest"];
            404: components["responses"]["NotFound"];
            409: components["responses"]["MoveWorkConflict"];
            500: components["responses"]["InternalError"];
        };
    };
    getEventsBySessionId: {
        parameters: {
            query?: {
                /** @description Session-scoped reconnect cursor identifying the last acknowledged FactoryEvent.id. The stream replays only events recorded after this stable event identifier. When both after_event_id and after_sequence are present on GET /factory-sessions/{session_id}/events, after_event_id wins. */
                after_event_id?: components["parameters"]["AfterEventId"];
                /** @description Session-scoped reconnect cursor identifying the last acknowledged ordering point. Session-scoped FactoryEvent streams prefer FactoryEvent.context.sessionSequence when present and otherwise fall back to FactoryEvent.context.sequence. When both after_event_id and after_sequence are present on GET /factory-sessions/{session_id}/events, after_event_id wins. Cursors that no longer match the retained history boundary surface as cursor_stale on JSON reconnect probes or invalid-cursor 400 responses on SSE open. */
                after_sequence?: components["parameters"]["AfterSequence"];
            };
            header?: never;
            path: {
                /** @description Stable live factory session identifier. Use `~default` to target the default compatibility session explicitly. */
                session_id: components["parameters"]["SessionID"];
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Retained catch-up in ascending tick order followed by live FactoryEvent records for the targeted session when Accept requests text/event-stream, or a JSON FactorySessionEventStreamRecovery reconnect probe result when Accept includes application/json. Successful SSE responses use Connection keep-alive and may remain idle until the next canonical FactoryEvent is recorded. */
            200: {
                headers: {
                    /** @description Stable backend scope identifier for the current live Factory Session event history. Compare this handshake header with session-sync or preflight `backendScopeId` values before reusing reconnect cursors or stream-derived projections. */
                    "X-Factory-Session-Backend-Scope-Id"?: string;
                    /** @description Stable logical session key for the resolved Factory Session target within the current backend scope. Compare this handshake header with session-sync or preflight `logicalSessionKeyId` values before reusing reconnect cursors or stream-derived projections. */
                    "X-Factory-Session-Logical-Session-Key-Id"?: string;
                    /** @description Resolved UUID Factory Session identifier for the current live event history. Compare this handshake header with session-sync or preflight `factorySessionId` values before reusing reconnect cursors or stream-derived projections. */
                    "X-Factory-Session-Factory-Session-Id"?: string;
                    /** @description Opaque invalidation token for the current live Factory Session event history. Compare this handshake header with session-sync or preflight `streamGenerationID` values before reusing reconnect cursors or stream-derived projections. */
                    "X-Factory-Session-Stream-Generation-Id"?: string;
                    /** @description Count of already-committed canonical FactoryEvent records written as the retained-history prefix before any live event, captured at subscribe time. A bounded reader can read exactly this many leading data frames instead of inferring completion from stream quiescence. */
                    "X-Factory-Session-Retained-Event-Count"?: number;
                    [name: string]: unknown;
                };
                content: {
                    "text/event-stream": string;
                    "application/json": components["schemas"]["FactorySessionEventStreamRecovery"];
                };
            };
            400: components["responses"]["BadRequest"];
            404: components["responses"]["NotFound"];
            500: components["responses"]["InternalError"];
        };
    };
    getFactoryResponseEventsBySessionId: {
        parameters: {
            query?: {
                /** @description Last acknowledged FactoryResponseEvent.sequence. The stream sends only retained response events with a greater sequence before continuing with live events. Omit this cursor to start at the beginning of retained response-event history. If the cursor predates retained history, the first emitted event is a STREAM_GAP record describing the loss instead of silently skipping it. */
                after_sequence?: components["parameters"]["ResponseEventAfterSequence"];
                /** @description Return only FactoryResponseEvent records associated with this exact dispatch identifier. Invalid or empty identifiers return the typed bad-request response. */
                dispatch_id?: components["parameters"]["ResponseEventDispatchID"];
                /** @description Return FactoryResponseEvent records matching any requested public kind. The parameter may be repeated, for example kind=MESSAGE&kind=TOOL. Invalid or empty kind values return the typed bad-request response. */
                kind?: components["parameters"]["ResponseEventKind"];
            };
            header?: never;
            path: {
                /** @description Stable live factory session identifier. Use `~default` to target the default compatibility session explicitly. */
                session_id: components["parameters"]["SessionID"];
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Retained catch-up followed by live Factory Response Event records for the explicitly targeted session. */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "text/event-stream": string;
                };
            };
            400: components["responses"]["ResponseEventBadRequest"];
            404: components["responses"]["ResponseEventSessionNotFound"];
            410: components["responses"]["ResponseEventStreamExpired"];
            500: components["responses"]["InternalError"];
        };
    };
    getFactorySessionSyncPreflightBySessionId: {
        parameters: {
            query?: {
                /** @description Optional backend scope identifier used with logicalSessionKeyId to resolve the current live Factory Session when the requested session selector is missing or stale. When provided, resolution succeeds only when it matches the active backend scope. */
                backend_scope_id?: components["parameters"]["BackendScopeId"];
                /** @description Optional canonical logical-session key derived from the normalized factory session target. When the requested session selector is missing or stale, resolution uses backendScopeId plus this key to locate the replacement current live Factory Session. */
                logical_session_key_id?: components["parameters"]["LogicalSessionKeyId"];
                /** @description Session-scoped reconnect cursor identifying the last acknowledged FactoryEvent.id. The stream replays only events recorded after this stable event identifier. When both after_event_id and after_sequence are present on GET /factory-sessions/{session_id}/events, after_event_id wins. */
                after_event_id?: components["parameters"]["AfterEventId"];
                /** @description Session-scoped reconnect cursor identifying the last acknowledged ordering point. Session-scoped FactoryEvent streams prefer FactoryEvent.context.sessionSequence when present and otherwise fall back to FactoryEvent.context.sequence. When both after_event_id and after_sequence are present on GET /factory-sessions/{session_id}/events, after_event_id wins. Cursors that no longer match the retained history boundary surface as cursor_stale on JSON reconnect probes or invalid-cursor 400 responses on SSE open. */
                after_sequence?: components["parameters"]["AfterSequence"];
            };
            header?: never;
            path: {
                /** @description Stable live factory session identifier. Use `~default` to target the default compatibility session explicitly. */
                session_id: components["parameters"]["SessionID"];
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Typed session sync preflight outcome for the targeted session selector. */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["FactorySessionSyncPreflightResponse"];
                };
            };
            500: components["responses"]["InternalError"];
        };
    };
    getStatus: {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Current runtime status summary. */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["StatusResponse"];
                };
            };
            500: components["responses"]["InternalError"];
        };
    };
    listModels: {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Managed runtimes for the current runtime. */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["ListModelsResponse"];
                };
            };
            500: components["responses"]["InternalError"];
        };
    };
    getModel: {
        parameters: {
            query?: never;
            header?: never;
            path: {
                /** @description Stable managed runtime identity such as `OMNIVOICE_Q4_K_M`. */
                model_name: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Managed runtime detail. */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["ModelDetail"];
                };
            };
            404: components["responses"]["NotFound"];
            500: components["responses"]["InternalError"];
        };
    };
    invokeModel: {
        parameters: {
            query?: never;
            header?: never;
            path: {
                /** @description Concrete public model identifier such as `OMNIVOICE_Q4_K_M`. */
                model_name: string;
            };
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["ModelInvocationRequest"];
            };
        };
        responses: {
            /** @description Successful model invocation result. */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["ModelInvocationResponse"];
                    "application/octet-stream": string;
                };
            };
            400: components["responses"]["BadRequest"];
            404: components["responses"]["NotFound"];
            500: components["responses"]["InternalError"];
        };
    };
    pullModel: {
        parameters: {
            query?: never;
            header?: never;
            path: {
                /** @description Stable managed runtime identity such as `OMNIVOICE_Q4_K_M`. */
                model_name: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Successful managed runtime pull or install, or confirmation that the managed cache already contained the required revision. */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["ModelPullResponse"];
                };
            };
            400: components["responses"]["BadRequest"];
            404: components["responses"]["NotFound"];
            500: components["responses"]["InternalError"];
        };
    };
    getStatusBySessionId: {
        parameters: {
            query?: never;
            header?: never;
            path: {
                /** @description Stable live factory session identifier. Use `~default` to target the default compatibility session explicitly. */
                session_id: components["parameters"]["SessionID"];
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Current runtime status summary for the targeted session. */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["StatusResponse"];
                };
            };
            404: components["responses"]["NotFound"];
            500: components["responses"]["InternalError"];
        };
    };
    getProviderSessionDetails: {
        parameters: {
            query: {
                /** @description Provider that emitted the session identifier. Only codex sessions are currently loadable. */
                provider: components["schemas"]["LoadableProviderSessionProvider"];
                /** @description Provider-session identifier kind. Only session_id is currently loadable. */
                kind: components["schemas"]["LoadableProviderSessionKind"];
                /** @description Provider-session identifier to resolve. This is an identifier, not a filesystem path. */
                id: string;
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Parsed provider-session details. */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["ProviderSessionDetailResponse"];
                };
            };
            400: components["responses"]["BadRequest"];
            404: components["responses"]["NotFound"];
            500: components["responses"]["InternalError"];
        };
    };
    previewFactory: {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["FactoryPreviewRequest"];
            };
        };
        responses: {
            /** @description Factory preview validation, source resolution, and policy projection. */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["FactoryPreviewResult"];
                };
            };
            400: components["responses"]["BadRequest"];
            500: components["responses"]["InternalError"];
        };
    };
    validateFactory: {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["Factory"];
            };
        };
        responses: {
            /** @description Validation result for the submitted factory definition. */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["FactoryValidationResult"];
                };
            };
            400: components["responses"]["BadRequest"];
            500: components["responses"]["InternalError"];
        };
    };
    startDurableFactorySessionAsync: {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["FactorySessionExecutionRequest"];
            };
        };
        responses: {
            /** @description Durable session execution was accepted. */
            202: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["FactorySessionExecutionResponse"];
                };
            };
            400: components["responses"]["BadRequest"];
            409: components["responses"]["ExecutionRequestIdConflict"];
            500: components["responses"]["InternalError"];
        };
    };
    startDurableFactorySessionSync: {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["FactorySessionExecutionRequest"];
            };
        };
        responses: {
            /** @description Sync durable execution completed, timed out, or returned while still running. */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["FactorySessionSyncExecutionResponse"];
                };
            };
            400: components["responses"]["BadRequest"];
            409: components["responses"]["ExecutionRequestIdConflict"];
            500: components["responses"]["InternalError"];
        };
    };
    listFactorySessions: {
        parameters: {
            query?: {
                /** @description Optional session list scope. Defaults to live for backward-compatible live workspace session listing. */
                scope?: components["parameters"]["FactorySessionListScope"];
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Factory session summaries for the requested scope. */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["ListFactorySessionsResponse"];
                };
            };
            400: components["responses"]["BadRequest"];
            500: components["responses"]["InternalError"];
        };
    };
    openFactorySession: {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["OpenFactorySessionRequest"];
            };
        };
        responses: {
            /** @description Session was opened or the caller needs to choose one of the returned runnable targets. */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["OpenFactorySessionResponse"];
                };
            };
            400: components["responses"]["BadRequest"];
            500: components["responses"]["InternalError"];
        };
    };
    getFactorySessionResult: {
        parameters: {
            query?: never;
            header?: never;
            path: {
                /** @description Stable live factory session identifier. Use `~default` to target the default compatibility session explicitly. */
                session_id: components["parameters"]["SessionID"];
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Terminal session result projection for the targeted live session. */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["FactorySessionLiveResult"];
                };
            };
            404: components["responses"]["NotFound"];
            500: components["responses"]["InternalError"];
        };
    };
    getFactorySessionResults: {
        parameters: {
            query?: {
                /** @description Optional durable result retrieval mode. Defaults to final for terminal outputs. partial returns the latest partial workflow output when available. */
                mode?: components["parameters"]["FactorySessionResultMode"];
                /** @description When true, include artifact metadata refs for materialized outputs. Defaults to false and may return artifact ids only. */
                includeArtifacts?: components["parameters"]["FactorySessionResultIncludeArtifacts"];
            };
            header?: never;
            path: {
                /** @description Stable live factory session identifier. Use `~default` to target the default compatibility session explicitly. */
                session_id: components["parameters"]["SessionID"];
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Durable session result retrieval response. */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["FactorySessionResult"];
                };
            };
            404: components["responses"]["NotFound"];
            500: components["responses"]["InternalError"];
        };
    };
    listFactorySessionDispatches: {
        parameters: {
            query?: {
                /** @description Exact canonical phase identifier. Unknown phases return an empty collection. */
                phase?: components["parameters"]["FactoryDispatchPhase"];
                /** @description Canonical Dispatch lifecycle status. */
                status?: components["parameters"]["FactoryDispatchStatusFilter"];
            };
            header?: never;
            path: {
                /** @description Stable live factory session identifier. Use `~default` to target the default compatibility session explicitly. */
                session_id: components["parameters"]["SessionID"];
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Dispatch summaries for the targeted session. */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["ListFactorySessionDispatchesResponse"];
                };
            };
            400: components["responses"]["BadRequest"];
            404: components["responses"]["NotFound"];
            500: components["responses"]["InternalError"];
        };
    };
    getFactorySessionDispatch: {
        parameters: {
            query?: never;
            header?: never;
            path: {
                /** @description Stable live factory session identifier. Use `~default` to target the default compatibility session explicitly. */
                session_id: components["parameters"]["SessionID"];
                /** @description Stable factory-session dispatch identifier. */
                dispatch_id: components["parameters"]["DispatchID"];
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Dispatch detail for the targeted session and dispatch id. */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["FactoryDispatch"];
                };
            };
            404: components["responses"]["NotFound"];
            500: components["responses"]["InternalError"];
        };
    };
    listFactorySessionArtifacts: {
        parameters: {
            query?: never;
            header?: never;
            path: {
                /** @description Stable live factory session identifier. Use `~default` to target the default compatibility session explicitly. */
                session_id: components["parameters"]["SessionID"];
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Artifact metadata rows for the targeted session. */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["ListFactorySessionArtifactsResponse"];
                };
            };
            404: components["responses"]["NotFound"];
            500: components["responses"]["InternalError"];
        };
    };
    getFactorySessionArtifact: {
        parameters: {
            query?: never;
            header?: never;
            path: {
                /** @description Stable live factory session identifier. Use `~default` to target the default compatibility session explicitly. */
                session_id: components["parameters"]["SessionID"];
                /** @description Stable factory-session artifact identifier. */
                artifact_id: components["parameters"]["ArtifactID"];
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Artifact detail for the targeted session and artifact id. */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["FactorySessionArtifactDetail"];
                };
            };
            404: components["responses"]["NotFound"];
            500: components["responses"]["InternalError"];
        };
    };
    approveFactorySession: {
        parameters: {
            query?: never;
            header?: never;
            path: {
                /** @description Stable live factory session identifier. Use `~default` to target the default compatibility session explicitly. */
                session_id: components["parameters"]["SessionID"];
            };
            cookie?: never;
        };
        requestBody?: {
            content: {
                "application/json": components["schemas"]["FactorySessionApproveRequest"];
            };
        };
        responses: {
            /** @description Approval applied immediately or the session already satisfied the request. */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["FactorySessionLifecycleControlResponse"];
                };
            };
            /** @description Approval control request accepted asynchronously. */
            202: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["FactorySessionLifecycleControlResponse"];
                };
            };
            400: components["responses"]["BadRequest"];
            404: components["responses"]["NotFound"];
            409: components["responses"]["FactorySessionLifecycleControlConflict"];
            500: components["responses"]["InternalError"];
        };
    };
    pauseFactorySession: {
        parameters: {
            query?: never;
            header?: never;
            path: {
                /** @description Stable live factory session identifier. Use `~default` to target the default compatibility session explicitly. */
                session_id: components["parameters"]["SessionID"];
            };
            cookie?: never;
        };
        requestBody?: {
            content: {
                "application/json": components["schemas"]["FactorySessionLifecycleControlRequest"];
            };
        };
        responses: {
            /** @description Pause applied immediately or the session was already paused. */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["FactorySessionLifecycleControlResponse"];
                };
            };
            /** @description Pause control request accepted asynchronously. */
            202: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["FactorySessionLifecycleControlResponse"];
                };
            };
            400: components["responses"]["BadRequest"];
            404: components["responses"]["NotFound"];
            409: components["responses"]["FactorySessionLifecycleControlConflict"];
            500: components["responses"]["InternalError"];
        };
    };
    resumeFactorySession: {
        parameters: {
            query?: never;
            header?: never;
            path: {
                /** @description Stable live factory session identifier. Use `~default` to target the default compatibility session explicitly. */
                session_id: components["parameters"]["SessionID"];
            };
            cookie?: never;
        };
        requestBody?: {
            content: {
                "application/json": components["schemas"]["FactorySessionLifecycleControlRequest"];
            };
        };
        responses: {
            /** @description Resume applied immediately or the session was already running. */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["FactorySessionLifecycleControlResponse"];
                };
            };
            /** @description Resume control request accepted asynchronously. */
            202: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["FactorySessionLifecycleControlResponse"];
                };
            };
            400: components["responses"]["BadRequest"];
            404: components["responses"]["NotFound"];
            409: components["responses"]["FactorySessionLifecycleControlConflict"];
            500: components["responses"]["InternalError"];
        };
    };
    cancelFactorySession: {
        parameters: {
            query?: never;
            header?: never;
            path: {
                /** @description Stable live factory session identifier. Use `~default` to target the default compatibility session explicitly. */
                session_id: components["parameters"]["SessionID"];
            };
            cookie?: never;
        };
        requestBody?: {
            content: {
                "application/json": components["schemas"]["FactorySessionLifecycleControlRequest"];
            };
        };
        responses: {
            /** @description Cancel applied immediately or the session was already canceled. */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["FactorySessionLifecycleControlResponse"];
                };
            };
            /** @description Cancel control request accepted asynchronously. */
            202: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["FactorySessionLifecycleControlResponse"];
                };
            };
            400: components["responses"]["BadRequest"];
            404: components["responses"]["NotFound"];
            409: components["responses"]["FactorySessionLifecycleControlConflict"];
            500: components["responses"]["InternalError"];
        };
    };
    terminateFactorySession: {
        parameters: {
            query?: never;
            header?: never;
            path: {
                /** @description Stable live factory session identifier. Use `~default` to target the default compatibility session explicitly. */
                session_id: components["parameters"]["SessionID"];
            };
            cookie?: never;
        };
        requestBody?: {
            content: {
                "application/json": components["schemas"]["FactorySessionLifecycleControlRequest"];
            };
        };
        responses: {
            /** @description Termination applied immediately or the session was already terminal. */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["FactorySessionLifecycleControlResponse"];
                };
            };
            /** @description Terminate control request accepted asynchronously. */
            202: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["FactorySessionLifecycleControlResponse"];
                };
            };
            400: components["responses"]["BadRequest"];
            404: components["responses"]["NotFound"];
            409: components["responses"]["FactorySessionLifecycleControlConflict"];
            500: components["responses"]["InternalError"];
        };
    };
    retryFactorySessionDispatch: {
        parameters: {
            query?: never;
            header?: never;
            path: {
                /** @description Stable live factory session identifier. Use `~default` to target the default compatibility session explicitly. */
                session_id: components["parameters"]["SessionID"];
            };
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["FactorySessionRetryDispatchRequest"];
            };
        };
        responses: {
            /** @description Retry dispatch applied immediately or produced a typed no-op outcome. */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["FactorySessionLifecycleControlResponse"];
                };
            };
            /** @description Retry-dispatch control request accepted asynchronously. */
            202: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["FactorySessionLifecycleControlResponse"];
                };
            };
            400: components["responses"]["BadRequest"];
            404: components["responses"]["NotFound"];
            409: components["responses"]["FactorySessionLifecycleControlConflict"];
            500: components["responses"]["InternalError"];
        };
    };
    interruptFactorySessionDispatch: {
        parameters: {
            query?: never;
            header?: never;
            path: {
                /** @description Stable live factory session identifier. Use `~default` to target the default compatibility session explicitly. */
                session_id: components["parameters"]["SessionID"];
            };
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["FactorySessionInterruptDispatchRequest"];
            };
        };
        responses: {
            /** @description Interrupt dispatch applied immediately or produced a typed no-op outcome. */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["FactorySessionLifecycleControlResponse"];
                };
            };
            /** @description Interrupt-dispatch control request accepted asynchronously. */
            202: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["FactorySessionLifecycleControlResponse"];
                };
            };
            400: components["responses"]["BadRequest"];
            404: components["responses"]["NotFound"];
            409: components["responses"]["FactorySessionLifecycleControlConflict"];
            500: components["responses"]["InternalError"];
        };
    };
    getFactorySessionPartialResult: {
        parameters: {
            query?: never;
            header?: never;
            path: {
                /** @description Stable live factory session identifier. Use `~default` to target the default compatibility session explicitly. */
                session_id: components["parameters"]["SessionID"];
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Partial session result projection for the targeted live session. */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["FactorySessionPartialResult"];
                };
            };
            404: components["responses"]["NotFound"];
            500: components["responses"]["InternalError"];
        };
    };
    getFactorySession: {
        parameters: {
            query?: never;
            header?: never;
            path: {
                /** @description Stable live factory session identifier. Use `~default` to target the default compatibility session explicitly. */
                session_id: components["parameters"]["SessionID"];
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Canonical factory session inspection read model for the targeted session. */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["FactorySessionGetResponse"];
                };
            };
            404: components["responses"]["NotFound"];
            500: components["responses"]["InternalError"];
        };
    };
    closeFactorySession: {
        parameters: {
            query?: never;
            header?: never;
            path: {
                /** @description Stable live factory session identifier. Use `~default` to close the default compatibility session explicitly. */
                session_id: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Session was stopped and removed from the live workspace. */
            204: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
            404: components["responses"]["NotFound"];
            500: components["responses"]["InternalError"];
        };
    };
    getCurrentFactoryBySessionId: {
        parameters: {
            query?: never;
            header?: never;
            path: {
                /** @description Stable live factory session identifier. Use `~default` to target the default compatibility session explicitly. */
                session_id: components["parameters"]["SessionID"];
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Current active factory definition and version metadata for the targeted session, or the active default root runtime when the default session has no durable current-factory pointer yet. Default-runtime responses use the reserved `UNDEFINED` identifier in `Factory.name`. */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Factory"];
                };
            };
            404: components["responses"]["NotFound"];
            500: components["responses"]["InternalError"];
        };
    };
    saveCurrentFactoryBySessionId: {
        parameters: {
            query?: never;
            header?: never;
            path: {
                /** @description Stable live factory session identifier. Use `~default` to target the default compatibility session explicitly. */
                session_id: components["parameters"]["SessionID"];
            };
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["SaveFactoryForSessionRequest"];
            };
        };
        responses: {
            /** @description Saved current factory definition and new version metadata for the targeted session. */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Factory"];
                };
            };
            400: components["responses"]["SaveCurrentFactoryBadRequest"];
            404: components["responses"]["NotFound"];
            409: components["responses"]["SaveCurrentFactoryConflict"];
            500: components["responses"]["InternalError"];
        };
    };
    getCurrentFactoryWorkstationPromptTemplateContractBySessionId: {
        parameters: {
            query?: never;
            header?: never;
            path: {
                /** @description Stable live factory session identifier. Use `~default` to target the default compatibility session explicitly. */
                session_id: components["parameters"]["SessionID"];
                /** @description Customer-authored workstation name to inspect in the current factory. */
                workstation_name: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Prompt-template contract for the selected workstation editing context. */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["PromptTemplateContract"];
                };
            };
            404: components["responses"]["CurrentFactoryNotFound"];
            500: components["responses"]["InternalError"];
        };
    };
    validateCurrentFactoryWorkstationPromptTemplateBySessionId: {
        parameters: {
            query?: never;
            header?: never;
            path: {
                /** @description Stable live factory session identifier. Use `~default` to target the default compatibility session explicitly. */
                session_id: components["parameters"]["SessionID"];
                /** @description Customer-authored workstation name to validate against in the current factory. */
                workstation_name: string;
            };
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["PromptTemplateValidationRequest"];
            };
        };
        responses: {
            /** @description Prompt validation result for the selected workstation editing context. */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["PromptTemplateValidationResult"];
                };
            };
            404: components["responses"]["CurrentFactoryNotFound"];
            500: components["responses"]["InternalError"];
        };
    };
    listPackagedFactories: {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Published packaged factory catalog. */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["PackagedFactoryCatalogResponse"];
                };
            };
            500: components["responses"]["InternalError"];
        };
    };
}
export declare const InvocationInputSourceKind: {
    readonly InvocationInputSourceKindText: "text";
    readonly InvocationInputSourceKindFileRef: "fileRef";
    readonly InvocationInputSourceKindAudioStream: "audioStream";
};
export type InvocationInputSourceKind = (typeof InvocationInputSourceKind)[keyof typeof InvocationInputSourceKind];
export declare const InvocationResponseErrorCode: {
    readonly INVOCATION_BLOCKED: "INVOCATION_BLOCKED";
    readonly INVOCATION_INTERRUPTED: "INVOCATION_INTERRUPTED";
    readonly INVOCATION_NEEDS_HUMAN: "INVOCATION_NEEDS_HUMAN";
    readonly INVOCATION_PAUSED: "INVOCATION_PAUSED";
    readonly INVOCATION_PRIMARY_RESULT_UNRESOLVED: "INVOCATION_PRIMARY_RESULT_UNRESOLVED";
    readonly INVOCATION_TIMED_OUT: "INVOCATION_TIMED_OUT";
    readonly INVOCATION_CANCELED: "INVOCATION_CANCELED";
    readonly INVOCATION_RUNTIME_FAILURE: "INVOCATION_RUNTIME_FAILURE";
    readonly INVOCATION_TTS_MODEL_NOT_READY: "INVOCATION_TTS_MODEL_NOT_READY";
    readonly INVOCATION_TTS_GENERATION_FAILED: "INVOCATION_TTS_GENERATION_FAILED";
};
export type InvocationResponseErrorCode = (typeof InvocationResponseErrorCode)[keyof typeof InvocationResponseErrorCode];
export declare const InvocationTerminalStatus: {
    readonly InvocationTerminalStatusCompleted: "COMPLETED";
    readonly InvocationTerminalStatusFailed: "FAILED";
    readonly InvocationTerminalStatusCanceled: "CANCELED";
    readonly InvocationTerminalStatusTimedOut: "TIMED_OUT";
};
export type InvocationTerminalStatus = (typeof InvocationTerminalStatus)[keyof typeof InvocationTerminalStatus];
export declare const SubmitWorkItemType: {
    readonly SubmitWorkItemTypeText: "text";
    readonly SubmitWorkItemTypeImage: "image";
    readonly SubmitWorkItemTypeVideo: "video";
    readonly SubmitWorkItemTypeAudio: "audio";
    readonly SubmitWorkItemTypeDocument: "document";
};
export type SubmitWorkItemType = (typeof SubmitWorkItemType)[keyof typeof SubmitWorkItemType];
export declare const SubmitWorkTextItemType: {
    readonly text: "text";
};
export type SubmitWorkTextItemType = (typeof SubmitWorkTextItemType)[keyof typeof SubmitWorkTextItemType];
export declare const SubmitWorkImageItemType: {
    readonly image: "image";
};
export type SubmitWorkImageItemType = (typeof SubmitWorkImageItemType)[keyof typeof SubmitWorkImageItemType];
export declare const SubmitWorkVideoItemType: {
    readonly video: "video";
};
export type SubmitWorkVideoItemType = (typeof SubmitWorkVideoItemType)[keyof typeof SubmitWorkVideoItemType];
export declare const SubmitWorkAudioItemType: {
    readonly audio: "audio";
};
export type SubmitWorkAudioItemType = (typeof SubmitWorkAudioItemType)[keyof typeof SubmitWorkAudioItemType];
export declare const SubmitWorkDocumentItemType: {
    readonly document: "document";
};
export type SubmitWorkDocumentItemType = (typeof SubmitWorkDocumentItemType)[keyof typeof SubmitWorkDocumentItemType];
export declare const ManagedRuntimeLifecycleState: {
    readonly NOT_APPLICABLE: "NOT_APPLICABLE";
    readonly NOT_INSTALLED: "NOT_INSTALLED";
    readonly INSTALLING: "INSTALLING";
    readonly INSTALLED: "INSTALLED";
    readonly LOADING: "LOADING";
    readonly LOADED: "LOADED";
};
export type ManagedRuntimeLifecycleState = (typeof ManagedRuntimeLifecycleState)[keyof typeof ManagedRuntimeLifecycleState];
export declare const ManagedRuntimePullOutcome: {
    readonly ALREADY_READY: "ALREADY_READY";
    readonly INSTALLED_SUCCESSFULLY: "INSTALLED_SUCCESSFULLY";
    readonly ALREADY_PRESENT: "ALREADY_PRESENT";
    readonly STILL_LOADING: "STILL_LOADING";
    readonly TIMED_OUT: "TIMED_OUT";
    readonly SOURCE_FETCH_FAILED: "SOURCE_FETCH_FAILED";
    readonly UNSUPPORTED_RUNTIME: "UNSUPPORTED_RUNTIME";
};
export type ManagedRuntimePullOutcome = (typeof ManagedRuntimePullOutcome)[keyof typeof ManagedRuntimePullOutcome];
export declare const ManagedRuntimeReadinessState: {
    readonly READY: "READY";
    readonly MISSING: "MISSING";
    readonly LOADING: "LOADING";
    readonly FAILED: "FAILED";
    readonly UNSUPPORTED: "UNSUPPORTED";
};
export type ManagedRuntimeReadinessState = (typeof ManagedRuntimeReadinessState)[keyof typeof ManagedRuntimeReadinessState];
export declare const ModelInvocationResponseMode: {
    readonly METADATA: "METADATA";
    readonly AUDIO_STREAM: "AUDIO_STREAM";
};
export type ModelInvocationResponseMode = (typeof ModelInvocationResponseMode)[keyof typeof ModelInvocationResponseMode];
export declare const ModelPullOutcome: {
    readonly PULLED: "PULLED";
    readonly ALREADY_PRESENT: "ALREADY_PRESENT";
};
export type ModelPullOutcome = (typeof ModelPullOutcome)[keyof typeof ModelPullOutcome];
export declare const ResolvedModelOperationBindingSource: {
    readonly INPUT: "INPUT";
    readonly CONFIG: "CONFIG";
    readonly DEFAULT: "DEFAULT";
    readonly OMITTED: "OMITTED";
};
export type ResolvedModelOperationBindingSource = (typeof ResolvedModelOperationBindingSource)[keyof typeof ResolvedModelOperationBindingSource];
export declare const ModelStatus: {
    readonly READY: "READY";
    readonly UNAVAILABLE: "UNAVAILABLE";
};
export type ModelStatus = (typeof ModelStatus)[keyof typeof ModelStatus];
export declare const ModelLoadState: {
    readonly UNLOADED: "UNLOADED";
    readonly NOT_APPLICABLE: "NOT_APPLICABLE";
};
export type ModelLoadState = (typeof ModelLoadState)[keyof typeof ModelLoadState];
export declare const ErrorFamily: {
    readonly ErrorFamilyBadRequest: "BAD_REQUEST";
    readonly ErrorFamilyConflict: "CONFLICT";
    readonly ErrorFamilyNotFound: "NOT_FOUND";
    readonly ErrorFamilyGone: "GONE";
    readonly ErrorFamilyInternalServerError: "INTERNAL_SERVER_ERROR";
};
export type ErrorFamily = (typeof ErrorFamily)[keyof typeof ErrorFamily];
export declare const ErrorResponseCode: {
    readonly BAD_REQUEST: "BAD_REQUEST";
    readonly FACTORY_SESSION_CONFIG_LOAD_FAILED: "FACTORY_SESSION_CONFIG_LOAD_FAILED";
    readonly INVALID_FACTORY_NAME: "INVALID_FACTORY_NAME";
    readonly FACTORY_ALREADY_EXISTS: "FACTORY_ALREADY_EXISTS";
    readonly INVALID_FACTORY: "INVALID_FACTORY";
    readonly FACTORY_NOT_IDLE: "FACTORY_NOT_IDLE";
    readonly STALE_FACTORY_VERSION: "STALE_FACTORY_VERSION";
    readonly MOVE_WORK_REQUEST_ALREADY_APPLIED: "MOVE_WORK_REQUEST_ALREADY_APPLIED";
    readonly METHOD_NOT_ALLOWED: "METHOD_NOT_ALLOWED";
    readonly EXECUTION_REQUEST_ID_CONFLICT: "EXECUTION_REQUEST_ID_CONFLICT";
    readonly FACTORY_SESSION_CONTROL_REQUEST_ALREADY_APPLIED: "FACTORY_SESSION_CONTROL_REQUEST_ALREADY_APPLIED";
    readonly INVALID_RESPONSE_EVENT_CURSOR: "INVALID_RESPONSE_EVENT_CURSOR";
    readonly INVALID_RESPONSE_EVENT_FILTER: "INVALID_RESPONSE_EVENT_FILTER";
    readonly RESPONSE_EVENT_SESSION_NOT_FOUND: "RESPONSE_EVENT_SESSION_NOT_FOUND";
    readonly RESPONSE_EVENT_STREAM_EXPIRED: "RESPONSE_EVENT_STREAM_EXPIRED";
    readonly NOT_FOUND: "NOT_FOUND";
    readonly INTERNAL_ERROR: "INTERNAL_ERROR";
};
export type ErrorResponseCode = (typeof ErrorResponseCode)[keyof typeof ErrorResponseCode];
export declare const FactorySessionTargetRefKind: {
    readonly default: "default";
    readonly named: "named";
};
export type FactorySessionTargetRefKind = (typeof FactorySessionTargetRefKind)[keyof typeof FactorySessionTargetRefKind];
export declare const FactoryStopKind: {
    readonly PAUSED: "PAUSED";
    readonly BLOCKED: "BLOCKED";
    readonly NEEDS_HUMAN: "NEEDS_HUMAN";
    readonly INTERRUPTED: "INTERRUPTED";
};
export type FactoryStopKind = (typeof FactoryStopKind)[keyof typeof FactoryStopKind];
export declare const FactorySessionLogicalTargetKind: {
    readonly default: "default";
    readonly named: "named";
    readonly provider: "provider";
};
export type FactorySessionLogicalTargetKind = (typeof FactorySessionLogicalTargetKind)[keyof typeof FactorySessionLogicalTargetKind];
export declare const FactorySessionStatus: {
    readonly ACTIVE: "ACTIVE";
    readonly IDLE: "IDLE";
    readonly FINISHED: "FINISHED";
};
export type FactorySessionStatus = (typeof FactorySessionStatus)[keyof typeof FactorySessionStatus];
export declare const FactorySessionJavaScriptScriptStatus: {
    readonly IDLE: "IDLE";
    readonly RUNNING: "RUNNING";
    readonly PAUSED: "PAUSED";
    readonly FINISHED: "FINISHED";
    readonly FAILED: "FAILED";
};
export type FactorySessionJavaScriptScriptStatus = (typeof FactorySessionJavaScriptScriptStatus)[keyof typeof FactorySessionJavaScriptScriptStatus];
export declare const FactorySessionSyncPreflightReasonCode: {
    readonly ok: "ok";
    readonly cursor_stale: "cursor_stale";
    readonly session_not_found: "session_not_found";
    readonly logical_session_remap: "logical_session_remap";
    readonly invalid_target_reference: "invalid_target_reference";
    readonly logical_session_unresolved: "logical_session_unresolved";
};
export type FactorySessionSyncPreflightReasonCode = (typeof FactorySessionSyncPreflightReasonCode)[keyof typeof FactorySessionSyncPreflightReasonCode];
export declare const FactorySessionResultMode: {
    readonly FactorySessionResultModeFinal: "final";
    readonly FactorySessionResultModePartial: "partial";
};
export type FactorySessionResultMode = (typeof FactorySessionResultMode)[keyof typeof FactorySessionResultMode];
export declare const FactorySessionArtifactRetrievalRefMethod: {
    readonly GET: "GET";
};
export type FactorySessionArtifactRetrievalRefMethod = (typeof FactorySessionArtifactRetrievalRefMethod)[keyof typeof FactorySessionArtifactRetrievalRefMethod];
export declare const FactoryDispatchKind: {
    readonly FactoryDispatchKindPETRITRANSITION: "PETRI_TRANSITION";
    readonly FactoryDispatchKindJAVASCRIPTAGENT: "JAVASCRIPT_AGENT";
    readonly FactoryDispatchKindJAVASCRIPTVERIFY: "JAVASCRIPT_VERIFY";
    readonly FactoryDispatchKindJAVASCRIPTSYNTHESIZE: "JAVASCRIPT_SYNTHESIZE";
    readonly FactoryDispatchKindJAVASCRIPTTOOL: "JAVASCRIPT_TOOL";
    readonly FactoryDispatchKindJAVASCRIPTSCRIPT: "JAVASCRIPT_SCRIPT";
    readonly FactoryDispatchKindJAVASCRIPTSYSTEM: "JAVASCRIPT_SYSTEM";
};
export type FactoryDispatchKind = (typeof FactoryDispatchKind)[keyof typeof FactoryDispatchKind];
export declare const FactoryDispatchStatus: {
    readonly FactoryDispatchStatusQUEUED: "QUEUED";
    readonly FactoryDispatchStatusRUNNING: "RUNNING";
    readonly FactoryDispatchStatusCOMPLETED: "COMPLETED";
    readonly FactoryDispatchStatusFAILED: "FAILED";
    readonly FactoryDispatchStatusINTERRUPTED: "INTERRUPTED";
};
export type FactoryDispatchStatus = (typeof FactoryDispatchStatus)[keyof typeof FactoryDispatchStatus];
export declare const FactoryDispatchJavaScriptTaskKind: {
    readonly FactoryDispatchJavaScriptTaskKindAGENT: "AGENT";
    readonly FactoryDispatchJavaScriptTaskKindVERIFY: "VERIFY";
    readonly FactoryDispatchJavaScriptTaskKindSYNTHESIZE: "SYNTHESIZE";
    readonly FactoryDispatchJavaScriptTaskKindTOOL: "TOOL";
    readonly FactoryDispatchJavaScriptTaskKindSCRIPT: "SCRIPT";
    readonly FactoryDispatchJavaScriptTaskKindSYSTEM: "SYSTEM";
};
export type FactoryDispatchJavaScriptTaskKind = (typeof FactoryDispatchJavaScriptTaskKind)[keyof typeof FactoryDispatchJavaScriptTaskKind];
export declare const FactoryArtifactKind: {
    readonly FactoryArtifactKindFINALRESULT: "FINAL_RESULT";
    readonly FactoryArtifactKindCHILDRESULT: "CHILD_RESULT";
    readonly FactoryArtifactKindFINDING: "FINDING";
    readonly FactoryArtifactKindPATCH: "PATCH";
    readonly FactoryArtifactKindLOG: "LOG";
    readonly FactoryArtifactKindDATASET: "DATASET";
    readonly FactoryArtifactKindCHECKPOINT: "CHECKPOINT";
    readonly FactoryArtifactKindWORKTREESUMMARY: "WORKTREE_SUMMARY";
};
export type FactoryArtifactKind = (typeof FactoryArtifactKind)[keyof typeof FactoryArtifactKind];
export declare const FactoryArtifactVisibility: {
    readonly FactoryArtifactVisibilityPUBLIC: "PUBLIC";
    readonly FactoryArtifactVisibilityINTERNALCHECKPOINT: "INTERNAL_CHECKPOINT";
};
export type FactoryArtifactVisibility = (typeof FactoryArtifactVisibility)[keyof typeof FactoryArtifactVisibility];
export declare const FactoryArtifactAuditMode: {
    readonly FactoryArtifactAuditModeNONE: "NONE";
    readonly FactoryArtifactAuditModeREDACTED: "REDACTED";
    readonly FactoryArtifactAuditModeFULL: "FULL";
};
export type FactoryArtifactAuditMode = (typeof FactoryArtifactAuditMode)[keyof typeof FactoryArtifactAuditMode];
export declare const FactoryEventSessionResultStatus: {
    readonly FactoryEventSessionResultStatusNotReady: "NOT_READY";
    readonly FactoryEventSessionResultStatusPartial: "PARTIAL";
    readonly FactoryEventSessionResultStatusFinal: "FINAL";
    readonly FactoryEventSessionResultStatusFailedWithPartial: "FAILED_WITH_PARTIAL";
    readonly FactoryEventSessionResultStatusUnavailable: "UNAVAILABLE";
};
export type FactoryEventSessionResultStatus = (typeof FactoryEventSessionResultStatus)[keyof typeof FactoryEventSessionResultStatus];
export declare const OrchestratorPhaseStatus: {
    readonly ACTIVE: "ACTIVE";
    readonly COMPLETED: "COMPLETED";
    readonly SKIPPED: "SKIPPED";
};
export type OrchestratorPhaseStatus = (typeof OrchestratorPhaseStatus)[keyof typeof OrchestratorPhaseStatus];
export declare const CheckpointResumabilityStatus: {
    readonly RESUMABLE: "RESUMABLE";
    readonly NOT_RESUMABLE: "NOT_RESUMABLE";
    readonly UNKNOWN: "UNKNOWN";
};
export type CheckpointResumabilityStatus = (typeof CheckpointResumabilityStatus)[keyof typeof CheckpointResumabilityStatus];
export declare const DispatchReconciliationSource: {
    readonly STREAM_REPLAY: "STREAM_REPLAY";
    readonly PROVIDER_SESSION: "PROVIDER_SESSION";
    readonly DURABLE_STATE: "DURABLE_STATE";
    readonly RUNTIME_RECONCILER: "RUNTIME_RECONCILER";
};
export type DispatchReconciliationSource = (typeof DispatchReconciliationSource)[keyof typeof DispatchReconciliationSource];
export declare const FactorySessionListScope: {
    readonly FactorySessionListScopeLive: "live";
    readonly FactorySessionListScopePersisted: "persisted";
    readonly FactorySessionListScopeAll: "all";
};
export type FactorySessionListScope = (typeof FactorySessionListScope)[keyof typeof FactorySessionListScope];
export declare const FactorySessionResultStatus: {
    readonly FactorySessionResultStatusNotReady: "NOT_READY";
    readonly FactorySessionResultStatusPartial: "PARTIAL";
    readonly FactorySessionResultStatusFinal: "FINAL";
    readonly FactorySessionResultStatusFailedWithPartial: "FAILED_WITH_PARTIAL";
    readonly FactorySessionResultStatusUnavailable: "UNAVAILABLE";
};
export type FactorySessionResultStatus = (typeof FactorySessionResultStatus)[keyof typeof FactorySessionResultStatus];
export declare const FactorySessionExecutionSourceKind: {
    readonly FactorySessionExecutionSourceKindFactoryId: "FACTORY_ID";
    readonly FactorySessionExecutionSourceKindFactoryInline: "FACTORY_INLINE";
    readonly FactorySessionExecutionSourceKindWorkflowFile: "WORKFLOW_FILE";
    readonly FactorySessionExecutionSourceKindWorkflowName: "WORKFLOW_NAME";
    readonly FactorySessionExecutionSourceKindInlineWorkflow: "INLINE_WORKFLOW";
};
export type FactorySessionExecutionSourceKind = (typeof FactorySessionExecutionSourceKind)[keyof typeof FactorySessionExecutionSourceKind];
export declare const FactorySessionEventStreamRecoveryOutcome: {
    readonly STREAM_READY: "STREAM_READY";
    readonly CURSOR_STALE: "CURSOR_STALE";
    readonly UNKNOWN_SESSION: "UNKNOWN_SESSION";
    readonly INTERNAL_ERROR: "INTERNAL_ERROR";
};
export type FactorySessionEventStreamRecoveryOutcome = (typeof FactorySessionEventStreamRecoveryOutcome)[keyof typeof FactorySessionEventStreamRecoveryOutcome];
export declare const FactorySessionWorkflowSourceResolutionOrder: {
    readonly FactorySessionWorkflowSourceResolutionOrderProjectClaudeWorkflows: "PROJECT_CLAUDE_WORKFLOWS";
    readonly FactorySessionWorkflowSourceResolutionOrderUserYouAgentFactoryWorkflows: "USER_YOU_AGENT_FACTORY_WORKFLOWS";
    readonly FactorySessionWorkflowSourceResolutionOrderPackageRelativeWorkflowDirectories: "PACKAGE_RELATIVE_WORKFLOW_DIRECTORIES";
    readonly FactorySessionWorkflowSourceResolutionOrderBuiltinGlobalJavaScriptFactories: "BUILTIN_GLOBAL_JAVASCRIPT_FACTORIES";
    readonly FactorySessionWorkflowSourceResolutionOrderExplicitFactoryLookup: "EXPLICIT_FACTORY_LOOKUP";
};
export type FactorySessionWorkflowSourceResolutionOrder = (typeof FactorySessionWorkflowSourceResolutionOrder)[keyof typeof FactorySessionWorkflowSourceResolutionOrder];
export declare const FactorySessionDurableLifecycleStatus: {
    readonly FactorySessionDurableLifecycleStatusQueued: "QUEUED";
    readonly FactorySessionDurableLifecycleStatusAwaitingApproval: "AWAITING_APPROVAL";
    readonly FactorySessionDurableLifecycleStatusRunning: "RUNNING";
    readonly FactorySessionDurableLifecycleStatusPaused: "PAUSED";
    readonly FactorySessionDurableLifecycleStatusResuming: "RESUMING";
    readonly FactorySessionDurableLifecycleStatusSucceeded: "SUCCEEDED";
    readonly FactorySessionDurableLifecycleStatusFailed: "FAILED";
    readonly FactorySessionDurableLifecycleStatusCanceling: "CANCELING";
    readonly FactorySessionDurableLifecycleStatusCanceled: "CANCELED";
    readonly FactorySessionDurableLifecycleStatusTimedOut: "TIMED_OUT";
    readonly FactorySessionDurableLifecycleStatusInterrupted: "INTERRUPTED";
    readonly FactorySessionDurableLifecycleStatusTerminated: "TERMINATED";
};
export type FactorySessionDurableLifecycleStatus = (typeof FactorySessionDurableLifecycleStatus)[keyof typeof FactorySessionDurableLifecycleStatus];
export declare const FactorySessionSyncExecutionOutcome: {
    readonly FactorySessionSyncExecutionOutcomeCompleted: "COMPLETED";
    readonly FactorySessionSyncExecutionOutcomeTimedOut: "TIMED_OUT";
    readonly FactorySessionSyncExecutionOutcomeStillRunning: "STILL_RUNNING";
};
export type FactorySessionSyncExecutionOutcome = (typeof FactorySessionSyncExecutionOutcome)[keyof typeof FactorySessionSyncExecutionOutcome];
export declare const FactorySessionLifecycleControlKind: {
    readonly FactorySessionLifecycleControlKindApprove: "APPROVE";
    readonly FactorySessionLifecycleControlKindPause: "PAUSE";
    readonly FactorySessionLifecycleControlKindResume: "RESUME";
    readonly FactorySessionLifecycleControlKindCancel: "CANCEL";
    readonly FactorySessionLifecycleControlKindTerminate: "TERMINATE";
    readonly FactorySessionLifecycleControlKindRetryDispatch: "RETRY_DISPATCH";
    readonly FactorySessionLifecycleControlKindInterruptDispatch: "INTERRUPT_DISPATCH";
};
export type FactorySessionLifecycleControlKind = (typeof FactorySessionLifecycleControlKind)[keyof typeof FactorySessionLifecycleControlKind];
export declare const FactorySessionLifecycleControlOutcome: {
    readonly FactorySessionLifecycleControlOutcomeAccepted: "ACCEPTED";
    readonly FactorySessionLifecycleControlOutcomeNoOp: "NO_OP";
    readonly FactorySessionLifecycleControlOutcomeInvalidState: "INVALID_STATE";
    readonly FactorySessionLifecycleControlOutcomeTerminalSession: "TERMINAL_SESSION";
    readonly FactorySessionLifecycleControlOutcomeConflict: "CONFLICT";
};
export type FactorySessionLifecycleControlOutcome = (typeof FactorySessionLifecycleControlOutcome)[keyof typeof FactorySessionLifecycleControlOutcome];
export declare const LoadableProviderSessionProvider: {
    readonly Codex: "codex";
    readonly Cursor: "cursor";
};
export type LoadableProviderSessionProvider = (typeof LoadableProviderSessionProvider)[keyof typeof LoadableProviderSessionProvider];
export declare const LoadableProviderSessionKind: {
    readonly SessionID: "session_id";
};
export type LoadableProviderSessionKind = (typeof LoadableProviderSessionKind)[keyof typeof LoadableProviderSessionKind];
export declare const ProviderSessionTranscriptEntryType: {
    readonly user_message: "user_message";
    readonly assistant_message: "assistant_message";
    readonly reasoning: "reasoning";
    readonly tool_call: "tool_call";
    readonly tool_output: "tool_output";
    readonly system_event: "system_event";
};
export type ProviderSessionTranscriptEntryType = (typeof ProviderSessionTranscriptEntryType)[keyof typeof ProviderSessionTranscriptEntryType];
export declare const NameValueType: {
    readonly LOCALIZABLE_ASSET: "LOCALIZABLE_ASSET";
};
export type NameValueType = (typeof NameValueType)[keyof typeof NameValueType];
export declare const FactoryWorldWorkItemRefPayloadStatus: {
    readonly RESOLVED: "RESOLVED";
    readonly UNAVAILABLE: "UNAVAILABLE";
    readonly LOADING: "LOADING";
    readonly ERROR: "ERROR";
};
export type FactoryWorldWorkItemRefPayloadStatus = (typeof FactoryWorldWorkItemRefPayloadStatus)[keyof typeof FactoryWorldWorkItemRefPayloadStatus];
export declare const FactoryWorldWorkItemRefLineageSourceKind: {
    readonly WORK_REQUEST: "WORK_REQUEST";
    readonly DISPATCH_RESPONSE_OUTPUT: "DISPATCH_RESPONSE_OUTPUT";
};
export type FactoryWorldWorkItemRefLineageSourceKind = (typeof FactoryWorldWorkItemRefLineageSourceKind)[keyof typeof FactoryWorldWorkItemRefLineageSourceKind];
export declare const FactoryWorldWorkItemRefLineageContinuity: {
    readonly INITIAL_SUBMISSION: "INITIAL_SUBMISSION";
    readonly SAME_WORK_ID_CONTINUATION: "SAME_WORK_ID_CONTINUATION";
    readonly NEW_DOWNSTREAM_WORK: "NEW_DOWNSTREAM_WORK";
};
export type FactoryWorldWorkItemRefLineageContinuity = (typeof FactoryWorldWorkItemRefLineageContinuity)[keyof typeof FactoryWorldWorkItemRefLineageContinuity];
export declare const FactoryWorldRunnerBaselineCapability: {
    readonly prompt_submission: "prompt_submission";
    readonly tool_execution: "tool_execution";
};
export type FactoryWorldRunnerBaselineCapability = (typeof FactoryWorldRunnerBaselineCapability)[keyof typeof FactoryWorldRunnerBaselineCapability];
export declare const FactoryWorldRunnerOptionalCapability: {
    readonly image_input: "image_input";
    readonly session_resume: "session_resume";
    readonly structured_output: "structured_output";
    readonly working_directory: "working_directory";
    readonly worktree: "worktree";
};
export type FactoryWorldRunnerOptionalCapability = (typeof FactoryWorldRunnerOptionalCapability)[keyof typeof FactoryWorldRunnerOptionalCapability];
export declare const FactoryWorldRunnerOptionalCapabilityStatus: {
    readonly supported: "supported";
    readonly unsupported: "unsupported";
};
export type FactoryWorldRunnerOptionalCapabilityStatus = (typeof FactoryWorldRunnerOptionalCapabilityStatus)[keyof typeof FactoryWorldRunnerOptionalCapabilityStatus];
export declare const FactoryEventSchemaVersion: {
    readonly agent_factory_event_v1: "agent-factory.event.v1";
};
export type FactoryEventSchemaVersion = (typeof FactoryEventSchemaVersion)[keyof typeof FactoryEventSchemaVersion];
export declare const FactoryRecordingSchemaVersion: {
    readonly agent_factory_recording_v1: "agent-factory.recording.v1";
};
export type FactoryRecordingSchemaVersion = (typeof FactoryRecordingSchemaVersion)[keyof typeof FactoryRecordingSchemaVersion];
export declare const FactoryEventType: {
    readonly FactoryEventTypeRunRequest: "RUN_REQUEST";
    readonly FactoryEventTypeInitialStructureRequest: "INITIAL_STRUCTURE_REQUEST";
    readonly FactoryEventTypeFactoryChange: "FACTORY_CHANGE";
    readonly FactoryEventTypeWorkRequest: "WORK_REQUEST";
    readonly FactoryEventTypeRelationshipChangeRequest: "RELATIONSHIP_CHANGE_REQUEST";
    readonly FactoryEventTypeDispatchRequest: "DISPATCH_REQUEST";
    readonly FactoryEventTypeDispatchWorkerSessionAssociation: "DISPATCH_WORKER_SESSION_ASSOCIATION";
    readonly FactoryEventTypeModelRequest: "MODEL_REQUEST";
    readonly FactoryEventTypeModelResponse: "MODEL_RESPONSE";
    readonly FactoryEventTypeInferenceRequest: "INFERENCE_REQUEST";
    readonly FactoryEventTypeInferenceResponse: "INFERENCE_RESPONSE";
    readonly FactoryEventTypeScriptRequest: "SCRIPT_REQUEST";
    readonly FactoryEventTypeScriptResponse: "SCRIPT_RESPONSE";
    readonly FactoryEventTypeAgentRunResponse: "AGENT_RUN_RESPONSE";
    readonly FactoryEventTypeDispatchResponse: "DISPATCH_RESPONSE";
    readonly FactoryEventTypeWorkStateChange: "WORK_STATE_CHANGE";
    readonly FactoryEventTypeFactoryStateResponse: "FACTORY_STATE_RESPONSE";
    readonly FactoryEventTypeRunResponse: "RUN_RESPONSE";
    readonly FactoryEventTypeSessionStarted: "SESSION_STARTED";
    readonly FactoryEventTypeSessionPaused: "SESSION_PAUSED";
    readonly FactoryEventTypeSessionResumed: "SESSION_RESUMED";
    readonly FactoryEventTypeSessionResultUpdated: "SESSION_RESULT_UPDATED";
    readonly FactoryEventTypeSessionCompleted: "SESSION_COMPLETED";
    readonly FactoryEventTypeSessionLifecycleControl: "SESSION_LIFECYCLE_CONTROL";
    readonly FactoryEventTypeOrchestratorPhaseChanged: "ORCHESTRATOR_PHASE_CHANGED";
    readonly FactoryEventTypeOrchestratorCheckpointWritten: "ORCHESTRATOR_CHECKPOINT_WRITTEN";
    readonly FactoryEventTypeDispatchQueued: "DISPATCH_QUEUED";
    readonly FactoryEventTypeDispatchInterrupted: "DISPATCH_INTERRUPTED";
    readonly FactoryEventTypeDispatchReconciled: "DISPATCH_RECONCILED";
    readonly FactoryEventTypeJavaScriptCheckpointRef: "JAVASCRIPT_CHECKPOINT_REF";
    readonly FactoryEventTypeJavaScriptPhaseChange: "JAVASCRIPT_PHASE_CHANGE";
    readonly FactoryEventTypeArtifactCreated: "ARTIFACT_CREATED";
};
export type FactoryEventType = (typeof FactoryEventType)[keyof typeof FactoryEventType];
export declare const WorkStateChangeSource: {
    readonly WorkStateChangeSourceAPI: "api";
    readonly WorkStateChangeSourceCLI: "cli";
    readonly WorkStateChangeSourceCascadingFailure: "cascading-failure";
};
export type WorkStateChangeSource = (typeof WorkStateChangeSource)[keyof typeof WorkStateChangeSource];
export declare const InferenceOutcome: {
    readonly InferenceOutcomeSucceeded: "SUCCEEDED";
    readonly InferenceOutcomeFailed: "FAILED";
};
export type InferenceOutcome = (typeof InferenceOutcome)[keyof typeof InferenceOutcome];
export declare const ScriptExecutionOutcome: {
    readonly ScriptExecutionOutcomeSucceeded: "SUCCEEDED";
    readonly ScriptExecutionOutcomeFailedExitCode: "FAILED_EXIT_CODE";
    readonly ScriptExecutionOutcomeTimedOut: "TIMED_OUT";
    readonly ScriptExecutionOutcomeProcessError: "PROCESS_ERROR";
};
export type ScriptExecutionOutcome = (typeof ScriptExecutionOutcome)[keyof typeof ScriptExecutionOutcome];
export declare const ScriptFailureType: {
    readonly ScriptFailureTypeTimeout: "TIMEOUT";
    readonly ScriptFailureTypeProcessError: "PROCESS_ERROR";
};
export type ScriptFailureType = (typeof ScriptFailureType)[keyof typeof ScriptFailureType];
export declare const FactoryState: {
    readonly FactoryStateIdle: "IDLE";
    readonly FactoryStateRunning: "RUNNING";
    readonly FactoryStatePaused: "PAUSED";
    readonly FactoryStateCompleted: "COMPLETED";
    readonly FactoryStateFailed: "FAILED";
};
export type FactoryState = (typeof FactoryState)[keyof typeof FactoryState];
export declare const WorkOutcome: {
    readonly WorkOutcomeAccepted: "ACCEPTED";
    readonly WorkOutcomeContinue: "CONTINUE";
    readonly WorkOutcomeRejected: "REJECTED";
    readonly WorkOutcomeFailed: "FAILED";
};
export type WorkOutcome = (typeof WorkOutcome)[keyof typeof WorkOutcome];
export declare const WorkFailureFamily: {
    readonly WorkFailureFamilyTerminal: "terminal";
    readonly WorkFailureFamilyRetryable: "retryable";
    readonly WorkFailureFamilyThrottle: "throttle";
};
export type WorkFailureFamily = (typeof WorkFailureFamily)[keyof typeof WorkFailureFamily];
export declare const WorkFailureType: {
    readonly WorkFailureTypeAuthFailure: "auth_failure";
    readonly WorkFailureTypePermanentBadRequest: "permanent_bad_request";
    readonly WorkFailureTypeThrottled: "throttled";
    readonly WorkFailureTypeInternalServerError: "internal_server_error";
    readonly WorkFailureTypeTimeout: "timeout";
    readonly WorkFailureTypeUnknown: "unknown";
    readonly WorkFailureTypeMisconfigured: "misconfigured";
    readonly WorkFailureTypeMissingExecutable: "missing_executable";
    readonly WorkFailureTypeCommandLineTooLong: "command_line_too_long";
};
export type WorkFailureType = (typeof WorkFailureType)[keyof typeof WorkFailureType];
export declare const SafeAgentRunDiagnosticExecutionBehavior: {
    readonly agent_run: "agent_run";
};
export type SafeAgentRunDiagnosticExecutionBehavior = (typeof SafeAgentRunDiagnosticExecutionBehavior)[keyof typeof SafeAgentRunDiagnosticExecutionBehavior];
export declare const FactoryResponseEventSchemaVersion: {
    readonly agent_factory_response_event_v1: "agent-factory.response-event.v1";
};
export type FactoryResponseEventSchemaVersion = (typeof FactoryResponseEventSchemaVersion)[keyof typeof FactoryResponseEventSchemaVersion];
export declare const FactoryResponseEventKind: {
    readonly FactoryResponseEventKindSession: "SESSION";
    readonly FactoryResponseEventKindRun: "RUN";
    readonly FactoryResponseEventKindTurn: "TURN";
    readonly FactoryResponseEventKindMessage: "MESSAGE";
    readonly FactoryResponseEventKindReasoning: "REASONING";
    readonly FactoryResponseEventKindTool: "TOOL";
    readonly FactoryResponseEventKindFileChange: "FILE_CHANGE";
    readonly FactoryResponseEventKindPlan: "PLAN";
    readonly FactoryResponseEventKindProgress: "PROGRESS";
    readonly FactoryResponseEventKindUsage: "USAGE";
    readonly FactoryResponseEventKindError: "ERROR";
    readonly FactoryResponseEventKindStreamGap: "STREAM_GAP";
};
export type FactoryResponseEventKind = (typeof FactoryResponseEventKind)[keyof typeof FactoryResponseEventKind];
export declare const FactoryResponseEventPhase: {
    readonly FactoryResponseEventPhaseStarted: "STARTED";
    readonly FactoryResponseEventPhaseDelta: "DELTA";
    readonly FactoryResponseEventPhaseUpdated: "UPDATED";
    readonly FactoryResponseEventPhaseCompleted: "COMPLETED";
    readonly FactoryResponseEventPhaseFailed: "FAILED";
    readonly FactoryResponseEventPhaseCanceled: "CANCELED";
};
export type FactoryResponseEventPhase = (typeof FactoryResponseEventPhase)[keyof typeof FactoryResponseEventPhase];
export declare const FactoryResponseEventProvenanceDelivery: {
    readonly FactoryResponseEventProvenanceDeliveryNativeStream: "NATIVE_STREAM";
    readonly FactoryResponseEventProvenanceDeliveryNativeFinal: "NATIVE_FINAL";
    readonly FactoryResponseEventProvenanceDeliverySynthesized: "SYNTHESIZED";
    readonly FactoryResponseEventProvenanceDeliveryReplay: "REPLAY";
};
export type FactoryResponseEventProvenanceDelivery = (typeof FactoryResponseEventProvenanceDelivery)[keyof typeof FactoryResponseEventProvenanceDelivery];
export declare const FactoryResponseEventProvenanceRepresentation: {
    readonly FactoryResponseEventProvenanceRepresentationDelta: "DELTA";
    readonly FactoryResponseEventProvenanceRepresentationSnapshot: "SNAPSHOT";
    readonly FactoryResponseEventProvenanceRepresentationNotification: "NOTIFICATION";
};
export type FactoryResponseEventProvenanceRepresentation = (typeof FactoryResponseEventProvenanceRepresentation)[keyof typeof FactoryResponseEventProvenanceRepresentation];
export declare const FactoryResponseEventProvenanceFidelity: {
    readonly FactoryResponseEventProvenanceFidelityLossless: "LOSSLESS";
    readonly FactoryResponseEventProvenanceFidelityNormalized: "NORMALIZED";
    readonly FactoryResponseEventProvenanceFidelityLossy: "LOSSY";
    readonly FactoryResponseEventProvenanceFidelityFinalOnly: "FINAL_ONLY";
    readonly FactoryResponseEventProvenanceFidelityLifecycleOnly: "LIFECYCLE_ONLY";
};
export type FactoryResponseEventProvenanceFidelity = (typeof FactoryResponseEventProvenanceFidelity)[keyof typeof FactoryResponseEventProvenanceFidelity];
export declare const FactoryResponseEventContentBlockKind: {
    readonly FactoryResponseEventContentBlockKindText: "TEXT";
    readonly FactoryResponseEventContentBlockKindReasoningSummary: "REASONING_SUMMARY";
    readonly FactoryResponseEventContentBlockKindToolRequest: "TOOL_REQUEST";
    readonly FactoryResponseEventContentBlockKindImageRef: "IMAGE_REF";
    readonly FactoryResponseEventContentBlockKindResourceRef: "RESOURCE_REF";
    readonly FactoryResponseEventContentBlockKindStructuredOutput: "STRUCTURED_OUTPUT";
};
export type FactoryResponseEventContentBlockKind = (typeof FactoryResponseEventContentBlockKind)[keyof typeof FactoryResponseEventContentBlockKind];
export declare const FactoryResponseEventTextContentBlockKind: {
    readonly TEXT: "TEXT";
};
export type FactoryResponseEventTextContentBlockKind = (typeof FactoryResponseEventTextContentBlockKind)[keyof typeof FactoryResponseEventTextContentBlockKind];
export declare const FactoryResponseEventReasoningSummaryContentBlockKind: {
    readonly REASONING_SUMMARY: "REASONING_SUMMARY";
};
export type FactoryResponseEventReasoningSummaryContentBlockKind = (typeof FactoryResponseEventReasoningSummaryContentBlockKind)[keyof typeof FactoryResponseEventReasoningSummaryContentBlockKind];
export declare const FactoryResponseEventToolRequestContentBlockKind: {
    readonly TOOL_REQUEST: "TOOL_REQUEST";
};
export type FactoryResponseEventToolRequestContentBlockKind = (typeof FactoryResponseEventToolRequestContentBlockKind)[keyof typeof FactoryResponseEventToolRequestContentBlockKind];
export declare const FactoryResponseEventImageRefContentBlockKind: {
    readonly IMAGE_REF: "IMAGE_REF";
};
export type FactoryResponseEventImageRefContentBlockKind = (typeof FactoryResponseEventImageRefContentBlockKind)[keyof typeof FactoryResponseEventImageRefContentBlockKind];
export declare const FactoryResponseEventResourceRefContentBlockKind: {
    readonly RESOURCE_REF: "RESOURCE_REF";
};
export type FactoryResponseEventResourceRefContentBlockKind = (typeof FactoryResponseEventResourceRefContentBlockKind)[keyof typeof FactoryResponseEventResourceRefContentBlockKind];
export declare const FactoryResponseEventStructuredOutputContentBlockKind: {
    readonly STRUCTURED_OUTPUT: "STRUCTURED_OUTPUT";
};
export type FactoryResponseEventStructuredOutputContentBlockKind = (typeof FactoryResponseEventStructuredOutputContentBlockKind)[keyof typeof FactoryResponseEventStructuredOutputContentBlockKind];
export declare const FactorySaveMode: {
    readonly FactorySaveModeReplaceCurrent: "REPLACE_CURRENT";
    readonly FactorySaveModeUpsertNamedAndActivate: "UPSERT_NAMED_AND_ACTIVATE";
};
export type FactorySaveMode = (typeof FactorySaveMode)[keyof typeof FactorySaveMode];
export declare const FactoryOrchestratorKind: {
    readonly PETRI: "PETRI";
    readonly JAVASCRIPT: "JAVASCRIPT";
};
export type FactoryOrchestratorKind = (typeof FactoryOrchestratorKind)[keyof typeof FactoryOrchestratorKind];
export declare const FactoryOrchestratorJavaScriptInlineSourceEncoding: {
    readonly utf_8: "utf-8";
};
export type FactoryOrchestratorJavaScriptInlineSourceEncoding = (typeof FactoryOrchestratorJavaScriptInlineSourceEncoding)[keyof typeof FactoryOrchestratorJavaScriptInlineSourceEncoding];
export declare const FactoryInvocationParameterBindingKind: {
    readonly POSITIONAL: "POSITIONAL";
    readonly NAMED: "NAMED";
    readonly STDIN: "STDIN";
    readonly NAMED_REST: "NAMED_REST";
};
export type FactoryInvocationParameterBindingKind = (typeof FactoryInvocationParameterBindingKind)[keyof typeof FactoryInvocationParameterBindingKind];
export declare const FactoryInvocationParameterTypeHint: {
    readonly STRING: "STRING";
    readonly PATH: "PATH";
    readonly FILE_PATH: "FILE_PATH";
    readonly DIRECTORY_PATH: "DIRECTORY_PATH";
    readonly NUMBER_STRING: "NUMBER_STRING";
    readonly BOOLEAN_STRING: "BOOLEAN_STRING";
};
export type FactoryInvocationParameterTypeHint = (typeof FactoryInvocationParameterTypeHint)[keyof typeof FactoryInvocationParameterTypeHint];
export declare const FactoryInvocationParameterValueMode: {
    readonly EXACT: "EXACT";
    readonly REPEATED: "REPEATED";
    readonly VARIADIC: "VARIADIC";
    readonly FILE_CONTENTS: "FILE_CONTENTS";
};
export type FactoryInvocationParameterValueMode = (typeof FactoryInvocationParameterValueMode)[keyof typeof FactoryInvocationParameterValueMode];
export declare const FactoryInvocationUnknownNamedArgumentPolicy: {
    readonly REJECT: "REJECT";
    readonly ALLOW: "ALLOW";
    readonly COLLECT: "COLLECT";
};
export type FactoryInvocationUnknownNamedArgumentPolicy = (typeof FactoryInvocationUnknownNamedArgumentPolicy)[keyof typeof FactoryInvocationUnknownNamedArgumentPolicy];
export declare const FactoryInvocationOutputContractMode: {
    readonly INLINE: "INLINE";
    readonly FILE: "FILE";
    readonly JSON: "JSON";
};
export type FactoryInvocationOutputContractMode = (typeof FactoryInvocationOutputContractMode)[keyof typeof FactoryInvocationOutputContractMode];
export declare const InvocationReturnPolicy: {
    readonly SUBMITTED_WORK_TERMINAL: "SUBMITTED_WORK_TERMINAL";
    readonly EXPLICIT: "EXPLICIT";
};
export type InvocationReturnPolicy = (typeof InvocationReturnPolicy)[keyof typeof InvocationReturnPolicy];
export declare const BundledFileType: {
    readonly SCRIPT: "SCRIPT";
    readonly DOC: "DOC";
    readonly INPUT: "INPUT";
    readonly ROOT_HELPER: "ROOT_HELPER";
};
export type BundledFileType = (typeof BundledFileType)[keyof typeof BundledFileType];
export declare const BundledFileContentEncoding: {
    readonly utf_8: "utf-8";
};
export type BundledFileContentEncoding = (typeof BundledFileContentEncoding)[keyof typeof BundledFileContentEncoding];
export declare const InputKind: {
    readonly DEFAULT: "DEFAULT";
};
export type InputKind = (typeof InputKind)[keyof typeof InputKind];
export declare const WorkStateType: {
    readonly INITIAL: "INITIAL";
    readonly PROCESSING: "PROCESSING";
    readonly TERMINAL: "TERMINAL";
    readonly FAILED: "FAILED";
};
export type WorkStateType = (typeof WorkStateType)[keyof typeof WorkStateType];
export declare const ResourceType: {
    readonly MODEL: "MODEL";
    readonly PROVIDER_QUOTA: "PROVIDER_QUOTA";
    readonly INVOCATION_SLOT: "INVOCATION_SLOT";
};
export type ResourceType = (typeof ResourceType)[keyof typeof ResourceType];
export declare const AgentWorkerToolPolicy: {
    readonly DISABLED: "DISABLED";
    readonly READ_ONLY: "READ_ONLY";
    readonly ENABLED: "ENABLED";
};
export type AgentWorkerToolPolicy = (typeof AgentWorkerToolPolicy)[keyof typeof AgentWorkerToolPolicy];
export declare const WorkerType: {
    readonly INFERENCE_WORKER: "INFERENCE_WORKER";
    readonly AGENT_WORKER: "AGENT_WORKER";
    readonly SCRIPT_WORKER: "SCRIPT_WORKER";
    readonly POLLER_WORKER: "POLLER_WORKER";
    readonly MODEL_WORKER: "MODEL_WORKER";
    readonly HOSTED_WORKER: "HOSTED_WORKER";
};
export type WorkerType = (typeof WorkerType)[keyof typeof WorkerType];
export declare const WorkerModelProvider: {
    readonly CLAUDE: "CLAUDE";
    readonly CODEX: "CODEX";
    readonly ANTIGRAVITY: "ANTIGRAVITY";
};
export type WorkerModelProvider = (typeof WorkerModelProvider)[keyof typeof WorkerModelProvider];
export declare const ProviderCatalogFormatVersion: {
    readonly Value1_0_0: "1.0.0";
};
export type ProviderCatalogFormatVersion = (typeof ProviderCatalogFormatVersion)[keyof typeof ProviderCatalogFormatVersion];
export declare const ProviderCatalogProviderSchema: {
    readonly https_schemas_you_dev_model_providers_provider_manifest_1_0_0_schema_json: "https://schemas.you.dev/model-providers/provider-manifest/1.0.0.schema.json";
};
export type ProviderCatalogProviderSchema = (typeof ProviderCatalogProviderSchema)[keyof typeof ProviderCatalogProviderSchema];
export declare const ProviderTechnicalSupportLevel: {
    readonly production: "production";
    readonly experimental: "experimental";
    readonly not_supported: "not-supported";
};
export type ProviderTechnicalSupportLevel = (typeof ProviderTechnicalSupportLevel)[keyof typeof ProviderTechnicalSupportLevel];
export declare const ProviderImplementationAvailability: {
    readonly bundled: "bundled";
    readonly externally_supplied: "externally-supplied";
    readonly catalog_only: "catalog-only";
};
export type ProviderImplementationAvailability = (typeof ProviderImplementationAvailability)[keyof typeof ProviderImplementationAvailability];
export declare const ProviderDocumentationLinkKind: {
    readonly homepage: "homepage";
    readonly setup: "setup";
    readonly reference: "reference";
    readonly support: "support";
};
export type ProviderDocumentationLinkKind = (typeof ProviderDocumentationLinkKind)[keyof typeof ProviderDocumentationLinkKind];
export declare const ProviderDiscoveryEndpointKind: {
    readonly local_http: "local-http";
    readonly remote_http: "remote-http";
    readonly stdio: "stdio";
    readonly unix_socket: "unix-socket";
};
export type ProviderDiscoveryEndpointKind = (typeof ProviderDiscoveryEndpointKind)[keyof typeof ProviderDiscoveryEndpointKind];
export declare const WorkerModelLocality: {
    readonly LOCAL: "LOCAL";
    readonly CLOUD: "CLOUD";
};
export type WorkerModelLocality = (typeof WorkerModelLocality)[keyof typeof WorkerModelLocality];
export declare const ModelOperationContentType: {
    readonly TEXT: "TEXT";
    readonly IMAGE: "IMAGE";
    readonly AUDIO: "AUDIO";
    readonly JSON: "JSON";
    readonly BINARY: "BINARY";
};
export type ModelOperationContentType = (typeof ModelOperationContentType)[keyof typeof ModelOperationContentType];
export declare const RunnerID: {
    readonly codex: "codex";
    readonly claude: "claude";
    readonly antigravity: "antigravity";
};
export type RunnerID = (typeof RunnerID)[keyof typeof RunnerID];
export declare const RunnerSelectionSource: {
    readonly workstation: "workstation";
    readonly factory: "factory";
    readonly legacy_provider: "legacy_provider";
    readonly default: "default";
};
export type RunnerSelectionSource = (typeof RunnerSelectionSource)[keyof typeof RunnerSelectionSource];
export declare const WorkstationOutcomeFormat: {
    readonly decision_envelope: "decision-envelope";
};
export type WorkstationOutcomeFormat = (typeof WorkstationOutcomeFormat)[keyof typeof WorkstationOutcomeFormat];
export declare const WorkstationKind: {
    readonly STANDARD: "STANDARD";
    readonly REPEATER: "REPEATER";
    readonly CRON: "CRON";
    readonly POLLER: "POLLER";
};
export type WorkstationKind = (typeof WorkstationKind)[keyof typeof WorkstationKind];
export declare const WorkstationType: {
    readonly INFERENCE_RUN: "INFERENCE_RUN";
    readonly AGENT_RUN: "AGENT_RUN";
    readonly SCRIPT_RUN: "SCRIPT_RUN";
    readonly POLLER_RUN: "POLLER_RUN";
    readonly MODEL_WORKSTATION: "MODEL_WORKSTATION";
    readonly MODEL_INVOKE: "MODEL_INVOKE";
    readonly LOGICAL_MOVE: "LOGICAL_MOVE";
    readonly CLASSIFIER_WORKSTATION: "CLASSIFIER_WORKSTATION";
};
export type WorkstationType = (typeof WorkstationType)[keyof typeof WorkstationType];
export declare const WorkPropagationMode: {
    readonly OUTPUT_AS_PAYLOAD: "OUTPUT_AS_PAYLOAD";
    readonly PRESERVE_INPUT: "PRESERVE_INPUT";
};
export type WorkPropagationMode = (typeof WorkPropagationMode)[keyof typeof WorkPropagationMode];
export declare const GuardType: {
    readonly VISIT_COUNT: "VISIT_COUNT";
    readonly MATCHES_FIELDS: "MATCHES_FIELDS";
    readonly ALL_CHILDREN_COMPLETE: "ALL_CHILDREN_COMPLETE";
    readonly ANY_CHILD_FAILED: "ANY_CHILD_FAILED";
    readonly SAME_NAME: "SAME_NAME";
    readonly SAME_TRACE_ID: "SAME_TRACE_ID";
};
export type GuardType = (typeof GuardType)[keyof typeof GuardType];
export declare const PromptTemplateVariableReferenceCategory: {
    readonly ROOT: "ROOT";
    readonly INPUT: "INPUT";
    readonly HISTORY: "HISTORY";
    readonly CONTEXT: "CONTEXT";
    readonly MAP_ACCESS: "MAP_ACCESS";
    readonly DOC: "DOC";
};
export type PromptTemplateVariableReferenceCategory = (typeof PromptTemplateVariableReferenceCategory)[keyof typeof PromptTemplateVariableReferenceCategory];
export declare const PromptTemplateDiagnosticKind: {
    readonly SYNTAX_ERROR: "SYNTAX_ERROR";
    readonly INVALID_VARIABLE: "INVALID_VARIABLE";
    readonly UNAVAILABLE_VARIABLE: "UNAVAILABLE_VARIABLE";
};
export type PromptTemplateDiagnosticKind = (typeof PromptTemplateDiagnosticKind)[keyof typeof PromptTemplateDiagnosticKind];
export declare const FactoryPreviewRequestSourceKind: {
    readonly FACTORY_ID: "FACTORY_ID";
    readonly FACTORY_INLINE: "FACTORY_INLINE";
    readonly WORKFLOW_FILE: "WORKFLOW_FILE";
    readonly WORKFLOW_NAME: "WORKFLOW_NAME";
    readonly INLINE_WORKFLOW: "INLINE_WORKFLOW";
};
export type FactoryPreviewRequestSourceKind = (typeof FactoryPreviewRequestSourceKind)[keyof typeof FactoryPreviewRequestSourceKind];
export declare const FactoryValidationSeverity: {
    readonly FactoryValidationSeverityError: "error";
    readonly FactoryValidationSeverityWarning: "warning";
    readonly FactoryValidationSeverityHint: "hint";
};
export type FactoryValidationSeverity = (typeof FactoryValidationSeverity)[keyof typeof FactoryValidationSeverity];
export declare const FactoryValidationSubjectType: {
    readonly FactoryValidationSubjectTypeFactory: "FACTORY";
    readonly FactoryValidationSubjectTypeWorkstation: "WORKSTATION";
    readonly FactoryValidationSubjectTypeWorkType: "WORK_TYPE";
    readonly FactoryValidationSubjectTypeWorkState: "WORK_STATE";
    readonly FactoryValidationSubjectTypeWorker: "WORKER";
    readonly FactoryValidationSubjectTypeResource: "RESOURCE";
    readonly FactoryValidationSubjectTypeRoute: "ROUTE";
};
export type FactoryValidationSubjectType = (typeof FactoryValidationSubjectType)[keyof typeof FactoryValidationSubjectType];
export declare const FactoryValidationSubjectLocation: {
    readonly FactoryValidationSubjectLocationOnRejection: "ON_REJECTION";
    readonly FactoryValidationSubjectLocationOnFailure: "ON_FAILURE";
    readonly FactoryValidationSubjectLocationOutputs: "OUTPUTS";
    readonly FactoryValidationSubjectLocationInputs: "INPUTS";
    readonly FactoryValidationSubjectLocationStates: "STATES";
    readonly FactoryValidationSubjectLocationTerminal: "TERMINAL";
    readonly FactoryValidationSubjectLocationReference: "REFERENCE";
    readonly FactoryValidationSubjectLocationDefinition: "DEFINITION";
};
export type FactoryValidationSubjectLocation = (typeof FactoryValidationSubjectLocation)[keyof typeof FactoryValidationSubjectLocation];
export declare const WorkRequestType: {
    readonly WorkRequestTypeFactoryRequestBatch: "FACTORY_REQUEST_BATCH";
};
export type WorkRequestType = (typeof WorkRequestType)[keyof typeof WorkRequestType];
export declare const WorkContentPartType: {
    readonly text: "text";
    readonly image: "image";
    readonly TEXT: "TEXT";
    readonly IMAGE: "IMAGE";
    readonly AUDIO: "AUDIO";
    readonly JSON: "JSON";
    readonly BINARY: "BINARY";
};
export type WorkContentPartType = (typeof WorkContentPartType)[keyof typeof WorkContentPartType];
export declare const WorkTextContentPartType: {
    readonly text: "text";
    readonly TEXT: "TEXT";
};
export type WorkTextContentPartType = (typeof WorkTextContentPartType)[keyof typeof WorkTextContentPartType];
export declare const WorkImageContentPartType: {
    readonly image: "image";
    readonly IMAGE: "IMAGE";
};
export type WorkImageContentPartType = (typeof WorkImageContentPartType)[keyof typeof WorkImageContentPartType];
export declare const WorkAudioContentPartType: {
    readonly AUDIO: "AUDIO";
};
export type WorkAudioContentPartType = (typeof WorkAudioContentPartType)[keyof typeof WorkAudioContentPartType];
export declare const WorkJsonContentPartType: {
    readonly JSON: "JSON";
};
export type WorkJsonContentPartType = (typeof WorkJsonContentPartType)[keyof typeof WorkJsonContentPartType];
export declare const WorkBinaryContentPartType: {
    readonly BINARY: "BINARY";
};
export type WorkBinaryContentPartType = (typeof WorkBinaryContentPartType)[keyof typeof WorkBinaryContentPartType];
export declare const RelationType: {
    readonly RelationTypeDependsOn: "DEPENDS_ON";
    readonly RelationTypeParentChild: "PARENT_CHILD";
    readonly RelationTypeSpawnedBy: "SPAWNED_BY";
};
export type RelationType = (typeof RelationType)[keyof typeof RelationType];
export declare const FactoryGuardType: {
    readonly INFERENCE_THROTTLE_GUARD: "INFERENCE_THROTTLE_GUARD";
};
export type FactoryGuardType = (typeof FactoryGuardType)[keyof typeof FactoryGuardType];
export declare const WorkTypeHandlingBehavior: {
    readonly DEFAULT: "DEFAULT";
};
export type WorkTypeHandlingBehavior = (typeof WorkTypeHandlingBehavior)[keyof typeof WorkTypeHandlingBehavior];
export declare const FactoryLayoutImageSourceKind: {
    readonly EMBEDDED: "EMBEDDED";
};
export type FactoryLayoutImageSourceKind = (typeof FactoryLayoutImageSourceKind)[keyof typeof FactoryLayoutImageSourceKind];
export declare const FactoryLayoutImageSourceMediaType: {
    readonly image_png: "image/png";
    readonly image_jpeg: "image/jpeg";
    readonly image_webp: "image/webp";
};
export type FactoryLayoutImageSourceMediaType = (typeof FactoryLayoutImageSourceMediaType)[keyof typeof FactoryLayoutImageSourceMediaType];
export declare const FactoryLayoutNoteTone: {
    readonly NEUTRAL: "NEUTRAL";
    readonly ACCENT: "ACCENT";
    readonly INFO: "INFO";
    readonly SUCCESS: "SUCCESS";
    readonly WARNING: "WARNING";
    readonly DANGER: "DANGER";
};
export type FactoryLayoutNoteTone = (typeof FactoryLayoutNoteTone)[keyof typeof FactoryLayoutNoteTone];
export declare const FactoryLayoutAnnotationKind: {
    readonly NOTE: "NOTE";
    readonly IMAGE: "IMAGE";
};
export type FactoryLayoutAnnotationKind = (typeof FactoryLayoutAnnotationKind)[keyof typeof FactoryLayoutAnnotationKind];
export declare const FactoryLayoutAnnotationOneOf0Kind: {
    readonly NOTE: "NOTE";
};
export type FactoryLayoutAnnotationOneOf0Kind = (typeof FactoryLayoutAnnotationOneOf0Kind)[keyof typeof FactoryLayoutAnnotationOneOf0Kind];
export declare const FactoryLayoutAnnotationOneOf1Kind: {
    readonly IMAGE: "IMAGE";
};
export type FactoryLayoutAnnotationOneOf1Kind = (typeof FactoryLayoutAnnotationOneOf1Kind)[keyof typeof FactoryLayoutAnnotationOneOf1Kind];
export declare const FactoryLayoutPreferencesDirection: {
    readonly UP: "UP";
    readonly DOWN: "DOWN";
    readonly LEFT: "LEFT";
    readonly RIGHT: "RIGHT";
};
export type FactoryLayoutPreferencesDirection = (typeof FactoryLayoutPreferencesDirection)[keyof typeof FactoryLayoutPreferencesDirection];
export declare const HostedWorkerProvider: {
    readonly LINEAR: "LINEAR";
};
export type HostedWorkerProvider = (typeof HostedWorkerProvider)[keyof typeof HostedWorkerProvider];
export declare const InputGuardType: {
    readonly VISIT_COUNT: "VISIT_COUNT";
    readonly ALL_CHILDREN_COMPLETE: "ALL_CHILDREN_COMPLETE";
    readonly ANY_CHILD_FAILED: "ANY_CHILD_FAILED";
    readonly SAME_NAME: "SAME_NAME";
    readonly SAME_TRACE_ID: "SAME_TRACE_ID";
};
export type InputGuardType = (typeof InputGuardType)[keyof typeof InputGuardType];
export declare const WorkstationGuardType: {
    readonly VISIT_COUNT: "VISIT_COUNT";
    readonly MATCHES_FIELDS: "MATCHES_FIELDS";
};
export type WorkstationGuardType = (typeof WorkstationGuardType)[keyof typeof WorkstationGuardType];
export declare const GlobalConfigACPIntegrationTransport: {
    readonly stdio: "stdio";
};
export type GlobalConfigACPIntegrationTransport = (typeof GlobalConfigACPIntegrationTransport)[keyof typeof GlobalConfigACPIntegrationTransport];
export declare const ComponentsParametersSortBy: {
    readonly state_type: "state.type";
};
export type ComponentsParametersSortBy = (typeof ComponentsParametersSortBy)[keyof typeof ComponentsParametersSortBy];