@qawolf/api-contracts 0.1.0 → 0.11.0

package/dist/v1/index.d.ts

@@ -1,6 +1,7 @@
 import type { z } from "zod";
 export type { AnyPublicApiContract, PublicApiContract, PublicApiContractKind, } from "./definition.js";
 export { type PublicIdSchema, type PublicIdSchemas, defaultIdSchemas, } from "./ids.js";
+export { makeFlowSelectionSchema } from "./run/index.js";
 import type { AnyPublicApiContract } from "./definition.js";
 import { type PublicIdSchema, type PublicIdSchemasOf } from "./ids.js";
 export type PublicApiInput<Api extends AnyPublicApiContract> = z.input<Api["input"]>;
@@ -12,38 +13,802 @@ export type PublicApiOutput<Api extends AnyPublicApiContract> = z.infer<Api["out
  * the same factory with its own strict id schemas, so the contract shape can
  * never drift between the two while validation strictness stays server-owned.
  */
-export declare const makeContractsV1: <EnvironmentId extends PublicIdSchema, FlowId extends PublicIdSchema, RunId extends PublicIdSchema>(ids: PublicIdSchemasOf<EnvironmentId, FlowId, RunId>) => {
-    run: {
+export declare const makeContractsV1: <EnvironmentId extends PublicIdSchema, FlowId extends PublicIdSchema, RunId extends PublicIdSchema, AutomationId extends PublicIdSchema = PublicIdSchema, IssueId extends PublicIdSchema = PublicIdSchema, WorkspaceId extends PublicIdSchema = PublicIdSchema>(ids: PublicIdSchemasOf<EnvironmentId, FlowId, RunId, AutomationId, IssueId, WorkspaceId>) => {
+    automate: {
+        readonly description: "Request an automation that builds the selected draft flows in an environment.";
+        readonly input: z.ZodObject<{
+            environmentId: EnvironmentId;
+            flowIds: z.ZodArray<FlowId>;
+            patch: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        readonly kind: "write";
+        readonly name: "automate";
+        readonly output: z.ZodObject<{
+            automationId: AutomationId;
+            url: z.ZodURL;
+        }, z.core.$strip>;
+    };
+    environment: {
         create: {
-            readonly description: "Create a run for selected flows in an environment.";
+            readonly description: "Create an environment on the caller's team and return it in the environment.get shape.";
+            readonly input: z.ZodObject<{
+                name: z.ZodString;
+            }, z.core.$strip>;
+            readonly kind: "write";
+            readonly name: "environment.create";
+            readonly output: z.ZodObject<{
+                environmentId: EnvironmentId;
+                flowCodeBranch: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    lastSyncedCommitHash: z.ZodString;
+                    name: z.ZodString;
+                    syncStatus: z.ZodLiteral<"reconciled">;
+                }, z.core.$strip>, z.ZodObject<{
+                    name: z.ZodString;
+                    syncStatus: z.ZodLiteral<"not-reconciled">;
+                }, z.core.$strip>], "syncStatus">>;
+                kind: z.ZodEnum<{
+                    static: "static";
+                    preview: "preview";
+                }>;
+                name: z.ZodString;
+                status: z.ZodEnum<{
+                    blocked: "blocked";
+                    "needs-investigation": "needs-investigation";
+                    ready: "ready";
+                    running: "running";
+                }>;
+                terminatedAt: z.ZodOptional<z.ZodISODateTime>;
+                url: z.ZodURL;
+            }, z.core.$strip>;
+        };
+        get: {
+            readonly description: "Read a single environment's name, kind, health status, and termination state.";
             readonly input: z.ZodObject<{
                 environmentId: EnvironmentId;
+            }, z.core.$strip>;
+            readonly kind: "read";
+            readonly name: "environment.get";
+            readonly output: z.ZodObject<{
+                environmentId: EnvironmentId;
+                flowCodeBranch: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    lastSyncedCommitHash: z.ZodString;
+                    name: z.ZodString;
+                    syncStatus: z.ZodLiteral<"reconciled">;
+                }, z.core.$strip>, z.ZodObject<{
+                    name: z.ZodString;
+                    syncStatus: z.ZodLiteral<"not-reconciled">;
+                }, z.core.$strip>], "syncStatus">>;
+                kind: z.ZodEnum<{
+                    static: "static";
+                    preview: "preview";
+                }>;
+                name: z.ZodString;
+                status: z.ZodEnum<{
+                    blocked: "blocked";
+                    "needs-investigation": "needs-investigation";
+                    ready: "ready";
+                    running: "running";
+                }>;
+                terminatedAt: z.ZodOptional<z.ZodISODateTime>;
+                url: z.ZodURL;
+            }, z.core.$strip>;
+        };
+        listVariableNames: {
+            readonly description: "List the names of an environment's variables, sorted. Names only — values never leave the server.";
+            readonly input: z.ZodObject<{
+                environmentId: EnvironmentId;
+            }, z.core.$strip>;
+            readonly kind: "read";
+            readonly name: "environment.listVariableNames";
+            readonly output: z.ZodObject<{
+                variableNames: z.ZodArray<z.ZodString>;
+            }, z.core.$strip>;
+        };
+    };
+    flow: {
+        list: {
+            readonly description: "List the flows of an environment at its latest reconciled commit.";
+            readonly input: z.ZodObject<{
+                environmentId: EnvironmentId;
+                includeDrafts: z.ZodDefault<z.ZodBoolean>;
+            }, z.core.$strip>;
+            readonly kind: "read";
+            readonly name: "flow.list";
+            readonly output: z.ZodObject<{
+                flows: z.ZodArray<z.ZodObject<{
+                    executionTarget: z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>]>;
+                    flowId: FlowId;
+                    name: z.ZodString;
+                    path: z.ZodString;
+                    tags: z.ZodArray<z.ZodString>;
+                    url: z.ZodURL;
+                }, z.core.$strip>>;
+            }, z.core.$strip>;
+        };
+    };
+    issue: {
+        create: {
+            readonly description: string;
+            readonly input: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                type: z.ZodLiteral<"bug">;
+                description: z.ZodOptional<z.ZodString>;
+                name: z.ZodString;
+                priority: z.ZodOptional<z.ZodEnum<{
+                    unprioritized: "unprioritized";
+                    low: "low";
+                    medium: "medium";
+                    high: "high";
+                    urgent: "urgent";
+                }>>;
+            }, z.core.$strip>, z.ZodObject<{
+                estimatedDueDate: z.ZodOptional<z.ZodISODate>;
+                type: z.ZodLiteral<"coverageRequest">;
+                description: z.ZodOptional<z.ZodString>;
+                name: z.ZodString;
+                priority: z.ZodOptional<z.ZodEnum<{
+                    unprioritized: "unprioritized";
+                    low: "low";
+                    medium: "medium";
+                    high: "high";
+                    urgent: "urgent";
+                }>>;
+            }, z.core.$strip>], "type">;
+            readonly kind: "write";
+            readonly name: "issue.create";
+            readonly output: z.ZodObject<{
+                issue: z.ZodObject<{
+                    createdAt: z.ZodCoercedDate<unknown>;
+                    description: z.ZodString;
+                    issueId: IssueId;
+                    name: z.ZodString;
+                    number: z.ZodNumber;
+                    priority: z.ZodEnum<{
+                        unprioritized: "unprioritized";
+                        low: "low";
+                        medium: "medium";
+                        high: "high";
+                        urgent: "urgent";
+                    }>;
+                    reproductions: z.ZodArray<z.ZodObject<{
+                        environmentId: EnvironmentId;
+                        firstReproducedInRunId: RunId;
+                        flowId: FlowId;
+                        isActive: z.ZodBoolean;
+                        lastReproducedInRunId: RunId;
+                    }, z.core.$strip>>;
+                    status: z.ZodEnum<{
+                        pending: "pending";
+                        inProgress: "inProgress";
+                        paused: "paused";
+                        resolved: "resolved";
+                        canceled: "canceled";
+                        archived: "archived";
+                    }>;
+                    type: z.ZodEnum<{
+                        bug: "bug";
+                        coverageRequest: "coverageRequest";
+                        maintenance: "maintenance";
+                    }>;
+                    url: z.ZodURL;
+                }, z.core.$strip>;
+            }, z.core.$strip>;
+        };
+        find: {
+            readonly description: "List the team's bug reports, maintenance reports, or coverage requests, newest first.";
+            readonly input: z.ZodObject<{
+                statuses: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+                    pending: "pending";
+                    inProgress: "inProgress";
+                    paused: "paused";
+                    resolved: "resolved";
+                    canceled: "canceled";
+                    archived: "archived";
+                }>>>;
+                type: z.ZodEnum<{
+                    bug: "bug";
+                    coverageRequest: "coverageRequest";
+                    maintenance: "maintenance";
+                }>;
+                cursor: z.ZodOptional<z.ZodString>;
+                limit: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strip>;
+            readonly kind: "read";
+            readonly name: "issue.find";
+            readonly output: z.ZodObject<{
+                issues: z.ZodArray<z.ZodObject<{
+                    createdAt: z.ZodCoercedDate<unknown>;
+                    description: z.ZodString;
+                    issueId: IssueId;
+                    name: z.ZodString;
+                    number: z.ZodNumber;
+                    priority: z.ZodEnum<{
+                        unprioritized: "unprioritized";
+                        low: "low";
+                        medium: "medium";
+                        high: "high";
+                        urgent: "urgent";
+                    }>;
+                    reproductions: z.ZodArray<z.ZodObject<{
+                        environmentId: EnvironmentId;
+                        firstReproducedInRunId: RunId;
+                        flowId: FlowId;
+                        isActive: z.ZodBoolean;
+                        lastReproducedInRunId: RunId;
+                    }, z.core.$strip>>;
+                    status: z.ZodEnum<{
+                        pending: "pending";
+                        inProgress: "inProgress";
+                        paused: "paused";
+                        resolved: "resolved";
+                        canceled: "canceled";
+                        archived: "archived";
+                    }>;
+                    type: z.ZodEnum<{
+                        bug: "bug";
+                        coverageRequest: "coverageRequest";
+                        maintenance: "maintenance";
+                    }>;
+                    url: z.ZodURL;
+                }, z.core.$strip>>;
+                nextCursor: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>;
+        };
+        get: {
+            readonly description: "Get an issue by id.";
+            readonly input: z.ZodObject<{
+                issueId: IssueId;
+            }, z.core.$strip>;
+            readonly kind: "read";
+            readonly name: "issue.get";
+            readonly output: z.ZodObject<{
+                issue: z.ZodObject<{
+                    createdAt: z.ZodCoercedDate<unknown>;
+                    description: z.ZodString;
+                    issueId: IssueId;
+                    name: z.ZodString;
+                    number: z.ZodNumber;
+                    priority: z.ZodEnum<{
+                        unprioritized: "unprioritized";
+                        low: "low";
+                        medium: "medium";
+                        high: "high";
+                        urgent: "urgent";
+                    }>;
+                    reproductions: z.ZodArray<z.ZodObject<{
+                        environmentId: EnvironmentId;
+                        firstReproducedInRunId: RunId;
+                        flowId: FlowId;
+                        isActive: z.ZodBoolean;
+                        lastReproducedInRunId: RunId;
+                    }, z.core.$strip>>;
+                    status: z.ZodEnum<{
+                        pending: "pending";
+                        inProgress: "inProgress";
+                        paused: "paused";
+                        resolved: "resolved";
+                        canceled: "canceled";
+                        archived: "archived";
+                    }>;
+                    type: z.ZodEnum<{
+                        bug: "bug";
+                        coverageRequest: "coverageRequest";
+                        maintenance: "maintenance";
+                    }>;
+                    url: z.ZodURL;
+                }, z.core.$strip>;
+            }, z.core.$strip>;
+        };
+    };
+    run: {
+        create: {
+            readonly description: "Create a run for the selected flows and/or tags in an environment.";
+            readonly input: z.ZodIntersection<z.ZodObject<{
+                environmentId: EnvironmentId;
                 environmentVariables: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-                flowIds: z.ZodArray<FlowId>;
                 ignoreRules: z.ZodDefault<z.ZodBoolean>;
-            }, z.core.$strip>;
+                pullRequestNumber: z.ZodOptional<z.ZodNumber>;
+                repository: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>, z.ZodObject<{
+                flowIds: z.ZodDefault<z.ZodArray<FlowId>>;
+                tagNames: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>>;
             readonly kind: "write";
             readonly name: "run.create";
             readonly output: z.ZodObject<{
                 runId: RunId;
+                url: z.ZodURL;
+            }, z.core.$strip>;
+        };
+        find: {
+            readonly description: "List an environment's recent runs, newest first.";
+            readonly input: z.ZodObject<{
+                environmentId: EnvironmentId;
+                cursor: z.ZodOptional<z.ZodString>;
+                limit: z.ZodDefault<z.ZodNumber>;
+                createdAfter: z.ZodOptional<z.ZodISODateTime>;
+            }, z.core.$strip>;
+            readonly kind: "read";
+            readonly name: "run.find";
+            readonly output: z.ZodObject<{
+                nextCursor: z.ZodOptional<z.ZodString>;
+                runs: z.ZodArray<z.ZodObject<{
+                    completedAt: z.ZodOptional<z.ZodISODateTime>;
+                    createdAt: z.ZodISODateTime;
+                    git: z.ZodObject<{
+                        branch: z.ZodOptional<z.ZodString>;
+                        commitMessage: z.ZodOptional<z.ZodString>;
+                        commitSha: z.ZodOptional<z.ZodString>;
+                        commitUrl: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>;
+                    runId: RunId;
+                    status: z.ZodEnum<{
+                        running: "running";
+                        canceled: "canceled";
+                        queued: "queued";
+                        passed: "passed";
+                        failed: "failed";
+                    }>;
+                    url: z.ZodURL;
+                }, z.core.$strip>>;
+            }, z.core.$strip>;
+        };
+        get: {
+            readonly description: "Get a run's status, per-flow results, and links.";
+            readonly input: z.ZodObject<{
+                runId: RunId;
+            }, z.core.$strip>;
+            readonly kind: "read";
+            readonly name: "run.get";
+            readonly output: z.ZodObject<{
+                flows: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    failure: z.ZodObject<{
+                        error: z.ZodString;
+                    }, z.core.$strip>;
+                    flowId: FlowId;
+                    name: z.ZodString;
+                    status: z.ZodLiteral<"failed">;
+                }, z.core.$strip>, z.ZodObject<{
+                    flowId: FlowId;
+                    name: z.ZodString;
+                    status: z.ZodEnum<{
+                        running: "running";
+                        canceled: "canceled";
+                        queued: "queued";
+                        passed: "passed";
+                    }>;
+                }, z.core.$strip>], "status">>;
+                completedAt: z.ZodOptional<z.ZodISODateTime>;
+                createdAt: z.ZodISODateTime;
+                git: z.ZodObject<{
+                    branch: z.ZodOptional<z.ZodString>;
+                    commitMessage: z.ZodOptional<z.ZodString>;
+                    commitSha: z.ZodOptional<z.ZodString>;
+                    commitUrl: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>;
+                runId: RunId;
+                status: z.ZodEnum<{
+                    running: "running";
+                    canceled: "canceled";
+                    queued: "queued";
+                    passed: "passed";
+                    failed: "failed";
+                }>;
+                url: z.ZodURL;
+            }, z.core.$strip>;
+        };
+    };
+    tag: {
+        create: {
+            readonly description: "Create a tag on the caller's team. Tags select flows in run.create.";
+            readonly input: z.ZodObject<{
+                name: z.ZodString;
+            }, z.core.$strip>;
+            readonly kind: "write";
+            readonly name: "tag.create";
+            readonly output: z.ZodObject<{
+                color: z.ZodString;
+                name: z.ZodString;
+                url: z.ZodURL;
             }, z.core.$strip>;
         };
     };
 };
 export declare const publicContractsV1: {
-    run: {
+    automate: {
+        readonly description: "Request an automation that builds the selected draft flows in an environment.";
+        readonly input: z.ZodObject<{
+            environmentId: PublicIdSchema;
+            flowIds: z.ZodArray<PublicIdSchema>;
+            patch: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        readonly kind: "write";
+        readonly name: "automate";
+        readonly output: z.ZodObject<{
+            automationId: PublicIdSchema;
+            url: z.ZodURL;
+        }, z.core.$strip>;
+    };
+    environment: {
         create: {
-            readonly description: "Create a run for selected flows in an environment.";
+            readonly description: "Create an environment on the caller's team and return it in the environment.get shape.";
+            readonly input: z.ZodObject<{
+                name: z.ZodString;
+            }, z.core.$strip>;
+            readonly kind: "write";
+            readonly name: "environment.create";
+            readonly output: z.ZodObject<{
+                environmentId: PublicIdSchema;
+                flowCodeBranch: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    lastSyncedCommitHash: z.ZodString;
+                    name: z.ZodString;
+                    syncStatus: z.ZodLiteral<"reconciled">;
+                }, z.core.$strip>, z.ZodObject<{
+                    name: z.ZodString;
+                    syncStatus: z.ZodLiteral<"not-reconciled">;
+                }, z.core.$strip>], "syncStatus">>;
+                kind: z.ZodEnum<{
+                    static: "static";
+                    preview: "preview";
+                }>;
+                name: z.ZodString;
+                status: z.ZodEnum<{
+                    blocked: "blocked";
+                    "needs-investigation": "needs-investigation";
+                    ready: "ready";
+                    running: "running";
+                }>;
+                terminatedAt: z.ZodOptional<z.ZodISODateTime>;
+                url: z.ZodURL;
+            }, z.core.$strip>;
+        };
+        get: {
+            readonly description: "Read a single environment's name, kind, health status, and termination state.";
             readonly input: z.ZodObject<{
                 environmentId: PublicIdSchema;
+            }, z.core.$strip>;
+            readonly kind: "read";
+            readonly name: "environment.get";
+            readonly output: z.ZodObject<{
+                environmentId: PublicIdSchema;
+                flowCodeBranch: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    lastSyncedCommitHash: z.ZodString;
+                    name: z.ZodString;
+                    syncStatus: z.ZodLiteral<"reconciled">;
+                }, z.core.$strip>, z.ZodObject<{
+                    name: z.ZodString;
+                    syncStatus: z.ZodLiteral<"not-reconciled">;
+                }, z.core.$strip>], "syncStatus">>;
+                kind: z.ZodEnum<{
+                    static: "static";
+                    preview: "preview";
+                }>;
+                name: z.ZodString;
+                status: z.ZodEnum<{
+                    blocked: "blocked";
+                    "needs-investigation": "needs-investigation";
+                    ready: "ready";
+                    running: "running";
+                }>;
+                terminatedAt: z.ZodOptional<z.ZodISODateTime>;
+                url: z.ZodURL;
+            }, z.core.$strip>;
+        };
+        listVariableNames: {
+            readonly description: "List the names of an environment's variables, sorted. Names only — values never leave the server.";
+            readonly input: z.ZodObject<{
+                environmentId: PublicIdSchema;
+            }, z.core.$strip>;
+            readonly kind: "read";
+            readonly name: "environment.listVariableNames";
+            readonly output: z.ZodObject<{
+                variableNames: z.ZodArray<z.ZodString>;
+            }, z.core.$strip>;
+        };
+    };
+    flow: {
+        list: {
+            readonly description: "List the flows of an environment at its latest reconciled commit.";
+            readonly input: z.ZodObject<{
+                environmentId: PublicIdSchema;
+                includeDrafts: z.ZodDefault<z.ZodBoolean>;
+            }, z.core.$strip>;
+            readonly kind: "read";
+            readonly name: "flow.list";
+            readonly output: z.ZodObject<{
+                flows: z.ZodArray<z.ZodObject<{
+                    executionTarget: z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>]>;
+                    flowId: PublicIdSchema;
+                    name: z.ZodString;
+                    path: z.ZodString;
+                    tags: z.ZodArray<z.ZodString>;
+                    url: z.ZodURL;
+                }, z.core.$strip>>;
+            }, z.core.$strip>;
+        };
+    };
+    issue: {
+        create: {
+            readonly description: string;
+            readonly input: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                type: z.ZodLiteral<"bug">;
+                description: z.ZodOptional<z.ZodString>;
+                name: z.ZodString;
+                priority: z.ZodOptional<z.ZodEnum<{
+                    unprioritized: "unprioritized";
+                    low: "low";
+                    medium: "medium";
+                    high: "high";
+                    urgent: "urgent";
+                }>>;
+            }, z.core.$strip>, z.ZodObject<{
+                estimatedDueDate: z.ZodOptional<z.ZodISODate>;
+                type: z.ZodLiteral<"coverageRequest">;
+                description: z.ZodOptional<z.ZodString>;
+                name: z.ZodString;
+                priority: z.ZodOptional<z.ZodEnum<{
+                    unprioritized: "unprioritized";
+                    low: "low";
+                    medium: "medium";
+                    high: "high";
+                    urgent: "urgent";
+                }>>;
+            }, z.core.$strip>], "type">;
+            readonly kind: "write";
+            readonly name: "issue.create";
+            readonly output: z.ZodObject<{
+                issue: z.ZodObject<{
+                    createdAt: z.ZodCoercedDate<unknown>;
+                    description: z.ZodString;
+                    issueId: PublicIdSchema;
+                    name: z.ZodString;
+                    number: z.ZodNumber;
+                    priority: z.ZodEnum<{
+                        unprioritized: "unprioritized";
+                        low: "low";
+                        medium: "medium";
+                        high: "high";
+                        urgent: "urgent";
+                    }>;
+                    reproductions: z.ZodArray<z.ZodObject<{
+                        environmentId: PublicIdSchema;
+                        firstReproducedInRunId: PublicIdSchema;
+                        flowId: PublicIdSchema;
+                        isActive: z.ZodBoolean;
+                        lastReproducedInRunId: PublicIdSchema;
+                    }, z.core.$strip>>;
+                    status: z.ZodEnum<{
+                        pending: "pending";
+                        inProgress: "inProgress";
+                        paused: "paused";
+                        resolved: "resolved";
+                        canceled: "canceled";
+                        archived: "archived";
+                    }>;
+                    type: z.ZodEnum<{
+                        bug: "bug";
+                        coverageRequest: "coverageRequest";
+                        maintenance: "maintenance";
+                    }>;
+                    url: z.ZodURL;
+                }, z.core.$strip>;
+            }, z.core.$strip>;
+        };
+        find: {
+            readonly description: "List the team's bug reports, maintenance reports, or coverage requests, newest first.";
+            readonly input: z.ZodObject<{
+                statuses: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+                    pending: "pending";
+                    inProgress: "inProgress";
+                    paused: "paused";
+                    resolved: "resolved";
+                    canceled: "canceled";
+                    archived: "archived";
+                }>>>;
+                type: z.ZodEnum<{
+                    bug: "bug";
+                    coverageRequest: "coverageRequest";
+                    maintenance: "maintenance";
+                }>;
+                cursor: z.ZodOptional<z.ZodString>;
+                limit: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strip>;
+            readonly kind: "read";
+            readonly name: "issue.find";
+            readonly output: z.ZodObject<{
+                issues: z.ZodArray<z.ZodObject<{
+                    createdAt: z.ZodCoercedDate<unknown>;
+                    description: z.ZodString;
+                    issueId: PublicIdSchema;
+                    name: z.ZodString;
+                    number: z.ZodNumber;
+                    priority: z.ZodEnum<{
+                        unprioritized: "unprioritized";
+                        low: "low";
+                        medium: "medium";
+                        high: "high";
+                        urgent: "urgent";
+                    }>;
+                    reproductions: z.ZodArray<z.ZodObject<{
+                        environmentId: PublicIdSchema;
+                        firstReproducedInRunId: PublicIdSchema;
+                        flowId: PublicIdSchema;
+                        isActive: z.ZodBoolean;
+                        lastReproducedInRunId: PublicIdSchema;
+                    }, z.core.$strip>>;
+                    status: z.ZodEnum<{
+                        pending: "pending";
+                        inProgress: "inProgress";
+                        paused: "paused";
+                        resolved: "resolved";
+                        canceled: "canceled";
+                        archived: "archived";
+                    }>;
+                    type: z.ZodEnum<{
+                        bug: "bug";
+                        coverageRequest: "coverageRequest";
+                        maintenance: "maintenance";
+                    }>;
+                    url: z.ZodURL;
+                }, z.core.$strip>>;
+                nextCursor: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>;
+        };
+        get: {
+            readonly description: "Get an issue by id.";
+            readonly input: z.ZodObject<{
+                issueId: PublicIdSchema;
+            }, z.core.$strip>;
+            readonly kind: "read";
+            readonly name: "issue.get";
+            readonly output: z.ZodObject<{
+                issue: z.ZodObject<{
+                    createdAt: z.ZodCoercedDate<unknown>;
+                    description: z.ZodString;
+                    issueId: PublicIdSchema;
+                    name: z.ZodString;
+                    number: z.ZodNumber;
+                    priority: z.ZodEnum<{
+                        unprioritized: "unprioritized";
+                        low: "low";
+                        medium: "medium";
+                        high: "high";
+                        urgent: "urgent";
+                    }>;
+                    reproductions: z.ZodArray<z.ZodObject<{
+                        environmentId: PublicIdSchema;
+                        firstReproducedInRunId: PublicIdSchema;
+                        flowId: PublicIdSchema;
+                        isActive: z.ZodBoolean;
+                        lastReproducedInRunId: PublicIdSchema;
+                    }, z.core.$strip>>;
+                    status: z.ZodEnum<{
+                        pending: "pending";
+                        inProgress: "inProgress";
+                        paused: "paused";
+                        resolved: "resolved";
+                        canceled: "canceled";
+                        archived: "archived";
+                    }>;
+                    type: z.ZodEnum<{
+                        bug: "bug";
+                        coverageRequest: "coverageRequest";
+                        maintenance: "maintenance";
+                    }>;
+                    url: z.ZodURL;
+                }, z.core.$strip>;
+            }, z.core.$strip>;
+        };
+    };
+    run: {
+        create: {
+            readonly description: "Create a run for the selected flows and/or tags in an environment.";
+            readonly input: z.ZodIntersection<z.ZodObject<{
+                environmentId: PublicIdSchema;
                 environmentVariables: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-                flowIds: z.ZodArray<PublicIdSchema>;
                 ignoreRules: z.ZodDefault<z.ZodBoolean>;
-            }, z.core.$strip>;
+                pullRequestNumber: z.ZodOptional<z.ZodNumber>;
+                repository: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>, z.ZodObject<{
+                flowIds: z.ZodDefault<z.ZodArray<PublicIdSchema>>;
+                tagNames: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>>;
             readonly kind: "write";
             readonly name: "run.create";
             readonly output: z.ZodObject<{
                 runId: PublicIdSchema;
+                url: z.ZodURL;
+            }, z.core.$strip>;
+        };
+        find: {
+            readonly description: "List an environment's recent runs, newest first.";
+            readonly input: z.ZodObject<{
+                environmentId: PublicIdSchema;
+                cursor: z.ZodOptional<z.ZodString>;
+                limit: z.ZodDefault<z.ZodNumber>;
+                createdAfter: z.ZodOptional<z.ZodISODateTime>;
+            }, z.core.$strip>;
+            readonly kind: "read";
+            readonly name: "run.find";
+            readonly output: z.ZodObject<{
+                nextCursor: z.ZodOptional<z.ZodString>;
+                runs: z.ZodArray<z.ZodObject<{
+                    completedAt: z.ZodOptional<z.ZodISODateTime>;
+                    createdAt: z.ZodISODateTime;
+                    git: z.ZodObject<{
+                        branch: z.ZodOptional<z.ZodString>;
+                        commitMessage: z.ZodOptional<z.ZodString>;
+                        commitSha: z.ZodOptional<z.ZodString>;
+                        commitUrl: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>;
+                    runId: PublicIdSchema;
+                    status: z.ZodEnum<{
+                        running: "running";
+                        canceled: "canceled";
+                        queued: "queued";
+                        passed: "passed";
+                        failed: "failed";
+                    }>;
+                    url: z.ZodURL;
+                }, z.core.$strip>>;
+            }, z.core.$strip>;
+        };
+        get: {
+            readonly description: "Get a run's status, per-flow results, and links.";
+            readonly input: z.ZodObject<{
+                runId: PublicIdSchema;
+            }, z.core.$strip>;
+            readonly kind: "read";
+            readonly name: "run.get";
+            readonly output: z.ZodObject<{
+                flows: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    failure: z.ZodObject<{
+                        error: z.ZodString;
+                    }, z.core.$strip>;
+                    flowId: PublicIdSchema;
+                    name: z.ZodString;
+                    status: z.ZodLiteral<"failed">;
+                }, z.core.$strip>, z.ZodObject<{
+                    flowId: PublicIdSchema;
+                    name: z.ZodString;
+                    status: z.ZodEnum<{
+                        running: "running";
+                        canceled: "canceled";
+                        queued: "queued";
+                        passed: "passed";
+                    }>;
+                }, z.core.$strip>], "status">>;
+                completedAt: z.ZodOptional<z.ZodISODateTime>;
+                createdAt: z.ZodISODateTime;
+                git: z.ZodObject<{
+                    branch: z.ZodOptional<z.ZodString>;
+                    commitMessage: z.ZodOptional<z.ZodString>;
+                    commitSha: z.ZodOptional<z.ZodString>;
+                    commitUrl: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>;
+                runId: PublicIdSchema;
+                status: z.ZodEnum<{
+                    running: "running";
+                    canceled: "canceled";
+                    queued: "queued";
+                    passed: "passed";
+                    failed: "failed";
+                }>;
+                url: z.ZodURL;
+            }, z.core.$strip>;
+        };
+    };
+    tag: {
+        create: {
+            readonly description: "Create a tag on the caller's team. Tags select flows in run.create.";
+            readonly input: z.ZodObject<{
+                name: z.ZodString;
+            }, z.core.$strip>;
+            readonly kind: "write";
+            readonly name: "tag.create";
+            readonly output: z.ZodObject<{
+                color: z.ZodString;
+                name: z.ZodString;
+                url: z.ZodURL;
             }, z.core.$strip>;
         };
     };