@qawolf/api-contracts 0.58.0 → 0.63.0

package/dist/v1/agent/get.d.ts

@@ -9,10 +9,11 @@ export declare const makeAgentGetContract: <ChatSessionId extends PublicIdSchema
         readonly openWorldHint: false;
         readonly readOnlyHint: true;
     };
-    readonly description: "Monitor a QA Wolf AI session by reading its status and replies. After agent.send, share the returned session URL before monitoring. Wait 30 to 60 seconds between checks; do not call this in a tight loop. Pass the nextCursor from one response as the cursor on the next check; it then reads only what is new, and only for the session that minted it. Continue monitoring silently when the status is unchanged and no replies come back; do not narrate waiting, announce the next check, or ask whether to keep monitoring. Report only substantive new progress, questions, blockers, or the final outcome. A status of \"waiting-for-you\" means the last reply is a question the work is blocked on, and answering it with agent.send is what unblocks it. Surface an explicit request for user input even if the status still says \"working\". Include the session URL when reporting a blocker or final outcome. On \"completed\", stop status checks and verify the requested result before claiming success. For new flows, validation, publication in the target environment, and readiness are separate checks; a Git push or final reply does not prove the flow is active. If every requested result is verified but status remains \"working\", report the mismatch and stop monitoring. Stop on \"failed\" or \"cancelled\" and report any confirmed partial result.";
+    readonly description: "Monitor a QA Wolf AI session by reading its status and replies. After agent.send, share the returned session URL before monitoring. Pass waitSeconds 45 so the server holds the check open and answers the moment something happens. Check again as soon as it returns; never sleep between checks or loop without waitSeconds. Pass the nextCursor from one response as the cursor on the next check; it then reads only what is new, and only for the session that minted it. Continue monitoring silently when the status is unchanged and no replies come back; do not narrate waiting, announce the next check, or ask whether to keep monitoring. Report only substantive new progress, questions, blockers, or the final outcome. A status of \"waiting-for-you\" means the last reply is a question the work is blocked on, and answering it with agent.send is what unblocks it. Surface an explicit request for user input even if the status still says \"working\". Include the session URL when reporting a blocker or final outcome. On \"completed\", stop status checks and verify the requested result before claiming success. For new flows, validation, publication in the target environment, and readiness are separate checks; a Git push or final reply does not prove the flow is active. If every requested result is verified but status remains \"working\", report the mismatch and stop monitoring. Stop on \"failed\" or \"cancelled\" and report any confirmed partial result.";
     readonly input: z.ZodObject<{
         cursor: z.ZodOptional<z.ZodString>;
         sessionId: ChatSessionId;
+        waitSeconds: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>;
     readonly kind: "read";
     readonly name: "agent.get";
@@ -31,6 +32,12 @@ export declare const makeAgentGetContract: <ChatSessionId extends PublicIdSchema
             failed: "failed";
             cancelled: "cancelled";
         }>;
+        waitSeconds: z.ZodOptional<z.ZodNumber>;
+        wokeOn: z.ZodOptional<z.ZodEnum<{
+            reply: "reply";
+            status: "status";
+            timeout: "timeout";
+        }>>;
         url: z.ZodURL;
     }, z.core.$strip>;
 };

