@opensoftware/contracts 2.2.0 → 2.4.0

package/dist/generated/types.d.ts

@@ -1,4 +1,24 @@
 export type paths = {
+    "/v1/doctor/pings/{id}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * @description The `doctor.ping@v1` event with this ID, when the foreman's consumer received it since the server started (ADR
+         *     0120). `console doctor --deep` asks for it after it published the event.
+         */
+        get: operations["ForemanApi_getDoctorPing"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/v1/gates": {
         parameters: {
             query?: never;
@@ -33,6 +53,26 @@ export type paths = {
         patch?: never;
         trace?: never;
     };
+    "/v1/gates/{gateId}/decisions": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * @description A person decides a pending gate (ADR 0118): 403 when they are in no group the gate waits for, 409 when the gate
+         *     is no longer pending.
+         */
+        post: operations["GatekeeperApi_decideGate"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/v1/health": {
         parameters: {
             query?: never;
@@ -57,7 +97,10 @@ export type paths = {
             path?: never;
             cookie?: never;
         };
-        /** @description The 50 latest work items, the one received last first; with `status`, only the work items in that status. */
+        /**
+         * @description A page of the latest work items, the one received last first; with `status`, only the work items in that status.
+         *     `limit` work items at most, 50 by default; `cursor` is the `next` of the page before (ADR 0115).
+         */
         get: operations["IntakeApi_listWorkItems"];
         put?: never;
         post?: never;
@@ -74,10 +117,14 @@ export type paths = {
             path?: never;
             cookie?: never;
         };
-        /** @description The runs of the server, running runs first, then the runs that ended, the one that ended last first; with `state`, only the runs in that state (ADR 0071). */
+        /**
+         * @description A page of the runs of the server, running runs first, then the runs that ended, the one that ended last first; with
+         *     `state`, only the runs in that state (ADR 0071). `limit` runs at most, 50 by default; `cursor` is the `next` of the
+         *     page before (ADR 0115). With `state`, a page may hold fewer runs than `limit` and still have a `next`.
+         */
         get: operations["ForemanApi_listRuns"];
         put?: never;
-        /** @description Start a run of the factory's workflow for a work item. The same work item again answers the run it started. */
+        /** @description Start a run of the factory's workflow for a work item. The same work item again answers its newest run. */
         post: operations["ForemanApi_startRun"];
         delete?: never;
         options?: never;
@@ -102,6 +149,23 @@ export type paths = {
         patch?: never;
         trace?: never;
     };
+    "/v1/runs/{runId}/retry": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** @description Run a run that failed or was cancelled again, as a new run that names it (ADR 0105). */
+        post: operations["ForemanApi_retryRun"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/v1/runs/{runId}/signals": {
         parameters: {
             query?: never;
@@ -171,6 +235,18 @@ export type components = {
          * @enum {string}
          */
         ActorKind: "person" | "trigger";
+        /** @description foreman: a run of the factory's workflow for one work item, as the HTTP API shows it (ADR 0067).An adapter of the factory's `providers` and the version a run of it asks for (ADR 0110). */
+        AdapterVersion: {
+            /** @description The port under `providers`: harness, sandbox, forge or inference. */
+            port: "harness" | "sandbox" | "forge" | "inference";
+            name: string;
+            /** @description The exact version that factory.lock pins for the range under `providers.<port>.<name>`, else that range (ADR 0125). */
+            version?: string;
+            /** @description The command line the foreman builds when no map names the adapter: npx at the version. */
+            command?: string[];
+            /** @description The variable whose map gives the adapter's command line instead, for example "FOREMAN_HARNESSES". */
+            configured?: string;
+        };
         Agent: {
             description?: string;
             /** @description Harness adapter, declared under `providers.harness`, for example "claude-code". */
@@ -231,6 +307,11 @@ export type components = {
             /** @description Five-field cron expression in UTC. Without it the suite runs on request. */
             schedule?: string;
         };
+        /**
+         * @description What a blocked stage waits for: the checks of the run's pull request. A gate has its own `gate.requested@v1`.
+         * @enum {string}
+         */
+        BlockedOn: "checks";
         /** @description A path inside the bundle: relative, forward slashes, no "..". */
         BundlePath: string;
         /** @description The name of a check on the forge: a commit status context. */
@@ -247,6 +328,43 @@ export type components = {
         };
         /** @description A Git commit hash, abbreviated (7+) or full. The factory version is the commit of the factory definition. */
         CommitHash: string;
+        /**
+         * @description console: `console doctor --deep` checks that an event reaches the foreman (ADR 0120). The ID is fresh and random;
+         *     the foreman shows it on `GET /v1/doctor/pings/{id}` and acts on nothing else.
+         */
+        DoctorPing: {
+            /** @constant */
+            specversion: "1.0";
+            /** @description Unique per source. A consumer that sees the same source and id twice handles the event once. */
+            id: components["schemas"]["Identifier"];
+            /** @description The producing module, for example "/osf/intake". */
+            source: string;
+            /** @constant */
+            type: "doctor.ping@v1";
+            /** Format: date-time */
+            time: string;
+            /** @description The ID of the thing the event is about: work item, gate, run, score or pull request. */
+            subject?: string;
+            /** @constant */
+            datacontenttype?: "application/json";
+            /** Format: uri */
+            dataschema?: string;
+            /** @description W3C trace context (CloudEvents distributed tracing extension). */
+            traceparent?: string;
+            data: components["schemas"]["DoctorPingData"];
+        };
+        /** @description A ping carries nothing but its ID. */
+        DoctorPingData: Record<string, never>;
+        /** @description foreman: a `doctor.ping@v1` event that its consumer received (ADR 0120). */
+        DoctorPingSeen: {
+            /** @description The event's ID. */
+            id: components["schemas"]["Identifier"];
+            /**
+             * Format: date-time
+             * @description When the foreman received it.
+             */
+            receivedAt: string;
+        };
         /**
          * @description The effort level of an agent's model, from the least to the most thinking (ADR 0078).
          * @enum {string}
@@ -303,7 +421,7 @@ export type components = {
             agents: {
                 [key: string]: components["schemas"]["Agent"];
             };
-            /** @description Stages in order. Each stage runs one agent; the agent defaults to the stage name. */
+            /** @description Stages in order. Each stage runs one agent, which defaults to the stage name, or only waits (ADR 0107). */
             workflow?: components["schemas"]["Stage"][];
             /** @description What starts work without a person asking. */
             automations?: components["schemas"]["Automation"][];
@@ -316,6 +434,52 @@ export type components = {
                 [key: string]: components["schemas"]["Benchmark"];
             };
         };
+        /**
+         * @description factory.lock next to factory.yaml (ADR 0020, ADR 0125): the exact versions that `factory plan` pinned. factory-spec
+         *     writes it; the foreman reads the pins of its adapters.
+         */
+        FactoryLock: {
+            /**
+             * @description The version of the lock's format.
+             * @constant
+             */
+            version: 1;
+            /** @description The registry MCP servers, by their reference in factory.yaml, for example `registry:io.github.acme/tracker@1.4`. */
+            mcp: {
+                [key: string]: components["schemas"]["FactoryLockMcpPin"];
+            };
+            /**
+             * @description The adapters under `providers` that `factory plan --adapters` pinned, per port and adapter name (ADR 0125). A pin
+             *     counts only while its `range` is the range factory.yaml declares.
+             */
+            adapters?: {
+                [key: string]: {
+                    [key: string]: components["schemas"]["FactoryLockAdapterPin"];
+                };
+            };
+        };
+        /** @description One adapter's npm package `@opensoftware/<port>-<name>` at the newest version inside its range. */
+        FactoryLockAdapterPin: {
+            /** @description The range under `providers` that the pin was resolved from, for example "^2". */
+            range: string;
+            /** @description The exact version, for example "2.3.1". */
+            version: string;
+        };
+        /** @description One registry MCP server at its exact version, with the npm package or the remote it starts. */
+        FactoryLockMcpPin: {
+            name: string;
+            version: string;
+            package?: {
+                /** @constant */
+                registryType: "npm";
+                identifier: string;
+                version: string;
+            };
+            remote?: {
+                type: string;
+                url: string;
+            };
+        };
         /**
          * @description The version of a format inside its documents. Only 1 exists; a new major version of a format adds the next.
          * @constant
@@ -361,6 +525,17 @@ export type components = {
         };
         /** @enum {string} */
         GateDecision: "approved" | "rejected" | "expired";
+        /**
+         * @description gatekeeper: a person's decision of a pending gate through the API, as a member of a group the gate waits for
+         *     (ADR 0118). It decides like a reply "approve" or "reject <reason>" in the gate's channel.
+         */
+        GateDecisionRequest: {
+            decision: "approved" | "rejected";
+            /** @description The person who decides; their `id` must be a member of a group in `waitingFor`. */
+            by: components["schemas"]["Actor"];
+            /** @description The reason of a rejection. */
+            reason?: string;
+        };
         /** @description gatekeeper: who decided what and when, signed with Ed25519 (ADR 0047). */
         GateRecord: {
             gate: string;
@@ -702,6 +877,57 @@ export type components = {
         };
         /** @enum {string} */
         ReviewState: "approved" | "changes_requested" | "commented";
+        /** @description foreman: a signal a person sent a run, as the run records it (ADR 0118). */
+        RunAction: {
+            type: components["schemas"]["RunSignalType"];
+            /** @description The person who sent it. */
+            by: components["schemas"]["Actor"];
+            /**
+             * Format: date-time
+             * @description When the foreman took it.
+             */
+            at: string;
+            /** @description The steering message of "steer". */
+            message?: string;
+        };
+        /** @description foreman: a stage of a run waits for the checks of its pull request (ADR 0127). The ID is `<run ID>.blocked.<stage>`. */
+        RunBlocked: {
+            /** @constant */
+            specversion: "1.0";
+            /** @description Unique per source. A consumer that sees the same source and id twice handles the event once. */
+            id: components["schemas"]["Identifier"];
+            /** @description The producing module, for example "/osf/intake". */
+            source: string;
+            /** @constant */
+            type: "run.blocked@v1";
+            /** Format: date-time */
+            time: string;
+            /** @description The ID of the thing the event is about: work item, gate, run, score or pull request. */
+            subject?: string;
+            /** @constant */
+            datacontenttype?: "application/json";
+            /** Format: uri */
+            dataschema?: string;
+            /** @description W3C trace context (CloudEvents distributed tracing extension). */
+            traceparent?: string;
+            data: components["schemas"]["RunBlockedData"];
+        };
+        RunBlockedData: {
+            runId: components["schemas"]["Identifier"];
+            workItemId: components["schemas"]["Identifier"];
+            /** @description The stage that waits. */
+            stage: components["schemas"]["Name"];
+            waitsFor: components["schemas"]["BlockedOn"];
+            /**
+             * Format: uri
+             * @description The pull request whose checks the stage waits for.
+             */
+            pullRequest?: string;
+            /** @description The names of the checks the stage waits for. */
+            checks?: string[];
+            requester: components["schemas"]["Actor"];
+            source: components["schemas"]["Name"];
+        };
         /** @description foreman: a run ended. */
         RunCompleted: {
             /** @constant */
@@ -741,10 +967,16 @@ export type components = {
             pullRequests?: string[];
             /** Format: uri */
             evidenceBundle?: string;
+            /** @description The run before, when this run runs a work item again (ADR 0105). */
+            retryOf?: components["schemas"]["Identifier"];
+            /** @description Why the stage the run ended at failed, when the foreman knows it (ADR 0127). */
+            reason?: string;
         };
         /** @description foreman: the runs of the server, running runs first, then the runs that ended, the one that ended last first, as `GET /v1/runs` answers them (ADR 0071). */
         RunList: {
             runs: components["schemas"]["RunView"][];
+            /** @description The cursor of the next page, while more runs follow (ADR 0115). */
+            next?: string;
         };
         /**
          * @description How a run ended.
@@ -778,6 +1010,15 @@ export type components = {
             "osf.harness.name": components["schemas"]["Name"];
             "osf.harness.version"?: string;
         };
+        /**
+         * @description foreman: run a run that failed or was cancelled again, as a new run (ADR 0105). The new run starts at the first stage
+         *     that did not succeed, or at `from`, a stage at or before it.
+         */
+        RunRetry: {
+            /** @description The person who asks. */
+            by: components["schemas"]["Actor"];
+            from?: components["schemas"]["Name"];
+        };
         /**
          * @description foreman: a signal to a run: "steer" with a message for the running stage's agent, "cancel", "take-over" of the running
          *     stage by a person, or "hand-back" of that stage (ADR 0070).
@@ -786,6 +1027,8 @@ export type components = {
             type: components["schemas"]["RunSignalType"];
             /** @description The steering message. Required with "steer". */
             message?: string;
+            /** @description The person who sends the signal; the run then records it in `actions` (ADR 0118). */
+            by?: components["schemas"]["Actor"];
         };
         /**
          * @description foreman: what a person tells a run.
@@ -860,25 +1103,34 @@ export type components = {
             startedAt: string;
             requester: components["schemas"]["Actor"];
             source: components["schemas"]["Name"];
+            /** @description The run before, when this run runs a work item again (ADR 0105). */
+            retryOf?: components["schemas"]["Identifier"];
         };
         /**
          * @description foreman: where a run stands (vision scenario ORCH-008).
          * @enum {string}
          */
         RunState: "running" | "blocked" | "complete" | "failed" | "cancelled";
-        /** @description foreman: a run of the factory's workflow for one work item, as the HTTP API shows it (ADR 0067). */
         RunView: {
-            /** @description "run_" and 20 hex digits of the SHA-256 of the work item's ID. */
+            /** @description "run_" and 20 hex digits of the SHA-256 of the work item's ID; for the n-th run of the work item, n ≥ 2, of "<work item ID>#<n>" (ADR 0105). */
             runId: string;
+            /** @description Which run of the work item this is: 1 when absent (ADR 0105). */
+            attempt?: number;
+            /** @description The run before this one, which a person ran again (ADR 0105). */
+            retryOf?: string;
+            /** @description The person who ran the run before again (ADR 0105). */
+            retriedBy?: components["schemas"]["Actor"];
             workItem: components["schemas"]["WorkItem"];
             /** @description The name of the factory. */
             factory: components["schemas"]["Name"];
             /** @description The commit of the factory definition the run started with. */
             factoryVersion: components["schemas"]["CommitHash"];
+            /** @description The adapters of the factory's `providers` and the versions the run asks for (ADR 0110). */
+            adapters?: components["schemas"]["AdapterVersion"][];
             state: components["schemas"]["RunState"];
             /**
              * Format: uri
-             * @description The last pull request link that an agent of the run wrote (ADR 0069).
+             * @description The run's pull request: the forge's of the run's branch, the one an agent stated, or else the last link an agent wrote (ADR 0069, ADR 0109).
              */
             pullRequest?: string;
             /** @description The run's folder on the foreman's machine, where a person who took over a stage goes on (ADR 0070). */
@@ -891,6 +1143,8 @@ export type components = {
             traceId?: components["schemas"]["TraceId"];
             /** @description The stages of the workflow, in order. */
             stages: components["schemas"]["StageView"][];
+            /** @description The signals that named their person, oldest first (ADR 0118). */
+            actions?: components["schemas"]["RunAction"][];
         };
         Sandbox: {
             /** @description Sandbox template name, for example "node-24". */
@@ -1033,6 +1287,11 @@ export type components = {
             checks?: components["schemas"]["CheckName"][];
             /** @description Whether the stage must produce an evidence bundle. */
             evidence?: components["schemas"]["EvidenceRequirement"];
+            /**
+             * @description The stage runs no agent: it only waits for its checks, its evidence and its gate, then succeeds (ADR 0107). It
+             *     names no agent and at least one of checks, evidence "required" or gate.
+             */
+            wait?: boolean;
         };
         /**
          * @description foreman: where a stage of a run stands.
@@ -1042,15 +1301,27 @@ export type components = {
         /** @description foreman: one stage of a run (ADR 0067). */
         StageView: {
             stage: components["schemas"]["Name"];
-            /** @description The agent that runs the stage. */
+            /** @description The agent that runs the stage; the stage's name for a stage that only waits (ADR 0107). */
             agent: components["schemas"]["Name"];
+            /** @description True for a stage that only waits: it runs no agent and starts no session (ADR 0107). */
+            wait?: boolean;
             state: components["schemas"]["StageState"];
             /** @description The harness session of the stage's agent, once it started. */
             sessionId?: string;
+            /**
+             * @description The span of the stage in the run's trace, once it started: the first 16 hex digits of the SHA-256 of
+             *     `<runId>:<stage index>` (ADR 0087, ADR 0121).
+             */
+            spanId?: string;
             /** @description The gate that decides whether the stage starts, once it was requested. */
             gateId?: string;
             /** @description The checks the stage waits for, once the foreman read them (ADR 0069). */
             checks?: components["schemas"]["CheckView"][];
+            /**
+             * Format: date-time
+             * @description Since when the stage waits for its checks, its gate or a person, while it is blocked (ADR 0106).
+             */
+            waitingSince?: string;
             /**
              * Format: date-time
              * @description When a person took the stage over from its agent (ADR 0070).
@@ -1058,6 +1329,8 @@ export type components = {
             takenOverAt?: string;
             /** @description Why the stage ended without success, when the foreman knows. */
             reason?: string;
+            /** @description Why the stage gave the run no pull request: a refused link, a branch the forge has none of, or the forge adapter's error (ADR 0109). */
+            note?: string;
             /** Format: date-time */
             startedAt?: string;
             /** Format: date-time */
@@ -1091,6 +1364,8 @@ export type components = {
         /** @description intake: the latest work items, as `GET /v1/inbox` answers them, the one received last first. */
         WorkItemList: {
             workItems: components["schemas"]["WorkItemView"][];
+            /** @description The cursor of the next page, while more work items follow (ADR 0115). */
+            next?: string;
         };
         /**
          * @description Where a work item stands: received, then as its run in the foreman goes (ADR 0071).
@@ -1140,6 +1415,35 @@ export type components = {
             /** Format: date-time */
             receivedAt: string;
         };
+        /** @description intake: a person asked to run a work item's run again (ADR 0105). The ID is `<run ID>.retry`. */
+        WorkRetryRequested: {
+            /** @constant */
+            specversion: "1.0";
+            /** @description Unique per source. A consumer that sees the same source and id twice handles the event once. */
+            id: components["schemas"]["Identifier"];
+            /** @description The producing module, for example "/osf/intake". */
+            source: string;
+            /** @constant */
+            type: "work.retry-requested@v1";
+            /** Format: date-time */
+            time: string;
+            /** @description The ID of the thing the event is about: work item, gate, run, score or pull request. */
+            subject?: string;
+            /** @constant */
+            datacontenttype?: "application/json";
+            /** Format: uri */
+            dataschema?: string;
+            /** @description W3C trace context (CloudEvents distributed tracing extension). */
+            traceparent?: string;
+            data: components["schemas"]["WorkRetryRequestedData"];
+        };
+        WorkRetryRequestedData: {
+            workItemId: components["schemas"]["Identifier"];
+            /** @description The run to run again: the run the work item follows. */
+            runId: components["schemas"]["Identifier"];
+            /** @description The person who asked. */
+            requester: components["schemas"]["Actor"];
+        };
         /** @description intake: work to put into the inbox, a work item without its ID (ADR 0063). */
         WorkSubmission: {
             /** @description Default: task. */
@@ -1162,6 +1466,46 @@ export type components = {
 };
 export type $defs = Record<string, never>;
 export interface operations {
+    ForemanApi_getDoctorPing: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description The request has succeeded. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["DoctorPingSeen"];
+                };
+            };
+            /** @description Access is unauthorized. */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/problem+json": components["schemas"]["ApiProblem"];
+                };
+            };
+            /** @description The server cannot find the requested resource. */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/problem+json": components["schemas"]["ApiProblem"];
+                };
+            };
+        };
+    };
     GatekeeperApi_requestGate: {
         parameters: {
             query?: never;
@@ -1253,6 +1597,77 @@ export interface operations {
             };
         };
     };
+    GatekeeperApi_decideGate: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                gateId: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["GateDecisionRequest"];
+            };
+        };
+        responses: {
+            /** @description The request has succeeded. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["GateView"];
+                };
+            };
+            /** @description The server could not understand the request due to invalid syntax. */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/problem+json": components["schemas"]["ApiProblem"];
+                };
+            };
+            /** @description Access is unauthorized. */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/problem+json": components["schemas"]["ApiProblem"];
+                };
+            };
+            /** @description Access is forbidden. */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/problem+json": components["schemas"]["ApiProblem"];
+                };
+            };
+            /** @description The server cannot find the requested resource. */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/problem+json": components["schemas"]["ApiProblem"];
+                };
+            };
+            /** @description The request conflicts with the current state of the server. */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/problem+json": components["schemas"]["ApiProblem"];
+                };
+            };
+        };
+    };
     HealthApi_getHealth: {
         parameters: {
             query?: never;
@@ -1286,6 +1701,8 @@ export interface operations {
         parameters: {
             query?: {
                 status?: components["schemas"]["WorkItemStatus"];
+                limit?: number;
+                cursor?: string;
             };
             header?: never;
             path?: never;
@@ -1326,6 +1743,8 @@ export interface operations {
         parameters: {
             query?: {
                 state?: components["schemas"]["RunState"];
+                limit?: number;
+                cursor?: string;
             };
             header?: never;
             path?: never;
@@ -1453,6 +1872,68 @@ export interface operations {
             };
         };
     };
+    ForemanApi_retryRun: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                runId: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["RunRetry"];
+            };
+        };
+        responses: {
+            /** @description The request has succeeded and a new resource has been created as a result. */
+            201: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["RunView"];
+                };
+            };
+            /** @description The server could not understand the request due to invalid syntax. */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/problem+json": components["schemas"]["ApiProblem"];
+                };
+            };
+            /** @description Access is unauthorized. */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/problem+json": components["schemas"]["ApiProblem"];
+                };
+            };
+            /** @description The server cannot find the requested resource. */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/problem+json": components["schemas"]["ApiProblem"];
+                };
+            };
+            /** @description The request conflicts with the current state of the server. */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/problem+json": components["schemas"]["ApiProblem"];
+                };
+            };
+        };
+    };
     ForemanApi_signalRun: {
         parameters: {
             query?: never;