package/dist/v1/agent/get.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"get.d.ts","sourceRoot":"","sources":["../../../src/v1/agent/get.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAKhD,eAAO,MAAM,oBAAoB,GAC/B,aAAa,SAAS,cAAc,EACpC,WAAW,SAAS,cAAc,EAClC,KAAK;IACL,WAAW,EAAE,aAAa,CAAC;IAC3B,SAAS,EAAE,WAAW,CAAC;CACxB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmDA,CAAC"}
+{"version":3,"file":"get.d.ts","sourceRoot":"","sources":["../../../src/v1/agent/get.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAMhD,eAAO,MAAM,oBAAoB,GAC/B,aAAa,SAAS,cAAc,EACpC,WAAW,SAAS,cAAc,EAClC,KAAK;IACL,WAAW,EAAE,aAAa,CAAC;IAC3B,SAAS,EAAE,WAAW,CAAC;CACxB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuEA,CAAC"}

package/dist/v1/agent/get.js

@@ -1,6 +1,7 @@
 import { z } from "zod";
 import { resource } from "../resource.js";
 import { agentReplySchema, agentSessionStatusSchema } from "./status.js";
+import { agentWakeReasonSchema, maxAgentWaitSeconds } from "./wait.js";
 export const makeAgentGetContract = (ids) => {
     const input = z.object({
         cursor: z
@@ -9,6 +10,12 @@ export const makeAgentGetContract = (ids) => {
             .optional()
             .describe("Opaque cursor copied from this same session's previous nextCursor. Omit to read from its first reply."),
         sessionId: ids.chatSession.describe("The id agent.send answered with."),
+        waitSeconds: z
+            .number()
+            .int()
+            .min(0)
+            .optional()
+            .describe(`How long the server may hold this check open, in seconds. Omit or pass 0 to answer at once. A larger value clamps to ${maxAgentWaitSeconds}. Check again as soon as a held check returns.`),
     });
     const output = resource({
         nextCursor: z
@@ -20,6 +27,14 @@ export const makeAgentGetContract = (ids) => {
             .describe("What the AI has said since the cursor, oldest first. A reply still being written returns again, longer. A reply carrying choices is a question the work is blocked on."),
         sessionId: ids.chatSession,
         status: agentSessionStatusSchema,
+        waitSeconds: z
+            .number()
+            .int()
+            .optional()
+            .describe("The hold this check was allowed, in seconds, after clamping. Absent when the check did not wait."),
+        wokeOn: agentWakeReasonSchema
+            .optional()
+            .describe('Why this check answered when it did. Absent when the check did not wait. "timeout" means nothing new: replies is empty and nextCursor unchanged, so check again with the same cursor.'),
     }, {
         urlFieldDescription: "Absolute URL of the live session in the QA Wolf app.",
     });
@@ -29,7 +44,7 @@ export const makeAgentGetContract = (ids) => {
             openWorldHint: false,
             readOnlyHint: true,
         },
-        description: 'Monitor a QA Wolf AI session by reading its status and replies. After agent.send, share the returned session URL before monitoring. Wait 30 to 60 seconds between checks; do not call this in a tight loop. Pass the nextCursor from one response as the cursor on the next check; it then reads only what is new, and only for the session that minted it. Continue monitoring silently when the status is unchanged and no replies come back; do not narrate waiting, announce the next check, or ask whether to keep monitoring. Report only substantive new progress, questions, blockers, or the final outcome. A status of "waiting-for-you" means the last reply is a question the work is blocked on, and answering it with agent.send is what unblocks it. Surface an explicit request for user input even if the status still says "working". Include the session URL when reporting a blocker or final outcome. On "completed", stop status checks and verify the requested result before claiming success. For new flows, validation, publication in the target environment, and readiness are separate checks; a Git push or final reply does not prove the flow is active. If every requested result is verified but status remains "working", report the mismatch and stop monitoring. Stop on "failed" or "cancelled" and report any confirmed partial result.',
+        description: 'Monitor a QA Wolf AI session by reading its status and replies. After agent.send, share the returned session URL before monitoring. Pass waitSeconds 45 so the server holds the check open and answers the moment something happens. Check again as soon as it returns; never sleep between checks or loop without waitSeconds. Pass the nextCursor from one response as the cursor on the next check; it then reads only what is new, and only for the session that minted it. Continue monitoring silently when the status is unchanged and no replies come back; do not narrate waiting, announce the next check, or ask whether to keep monitoring. Report only substantive new progress, questions, blockers, or the final outcome. A status of "waiting-for-you" means the last reply is a question the work is blocked on, and answering it with agent.send is what unblocks it. Surface an explicit request for user input even if the status still says "working". Include the session URL when reporting a blocker or final outcome. On "completed", stop status checks and verify the requested result before claiming success. For new flows, validation, publication in the target environment, and readiness are separate checks; a Git push or final reply does not prove the flow is active. If every requested result is verified but status remains "working", report the mismatch and stop monitoring. Stop on "failed" or "cancelled" and report any confirmed partial result.',
         input,
         kind: "read",
         name: "agent.get",

package/dist/v1/agent/get.js.map

@@ -1 +1 @@
-{"version":3,"file":"get.js","sourceRoot":"","sources":["../../../src/v1/agent/get.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAE1C,OAAO,EAAE,gBAAgB,EAAE,wBAAwB,EAAE,MAAM,aAAa,CAAC;AAEzE,MAAM,CAAC,MAAM,oBAAoB,GAAG,CAGlC,GAGD,EAAE,EAAE;IACH,MAAM,KAAK,GAAG,CAAC,CAAC,MAAM,CAAC;QACrB,MAAM,EAAE,CAAC;aACN,MAAM,EAAE;aACR,GAAG,CAAC,CAAC,CAAC;aACN,QAAQ,EAAE;aACV,QAAQ,CACP,uGAAuG,CACxG;QACH,SAAS,EAAE,GAAG,CAAC,WAAW,CAAC,QAAQ,CAAC,kCAAkC,CAAC;KACxE,CAAC,CAAC;IACH,MAAM,MAAM,GAAG,QAAQ,CACrB;QACE,UAAU,EAAE,CAAC;aACV,MAAM,EAAE;aACR,GAAG,CAAC,CAAC,CAAC;aACN,QAAQ,CACP,uIAAuI,CACxI;QACH,OAAO,EAAE,CAAC;aACP,KAAK,CAAC,gBAAgB,CAAC;aACvB,QAAQ,CACP,wKAAwK,CACzK;QACH,SAAS,EAAE,GAAG,CAAC,WAAW;QAC1B,MAAM,EAAE,wBAAwB;KACjC,EACD;QACE,mBAAmB,EACjB,sDAAsD;KACzD,CACF,CAAC;IAEF,OAAO;QACL,WAAW,EAAE;YACX,eAAe,EAAE,KAAK;YACtB,aAAa,EAAE,KAAK;YACpB,YAAY,EAAE,IAAI;SACnB;QACD,WAAW,EACT,gzCAAgzC;QAClzC,KAAK;QACL,IAAI,EAAE,MAAM;QACZ,IAAI,EAAE,WAAW;QACjB,MAAM;KAMP,CAAC;AACJ,CAAC,CAAC"}
+{"version":3,"file":"get.js","sourceRoot":"","sources":["../../../src/v1/agent/get.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAE1C,OAAO,EAAE,gBAAgB,EAAE,wBAAwB,EAAE,MAAM,aAAa,CAAC;AACzE,OAAO,EAAE,qBAAqB,EAAE,mBAAmB,EAAE,MAAM,WAAW,CAAC;AAEvE,MAAM,CAAC,MAAM,oBAAoB,GAAG,CAGlC,GAGD,EAAE,EAAE;IACH,MAAM,KAAK,GAAG,CAAC,CAAC,MAAM,CAAC;QACrB,MAAM,EAAE,CAAC;aACN,MAAM,EAAE;aACR,GAAG,CAAC,CAAC,CAAC;aACN,QAAQ,EAAE;aACV,QAAQ,CACP,uGAAuG,CACxG;QACH,SAAS,EAAE,GAAG,CAAC,WAAW,CAAC,QAAQ,CAAC,kCAAkC,CAAC;QACvE,WAAW,EAAE,CAAC;aACX,MAAM,EAAE;aACR,GAAG,EAAE;aACL,GAAG,CAAC,CAAC,CAAC;aACN,QAAQ,EAAE;aACV,QAAQ,CACP,wHAAwH,mBAAmB,gDAAgD,CAC5L;KACJ,CAAC,CAAC;IACH,MAAM,MAAM,GAAG,QAAQ,CACrB;QACE,UAAU,EAAE,CAAC;aACV,MAAM,EAAE;aACR,GAAG,CAAC,CAAC,CAAC;aACN,QAAQ,CACP,uIAAuI,CACxI;QACH,OAAO,EAAE,CAAC;aACP,KAAK,CAAC,gBAAgB,CAAC;aACvB,QAAQ,CACP,wKAAwK,CACzK;QACH,SAAS,EAAE,GAAG,CAAC,WAAW;QAC1B,MAAM,EAAE,wBAAwB;QAChC,WAAW,EAAE,CAAC;aACX,MAAM,EAAE;aACR,GAAG,EAAE;aACL,QAAQ,EAAE;aACV,QAAQ,CACP,kGAAkG,CACnG;QACH,MAAM,EAAE,qBAAqB;aAC1B,QAAQ,EAAE;aACV,QAAQ,CACP,uLAAuL,CACxL;KACJ,EACD;QACE,mBAAmB,EACjB,sDAAsD;KACzD,CACF,CAAC;IAEF,OAAO;QACL,WAAW,EAAE;YACX,eAAe,EAAE,KAAK;YACtB,aAAa,EAAE,KAAK;YACpB,YAAY,EAAE,IAAI;SACnB;QACD,WAAW,EACT,o6CAAo6C;QACt6C,KAAK;QACL,IAAI,EAAE,MAAM;QACZ,IAAI,EAAE,WAAW;QACjB,MAAM;KAMP,CAAC;AACJ,CAAC,CAAC"}

package/dist/v1/agent/send.d.ts

@@ -15,6 +15,7 @@ export declare const makeAgentSendContract: <ChatSessionId extends PublicIdSchem
         environmentId: z.ZodOptional<PublicIdSchema>;
         filePaths: z.ZodOptional<z.ZodArray<z.ZodString>>;
         message: z.ZodString;
+        runnerId: z.ZodOptional<z.ZodString>;
         sessionId: z.ZodOptional<ChatSessionId>;
         workspaceId: z.ZodOptional<WorkspaceId>;
     }, z.core.$strip>;

package/dist/v1/agent/send.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"send.d.ts","sourceRoot":"","sources":["../../../src/v1/agent/send.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAKhD,eAAO,MAAM,qBAAqB,GAChC,aAAa,SAAS,cAAc,EACpC,WAAW,SAAS,cAAc,EAClC,KAAK;IACL,WAAW,EAAE,aAAa,CAAC;IAC3B,cAAc,EAAE,cAAc,CAAC;IAC/B,SAAS,EAAE,WAAW,CAAC;CACxB;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgEA,CAAC"}
+{"version":3,"file":"send.d.ts","sourceRoot":"","sources":["../../../src/v1/agent/send.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAMhD,eAAO,MAAM,qBAAqB,GAChC,aAAa,SAAS,cAAc,EACpC,WAAW,SAAS,cAAc,EAClC,KAAK;IACL,WAAW,EAAE,aAAa,CAAC;IAC3B,cAAc,EAAE,cAAc,CAAC;IAC/B,SAAS,EAAE,WAAW,CAAC;CACxB;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqEA,CAAC"}

package/dist/v1/agent/send.js

@@ -1,6 +1,7 @@
 import { z } from "zod";
 import { teamStoragePathSchema } from "../file/path.js";
 import { resource } from "../resource.js";
+import { runnerIdSchema } from "../runner/identity.js";
 import { agentSessionStatusSchema } from "./status.js";
 export const makeAgentSendContract = (ids) => {
     const input = z.object({
@@ -18,6 +19,9 @@ export const makeAgentSendContract = (ids) => {
             .min(1)
             .max(10_000)
             .describe("What you want QA Wolf to do, in plain language. Name the journey, the part of the app it covers, and anything the AI cannot discover for itself, such as a test account, a feature flag, or how to reach a staging environment. When answering a question from agent.get, send the answer here."),
+        runnerId: runnerIdSchema
+            .optional()
+            .describe("The runner you explored on, from runner.launch. Pass it to hand that browser to QA Wolf instead of having a fresh one started, so the pages you opened and any sign-in the user completed there are carried over. Leave the runner running: QA Wolf takes it over and terminates it when the work is done. Omit this when you have no runner, or when you already terminated it."),
         sessionId: ids.chatSession
             .optional()
             .describe("Continue the session with this id instead of opening a new one. Omit to start fresh. Send this to answer a question or to add context to work already running."),

package/dist/v1/agent/send.js.map

@@ -1 +1 @@
-{"version":3,"file":"send.js","sourceRoot":"","sources":["../../../src/v1/agent/send.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,EAAE,qBAAqB,EAAE,MAAM,iBAAiB,CAAC;AAExD,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAE1C,OAAO,EAAE,wBAAwB,EAAE,MAAM,aAAa,CAAC;AAEvD,MAAM,CAAC,MAAM,qBAAqB,GAAG,CAGnC,GAID,EAAE,EAAE;IACH,MAAM,KAAK,GAAG,CAAC,CAAC,MAAM,CAAC;QACrB,aAAa,EAAE,GAAG,CAAC,cAAc;aAC9B,QAAQ,EAAE;aACV,QAAQ,CACP,gKAAgK,CACjK;QACH,SAAS,EAAE,CAAC;aACT,KAAK,CAAC,qBAAqB,CAAC;aAC5B,GAAG,CAAC,EAAE,CAAC;aACP,QAAQ,EAAE;aACV,QAAQ,CACP,iLAAiL,CAClL;QACH,OAAO,EAAE,CAAC;aACP,MAAM,EAAE;aACR,IAAI,EAAE;aACN,GAAG,CAAC,CAAC,CAAC;aACN,GAAG,CAAC,MAAM,CAAC;aACX,QAAQ,CACP,iSAAiS,CAClS;QACH,SAAS,EAAE,GAAG,CAAC,WAAW;aACvB,QAAQ,EAAE;aACV,QAAQ,CACP,gKAAgK,CACjK;QACH,WAAW,EAAE,GAAG,CAAC,SAAS;aACvB,QAAQ,EAAE;aACV,QAAQ,CACP,8FAA8F,CAC/F;KACJ,CAAC,CAAC;IACH,MAAM,MAAM,GAAG,QAAQ,CACrB;QACE,SAAS,EAAE,GAAG,CAAC,WAAW,CAAC,QAAQ,CACjC,+CAA+C,CAChD;QACD,MAAM,EAAE,wBAAwB;KACjC,EACD;QACE,mBAAmB,EACjB,sDAAsD;KACzD,CACF,CAAC;IAEF,OAAO;QACL,WAAW,EAAE;YACX,eAAe,EAAE,IAAI;YACrB,aAAa,EAAE,IAAI;YACnB,YAAY,EAAE,KAAK;SACpB;QACD,WAAW,EACT,48BAA48B;QAC98B,KAAK;QACL,IAAI,EAAE,OAAO;QACb,IAAI,EAAE,YAAY;QAClB,MAAM;KAMP,CAAC;AACJ,CAAC,CAAC"}
+{"version":3,"file":"send.js","sourceRoot":"","sources":["../../../src/v1/agent/send.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,EAAE,qBAAqB,EAAE,MAAM,iBAAiB,CAAC;AAExD,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAC1C,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAEvD,OAAO,EAAE,wBAAwB,EAAE,MAAM,aAAa,CAAC;AAEvD,MAAM,CAAC,MAAM,qBAAqB,GAAG,CAGnC,GAID,EAAE,EAAE;IACH,MAAM,KAAK,GAAG,CAAC,CAAC,MAAM,CAAC;QACrB,aAAa,EAAE,GAAG,CAAC,cAAc;aAC9B,QAAQ,EAAE;aACV,QAAQ,CACP,gKAAgK,CACjK;QACH,SAAS,EAAE,CAAC;aACT,KAAK,CAAC,qBAAqB,CAAC;aAC5B,GAAG,CAAC,EAAE,CAAC;aACP,QAAQ,EAAE;aACV,QAAQ,CACP,iLAAiL,CAClL;QACH,OAAO,EAAE,CAAC;aACP,MAAM,EAAE;aACR,IAAI,EAAE;aACN,GAAG,CAAC,CAAC,CAAC;aACN,GAAG,CAAC,MAAM,CAAC;aACX,QAAQ,CACP,iSAAiS,CAClS;QACH,QAAQ,EAAE,cAAc;aACrB,QAAQ,EAAE;aACV,QAAQ,CACP,kXAAkX,CACnX;QACH,SAAS,EAAE,GAAG,CAAC,WAAW;aACvB,QAAQ,EAAE;aACV,QAAQ,CACP,gKAAgK,CACjK;QACH,WAAW,EAAE,GAAG,CAAC,SAAS;aACvB,QAAQ,EAAE;aACV,QAAQ,CACP,8FAA8F,CAC/F;KACJ,CAAC,CAAC;IACH,MAAM,MAAM,GAAG,QAAQ,CACrB;QACE,SAAS,EAAE,GAAG,CAAC,WAAW,CAAC,QAAQ,CACjC,+CAA+C,CAChD;QACD,MAAM,EAAE,wBAAwB;KACjC,EACD;QACE,mBAAmB,EACjB,sDAAsD;KACzD,CACF,CAAC;IAEF,OAAO;QACL,WAAW,EAAE;YACX,eAAe,EAAE,IAAI;YACrB,aAAa,EAAE,IAAI;YACnB,YAAY,EAAE,KAAK;SACpB;QACD,WAAW,EACT,48BAA48B;QAC98B,KAAK;QACL,IAAI,EAAE,OAAO;QACb,IAAI,EAAE,YAAY;QAClB,MAAM;KAMP,CAAC;AACJ,CAAC,CAAC"}

package/dist/v1/agent/wait.d.ts

@@ -0,0 +1,9 @@
+import { z } from "zod";
+export declare const maxAgentWaitSeconds = 45;
+export declare const agentWakeReasonSchema: z.ZodEnum<{
+    reply: "reply";
+    status: "status";
+    timeout: "timeout";
+}>;
+export type AgentWakeReason = z.infer<typeof agentWakeReasonSchema>;
+//# sourceMappingURL=wait.d.ts.map

package/dist/v1/agent/wait.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wait.d.ts","sourceRoot":"","sources":["../../../src/v1/agent/wait.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,mBAAmB,KAAK,CAAC;AAEtC,eAAO,MAAM,qBAAqB;;;;EAI/B,CAAC;AAEJ,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC"}

package/dist/v1/agent/wait.js

@@ -0,0 +1,6 @@
+import { z } from "zod";
+export const maxAgentWaitSeconds = 45;
+export const agentWakeReasonSchema = z
+    .enum(["reply", "status", "timeout"])
+    .describe('Why a held check answered. "reply" means the AI said something new, "status" means the session settled or needs you, "timeout" means the hold ran out with nothing new.');
+//# sourceMappingURL=wait.js.map

package/dist/v1/agent/wait.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wait.js","sourceRoot":"","sources":["../../../src/v1/agent/wait.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,MAAM,CAAC,MAAM,mBAAmB,GAAG,EAAE,CAAC;AAEtC,MAAM,CAAC,MAAM,qBAAqB,GAAG,CAAC;KACnC,IAAI,CAAC,CAAC,OAAO,EAAE,QAAQ,EAAE,SAAS,CAAC,CAAC;KACpC,QAAQ,CACP,yKAAyK,CAC1K,CAAC"}

package/dist/v1/deployment/find.d.ts

@@ -0,0 +1,48 @@
+import { z } from "zod";
+import type { PublicIdSchema } from "../ids.js";
+export declare const makeFindDeploymentsContract: <DeploymentId extends PublicIdSchema, EnvironmentId extends PublicIdSchema, WorkspaceId extends PublicIdSchema>(ids: {
+    deployment: DeploymentId;
+    environment: EnvironmentId;
+    workspace: WorkspaceId;
+}) => {
+    readonly annotations: {
+        readonly destructiveHint: false;
+        readonly openWorldHint: false;
+        readonly readOnlyHint: true;
+    };
+    readonly description: "List the deployments QA Wolf has received for the workspace, newest first. A deployment arrives through a code host integration's webhook or through deployment.reportStatus, and is what a deployment trigger evaluates against. deployment.listTriggerEvaluations reports each trigger's verdict for one deployment.";
+    readonly input: z.ZodObject<{
+        cursor: z.ZodOptional<z.ZodString>;
+        limit: z.ZodDefault<z.ZodNumber>;
+        workspaceId: z.ZodOptional<WorkspaceId>;
+    }, z.core.$strip>;
+    readonly kind: "read";
+    readonly name: "deployment.find";
+    readonly output: z.ZodObject<{
+        deployments: z.ZodArray<z.ZodObject<{
+            branch: z.ZodOptional<z.ZodString>;
+            commitAuthorName: z.ZodOptional<z.ZodString>;
+            commitMessage: z.ZodOptional<z.ZodString>;
+            commitSha: z.ZodOptional<z.ZodString>;
+            deployedAt: z.ZodISODateTime;
+            deployTarget: z.ZodOptional<z.ZodString>;
+            environmentId: EnvironmentId;
+            environmentName: z.ZodOptional<z.ZodString>;
+            id: DeploymentId;
+            provider: z.ZodOptional<z.ZodEnum<{
+                github: "github";
+                gitlab: "gitlab";
+                api: "api";
+            }>>;
+            status: z.ZodOptional<z.ZodEnum<{
+                success: "success";
+                pending: "pending";
+                failure: "failure";
+                inactive: "inactive";
+            }>>;
+            url: z.ZodURL;
+        }, z.core.$strip>>;
+        nextCursor: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+};
+//# sourceMappingURL=find.d.ts.map

package/dist/v1/deployment/find.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"find.d.ts","sourceRoot":"","sources":["../../../src/v1/deployment/find.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAKhD,eAAO,MAAM,2BAA2B,GACtC,YAAY,SAAS,cAAc,EACnC,aAAa,SAAS,cAAc,EACpC,WAAW,SAAS,cAAc,EAClC,KAAK;IACL,UAAU,EAAE,YAAY,CAAC;IACzB,WAAW,EAAE,aAAa,CAAC;IAC3B,SAAS,EAAE,WAAW,CAAC;CACxB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkCA,CAAC"}

package/dist/v1/deployment/find.js

@@ -0,0 +1,30 @@
+import { z } from "zod";
+import { makePaginationInputFields, nextCursorSchema } from "../pagination.js";
+import { makeDeploymentResourceSchema } from "./resource.js";
+export const makeFindDeploymentsContract = (ids) => {
+    const input = z.object({
+        workspaceId: ids.workspace
+            .optional()
+            .describe("The workspace to list deployments from. Required when authenticating with an organization or user API key."),
+        ...makePaginationInputFields({ defaultLimit: 20, maxLimit: 100 }),
+    });
+    const output = z.object({
+        deployments: z
+            .array(makeDeploymentResourceSchema(ids))
+            .describe("The workspace's deployments, newest first."),
+        nextCursor: nextCursorSchema,
+    });
+    return {
+        annotations: {
+            destructiveHint: false,
+            openWorldHint: false,
+            readOnlyHint: true,
+        },
+        description: "List the deployments QA Wolf has received for the workspace, newest first. A deployment arrives through a code host integration's webhook or through deployment.reportStatus, and is what a deployment trigger evaluates against. deployment.listTriggerEvaluations reports each trigger's verdict for one deployment.",
+        input,
+        kind: "read",
+        name: "deployment.find",
+        output,
+    };
+};
+//# sourceMappingURL=find.js.map

package/dist/v1/deployment/find.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"find.js","sourceRoot":"","sources":["../../../src/v1/deployment/find.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,OAAO,EAAE,yBAAyB,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAE/E,OAAO,EAAE,4BAA4B,EAAE,MAAM,eAAe,CAAC;AAE7D,MAAM,CAAC,MAAM,2BAA2B,GAAG,CAIzC,GAID,EAAE,EAAE;IACH,MAAM,KAAK,GAAG,CAAC,CAAC,MAAM,CAAC;QACrB,WAAW,EAAE,GAAG,CAAC,SAAS;aACvB,QAAQ,EAAE;aACV,QAAQ,CACP,4GAA4G,CAC7G;QACH,GAAG,yBAAyB,CAAC,EAAE,YAAY,EAAE,EAAE,EAAE,QAAQ,EAAE,GAAG,EAAE,CAAC;KAClE,CAAC,CAAC;IACH,MAAM,MAAM,GAAG,CAAC,CAAC,MAAM,CAAC;QACtB,WAAW,EAAE,CAAC;aACX,KAAK,CAAC,4BAA4B,CAAC,GAAG,CAAC,CAAC;aACxC,QAAQ,CAAC,4CAA4C,CAAC;QACzD,UAAU,EAAE,gBAAgB;KAC7B,CAAC,CAAC;IAEH,OAAO;QACL,WAAW,EAAE;YACX,eAAe,EAAE,KAAK;YACtB,aAAa,EAAE,KAAK;YACpB,YAAY,EAAE,IAAI;SACnB;QACD,WAAW,EACT,wTAAwT;QAC1T,KAAK;QACL,IAAI,EAAE,MAAM;QACZ,IAAI,EAAE,iBAAiB;QACvB,MAAM;KAMP,CAAC;AACJ,CAAC,CAAC"}

package/dist/v1/deployment/index.d.ts

@@ -0,0 +1,189 @@
+import type { PublicIdSchema } from "../ids.js";
+export declare const makeDeploymentContracts: <DeploymentId extends PublicIdSchema, EnvironmentId extends PublicIdSchema, RunId extends PublicIdSchema, TriggerId extends PublicIdSchema, WorkspaceId extends PublicIdSchema>(ids: {
+    deployment: DeploymentId;
+    environment: EnvironmentId;
+    run: RunId;
+    trigger: TriggerId;
+    workspace: WorkspaceId;
+}) => {
+    find: {
+        readonly annotations: {
+            readonly destructiveHint: false;
+            readonly openWorldHint: false;
+            readonly readOnlyHint: true;
+        };
+        readonly description: "List the deployments QA Wolf has received for the workspace, newest first. A deployment arrives through a code host integration's webhook or through deployment.reportStatus, and is what a deployment trigger evaluates against. deployment.listTriggerEvaluations reports each trigger's verdict for one deployment.";
+        readonly input: import("zod").ZodObject<{
+            cursor: import("zod").ZodOptional<import("zod").ZodString>;
+            limit: import("zod").ZodDefault<import("zod").ZodNumber>;
+            workspaceId: import("zod").ZodOptional<WorkspaceId>;
+        }, import("zod/v4/core").$strip>;
+        readonly kind: "read";
+        readonly name: "deployment.find";
+        readonly output: import("zod").ZodObject<{
+            deployments: import("zod").ZodArray<import("zod").ZodObject<{
+                branch: import("zod").ZodOptional<import("zod").ZodString>;
+                commitAuthorName: import("zod").ZodOptional<import("zod").ZodString>;
+                commitMessage: import("zod").ZodOptional<import("zod").ZodString>;
+                commitSha: import("zod").ZodOptional<import("zod").ZodString>;
+                deployedAt: import("zod").ZodISODateTime;
+                deployTarget: import("zod").ZodOptional<import("zod").ZodString>;
+                environmentId: EnvironmentId;
+                environmentName: import("zod").ZodOptional<import("zod").ZodString>;
+                id: DeploymentId;
+                provider: import("zod").ZodOptional<import("zod").ZodEnum<{
+                    github: "github";
+                    gitlab: "gitlab";
+                    api: "api";
+                }>>;
+                status: import("zod").ZodOptional<import("zod").ZodEnum<{
+                    success: "success";
+                    pending: "pending";
+                    failure: "failure";
+                    inactive: "inactive";
+                }>>;
+                url: import("zod").ZodURL;
+            }, import("zod/v4/core").$strip>>;
+            nextCursor: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>;
+    };
+    listTriggerEvaluations: {
+        readonly annotations: {
+            readonly destructiveHint: false;
+            readonly openWorldHint: false;
+            readonly readOnlyHint: true;
+        };
+        readonly description: "List the per-trigger verdicts recorded when a deployment was evaluated against the workspace's triggers. Each verdict says whether the trigger matched, did not match with the reason per condition, or was never considered and why. Verdicts are a snapshot from evaluation time: editing or deleting a trigger later does not change them.";
+        readonly input: import("zod").ZodObject<{
+            deploymentId: DeploymentId;
+        }, import("zod/v4/core").$strip>;
+        readonly kind: "read";
+        readonly name: "deployment.listTriggerEvaluations";
+        readonly output: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+            evaluations: import("zod").ZodArray<import("zod").ZodObject<{
+                triggerId: import("zod").ZodOptional<TriggerId>;
+                triggerName: import("zod").ZodString;
+                verdict: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+                    conditionSets: import("zod").ZodArray<import("zod").ZodObject<{
+                        conditions: import("zod").ZodArray<import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+                            kind: import("zod").ZodEnum<{
+                                branch: "branch";
+                                deployTarget: "deployTarget";
+                                environment: "environment";
+                            }>;
+                            outcome: import("zod").ZodLiteral<"matched">;
+                        }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+                            kind: import("zod").ZodEnum<{
+                                branch: "branch";
+                                deployTarget: "deployTarget";
+                                environment: "environment";
+                            }>;
+                            outcome: import("zod").ZodLiteral<"did-not-match">;
+                            reason: import("zod").ZodString;
+                        }, import("zod/v4/core").$strip>], "outcome">>;
+                        outcome: import("zod").ZodEnum<{
+                            matched: "matched";
+                            "did-not-match": "did-not-match";
+                        }>;
+                    }, import("zod/v4/core").$strip>>;
+                    outcome: import("zod").ZodLiteral<"matched">;
+                    run: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+                        runId: RunId;
+                        status: import("zod").ZodLiteral<"ran">;
+                    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+                        status: import("zod").ZodLiteral<"starting">;
+                    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+                        reason: import("zod").ZodString;
+                        status: import("zod").ZodLiteral<"did-not-run">;
+                        supersededByRunId: import("zod").ZodOptional<RunId>;
+                    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+                        status: import("zod").ZodLiteral<"unknown">;
+                    }, import("zod/v4/core").$strip>], "status">;
+                }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+                    conditionSets: import("zod").ZodArray<import("zod").ZodObject<{
+                        conditions: import("zod").ZodArray<import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+                            kind: import("zod").ZodEnum<{
+                                branch: "branch";
+                                deployTarget: "deployTarget";
+                                environment: "environment";
+                            }>;
+                            outcome: import("zod").ZodLiteral<"matched">;
+                        }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+                            kind: import("zod").ZodEnum<{
+                                branch: "branch";
+                                deployTarget: "deployTarget";
+                                environment: "environment";
+                            }>;
+                            outcome: import("zod").ZodLiteral<"did-not-match">;
+                            reason: import("zod").ZodString;
+                        }, import("zod/v4/core").$strip>], "outcome">>;
+                        outcome: import("zod").ZodEnum<{
+                            matched: "matched";
+                            "did-not-match": "did-not-match";
+                        }>;
+                    }, import("zod/v4/core").$strip>>;
+                    outcome: import("zod").ZodLiteral<"did-not-match">;
+                }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+                    outcome: import("zod").ZodLiteral<"not-considered">;
+                    reason: import("zod").ZodEnum<{
+                        "trigger-paused": "trigger-paused";
+                        "not-a-deployment-trigger": "not-a-deployment-trigger";
+                    }>;
+                }, import("zod/v4/core").$strip>], "outcome">;
+            }, import("zod/v4/core").$strip>>;
+            state: import("zod").ZodLiteral<"evaluated">;
+        }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+            state: import("zod").ZodLiteral<"not-evaluated">;
+        }, import("zod/v4/core").$strip>], "state">;
+    };
+    reportStatus: {
+        readonly annotations: {
+            readonly destructiveHint: true;
+            readonly openWorldHint: true;
+            readonly readOnlyHint: false;
+        };
+        readonly description: "Report a deployment lifecycle status. A deployment's first success report evaluates global triggers asynchronously, and it is the only report that does: a trigger added or unpaused later does not make an already reported deployment evaluate again. Report that deployment under a new providerDeploymentId to evaluate it against the current triggers. The response contains the deployment only, not the resulting runs. This route requires an organization or user API key.";
+        readonly input: import("zod").ZodObject<{
+            deployTarget: import("zod").ZodOptional<import("zod").ZodURL>;
+            environment: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+                id: EnvironmentId;
+            }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                baseEphemeralEnvironment: import("zod").ZodOptional<import("zod").ZodString>;
+                ephemeral: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                name: import("zod").ZodString;
+            }, import("zod/v4/core").$strict>]>>;
+            environmentVariables: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>>;
+            metadata: import("zod").ZodOptional<import("zod").ZodObject<{
+                commitAuthorName: import("zod").ZodOptional<import("zod").ZodString>;
+                commitMessage: import("zod").ZodOptional<import("zod").ZodString>;
+                commitSha: import("zod").ZodOptional<import("zod").ZodString>;
+                pullRequestNumber: import("zod").ZodOptional<import("zod").ZodNumber>;
+                ref: import("zod").ZodOptional<import("zod").ZodString>;
+                repository: import("zod").ZodOptional<import("zod").ZodString>;
+            }, import("zod/v4/core").$strict>>;
+            providerDeploymentId: import("zod").ZodString;
+            status: import("zod").ZodEnum<{
+                success: "success";
+                pending: "pending";
+                failure: "failure";
+                inactive: "inactive";
+            }>;
+            workspaceId: WorkspaceId;
+        }, import("zod/v4/core").$strict>;
+        readonly kind: "write";
+        readonly name: "deployment.reportStatus";
+        readonly output: import("zod").ZodObject<{
+            deployment: import("zod").ZodObject<{
+                id: DeploymentId;
+                status: import("zod").ZodEnum<{
+                    success: "success";
+                    pending: "pending";
+                    failure: "failure";
+                    inactive: "inactive";
+                }>;
+                url: import("zod").ZodURL;
+            }, import("zod/v4/core").$strip>;
+        }, import("zod/v4/core").$strip>;
+    };
+};
+//# sourceMappingURL=index.d.ts.map

package/dist/v1/deployment/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/v1/deployment/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAMhD,eAAO,MAAM,uBAAuB,GAClC,YAAY,SAAS,cAAc,EACnC,aAAa,SAAS,cAAc,EACpC,KAAK,SAAS,cAAc,EAC5B,SAAS,SAAS,cAAc,EAChC,WAAW,SAAS,cAAc,EAClC,KAAK;IACL,UAAU,EAAE,YAAY,CAAC;IACzB,WAAW,EAAE,aAAa,CAAC;IAC3B,GAAG,EAAE,KAAK,CAAC;IACX,OAAO,EAAE,SAAS,CAAC;IACnB,SAAS,EAAE,WAAW,CAAC;CACxB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAIC,CAAC"}

package/dist/v1/deployment/index.js

@@ -0,0 +1,9 @@
+import { makeFindDeploymentsContract } from "./find.js";
+import { makeListDeploymentTriggerEvaluationsContract } from "./listTriggerEvaluations.js";
+import { makeReportDeploymentStatusContract } from "./reportStatus.js";
+export const makeDeploymentContracts = (ids) => ({
+    find: makeFindDeploymentsContract(ids),
+    listTriggerEvaluations: makeListDeploymentTriggerEvaluationsContract(ids),
+    reportStatus: makeReportDeploymentStatusContract(ids),
+});
+//# sourceMappingURL=index.js.map

package/dist/v1/deployment/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/v1/deployment/index.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,2BAA2B,EAAE,MAAM,WAAW,CAAC;AACxD,OAAO,EAAE,4CAA4C,EAAE,MAAM,6BAA6B,CAAC;AAC3F,OAAO,EAAE,kCAAkC,EAAE,MAAM,mBAAmB,CAAC;AAEvE,MAAM,CAAC,MAAM,uBAAuB,GAAG,CAMrC,GAMD,EAAE,EAAE,CAAC,CAAC;IACL,IAAI,EAAE,2BAA2B,CAAC,GAAG,CAAC;IACtC,sBAAsB,EAAE,4CAA4C,CAAC,GAAG,CAAC;IACzE,YAAY,EAAE,kCAAkC,CAAC,GAAG,CAAC;CACtD,CAAC,CAAC"}

package/dist/v1/deployment/listTriggerEvaluations.d.ts

@@ -0,0 +1,96 @@
+import { z } from "zod";
+import type { PublicIdSchema } from "../ids.js";
+export declare const makeListDeploymentTriggerEvaluationsContract: <DeploymentId extends PublicIdSchema, RunId extends PublicIdSchema, TriggerId extends PublicIdSchema>(ids: {
+    deployment: DeploymentId;
+    run: RunId;
+    trigger: TriggerId;
+}) => {
+    readonly annotations: {
+        readonly destructiveHint: false;
+        readonly openWorldHint: false;
+        readonly readOnlyHint: true;
+    };
+    readonly description: "List the per-trigger verdicts recorded when a deployment was evaluated against the workspace's triggers. Each verdict says whether the trigger matched, did not match with the reason per condition, or was never considered and why. Verdicts are a snapshot from evaluation time: editing or deleting a trigger later does not change them.";
+    readonly input: z.ZodObject<{
+        deploymentId: DeploymentId;
+    }, z.core.$strip>;
+    readonly kind: "read";
+    readonly name: "deployment.listTriggerEvaluations";
+    readonly output: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        evaluations: z.ZodArray<z.ZodObject<{
+            triggerId: z.ZodOptional<TriggerId>;
+            triggerName: z.ZodString;
+            verdict: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                conditionSets: z.ZodArray<z.ZodObject<{
+                    conditions: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        kind: z.ZodEnum<{
+                            branch: "branch";
+                            deployTarget: "deployTarget";
+                            environment: "environment";
+                        }>;
+                        outcome: z.ZodLiteral<"matched">;
+                    }, z.core.$strip>, z.ZodObject<{
+                        kind: z.ZodEnum<{
+                            branch: "branch";
+                            deployTarget: "deployTarget";
+                            environment: "environment";
+                        }>;
+                        outcome: z.ZodLiteral<"did-not-match">;
+                        reason: z.ZodString;
+                    }, z.core.$strip>], "outcome">>;
+                    outcome: z.ZodEnum<{
+                        matched: "matched";
+                        "did-not-match": "did-not-match";
+                    }>;
+                }, z.core.$strip>>;
+                outcome: z.ZodLiteral<"matched">;
+                run: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    runId: RunId;
+                    status: z.ZodLiteral<"ran">;
+                }, z.core.$strip>, z.ZodObject<{
+                    status: z.ZodLiteral<"starting">;
+                }, z.core.$strip>, z.ZodObject<{
+                    reason: z.ZodString;
+                    status: z.ZodLiteral<"did-not-run">;
+                    supersededByRunId: z.ZodOptional<RunId>;
+                }, z.core.$strip>, z.ZodObject<{
+                    status: z.ZodLiteral<"unknown">;
+                }, z.core.$strip>], "status">;
+            }, z.core.$strip>, z.ZodObject<{
+                conditionSets: z.ZodArray<z.ZodObject<{
+                    conditions: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        kind: z.ZodEnum<{
+                            branch: "branch";
+                            deployTarget: "deployTarget";
+                            environment: "environment";
+                        }>;
+                        outcome: z.ZodLiteral<"matched">;
+                    }, z.core.$strip>, z.ZodObject<{
+                        kind: z.ZodEnum<{
+                            branch: "branch";
+                            deployTarget: "deployTarget";
+                            environment: "environment";
+                        }>;
+                        outcome: z.ZodLiteral<"did-not-match">;
+                        reason: z.ZodString;
+                    }, z.core.$strip>], "outcome">>;
+                    outcome: z.ZodEnum<{
+                        matched: "matched";
+                        "did-not-match": "did-not-match";
+                    }>;
+                }, z.core.$strip>>;
+                outcome: z.ZodLiteral<"did-not-match">;
+            }, z.core.$strip>, z.ZodObject<{
+                outcome: z.ZodLiteral<"not-considered">;
+                reason: z.ZodEnum<{
+                    "trigger-paused": "trigger-paused";
+                    "not-a-deployment-trigger": "not-a-deployment-trigger";
+                }>;
+            }, z.core.$strip>], "outcome">;
+        }, z.core.$strip>>;
+        state: z.ZodLiteral<"evaluated">;
+    }, z.core.$strip>, z.ZodObject<{
+        state: z.ZodLiteral<"not-evaluated">;
+    }, z.core.$strip>], "state">;
+};
+//# sourceMappingURL=listTriggerEvaluations.d.ts.map

package/dist/v1/deployment/listTriggerEvaluations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"listTriggerEvaluations.d.ts","sourceRoot":"","sources":["../../../src/v1/deployment/listTriggerEvaluations.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAgHhD,eAAO,MAAM,4CAA4C,GACvD,YAAY,SAAS,cAAc,EACnC,KAAK,SAAS,cAAc,EAC5B,SAAS,SAAS,cAAc,EAChC,KAAK;IACL,UAAU,EAAE,YAAY,CAAC;IACzB,GAAG,EAAE,KAAK,CAAC;IACX,OAAO,EAAE,SAAS,CAAC;CACpB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoCA,CAAC"}