@shipfox/api-workflows-dto 2.0.0

package/dist/schemas/agent-runtime-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-runtime-config.d.ts","sourceRoot":"","sources":["../../src/schemas/agent-runtime-config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,CAAC,EAAC,MAAM,KAAK,CAAC;AAEtB,eAAO,MAAM,6BAA6B;;;iBAGxC,CAAC;AAEH,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,6BAA6B,CAAC,CAAC"}

package/dist/schemas/agent-runtime-config.js

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+export const agentRuntimeConfigQuerySchema = z.object({
+    step_id: z.string().uuid(),
+    attempt: z.coerce.number().int().positive()
+});
+
+//# sourceMappingURL=agent-runtime-config.js.map

package/dist/schemas/agent-runtime-config.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/schemas/agent-runtime-config.ts"],"sourcesContent":["import {z} from 'zod';\n\nexport const agentRuntimeConfigQuerySchema = z.object({\n  step_id: z.string().uuid(),\n  attempt: z.coerce.number().int().positive(),\n});\n\nexport type AgentRuntimeConfigQueryDto = z.infer<typeof agentRuntimeConfigQuerySchema>;\n"],"names":["z","agentRuntimeConfigQuerySchema","object","step_id","string","uuid","attempt","coerce","number","int","positive"],"mappings":"AAAA,SAAQA,CAAC,QAAO,MAAM;AAEtB,OAAO,MAAMC,gCAAgCD,EAAEE,MAAM,CAAC;IACpDC,SAASH,EAAEI,MAAM,GAAGC,IAAI;IACxBC,SAASN,EAAEO,MAAM,CAACC,MAAM,GAAGC,GAAG,GAAGC,QAAQ;AAC3C,GAAG"}

package/dist/schemas/checkout-token.d.ts

@@ -0,0 +1,56 @@
+import { z } from 'zod';
+export declare const checkoutTokenAuthSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    carry: z.ZodEnum<{
+        header: "header";
+        userinfo: "userinfo";
+    }>;
+    host: z.ZodString;
+    persist: z.ZodBoolean;
+    kind: z.ZodLiteral<"basic">;
+    username: z.ZodString;
+    token: z.ZodString;
+    expires_at: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    carry: z.ZodEnum<{
+        header: "header";
+        userinfo: "userinfo";
+    }>;
+    host: z.ZodString;
+    persist: z.ZodBoolean;
+    kind: z.ZodLiteral<"bearer">;
+    token: z.ZodString;
+    expires_at: z.ZodString;
+}, z.core.$strip>], "kind">;
+export type CheckoutTokenAuthDto = z.infer<typeof checkoutTokenAuthSchema>;
+export declare const checkoutTokenResponseSchema: z.ZodObject<{
+    repository_url: z.ZodString;
+    ref: z.ZodString;
+    git_author: z.ZodOptional<z.ZodObject<{
+        name: z.ZodString;
+        email: z.ZodString;
+    }, z.core.$strip>>;
+    auth: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        carry: z.ZodEnum<{
+            header: "header";
+            userinfo: "userinfo";
+        }>;
+        host: z.ZodString;
+        persist: z.ZodBoolean;
+        kind: z.ZodLiteral<"basic">;
+        username: z.ZodString;
+        token: z.ZodString;
+        expires_at: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        carry: z.ZodEnum<{
+            header: "header";
+            userinfo: "userinfo";
+        }>;
+        host: z.ZodString;
+        persist: z.ZodBoolean;
+        kind: z.ZodLiteral<"bearer">;
+        token: z.ZodString;
+        expires_at: z.ZodString;
+    }, z.core.$strip>], "kind">>;
+}, z.core.$strip>;
+export type CheckoutTokenResponseDto = z.infer<typeof checkoutTokenResponseSchema>;
+//# sourceMappingURL=checkout-token.d.ts.map

package/dist/schemas/checkout-token.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"checkout-token.d.ts","sourceRoot":"","sources":["../../src/schemas/checkout-token.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,CAAC,EAAC,MAAM,KAAK,CAAC;AA4BtB,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;2BAGlC,CAAC;AAEH,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAE3E,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAOtC,CAAC;AAEH,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC"}

package/dist/schemas/checkout-token.js

@@ -0,0 +1,44 @@
+import { z } from 'zod';
+const carryFields = {
+    carry: z.enum([
+        'header',
+        'userinfo'
+    ]),
+    host: z.string().min(1),
+    persist: z.boolean()
+};
+const checkoutGitAuthorSchema = z.object({
+    name: z.string().min(1),
+    email: z.string().min(1)
+});
+const checkoutTokenBasicAuthSchema = z.object({
+    kind: z.literal('basic'),
+    username: z.string().min(1),
+    token: z.string().min(1),
+    expires_at: z.string().datetime({
+        offset: true
+    }),
+    ...carryFields
+});
+const checkoutTokenBearerAuthSchema = z.object({
+    kind: z.literal('bearer'),
+    token: z.string().min(1),
+    expires_at: z.string().datetime({
+        offset: true
+    }),
+    ...carryFields
+});
+export const checkoutTokenAuthSchema = z.discriminatedUnion('kind', [
+    checkoutTokenBasicAuthSchema,
+    checkoutTokenBearerAuthSchema
+]);
+export const checkoutTokenResponseSchema = z.object({
+    repository_url: z.string().min(1),
+    ref: z.string().min(1),
+    git_author: checkoutGitAuthorSchema.optional(),
+    // Optional: credential-free providers (e.g. the debug source control) return a
+    // public clone URL with no auth material, so the runner clones without a token.
+    auth: checkoutTokenAuthSchema.optional()
+});
+
+//# sourceMappingURL=checkout-token.js.map

package/dist/schemas/checkout-token.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/schemas/checkout-token.ts"],"sourcesContent":["import {z} from 'zod';\n\nconst carryFields = {\n  carry: z.enum(['header', 'userinfo']),\n  host: z.string().min(1),\n  persist: z.boolean(),\n};\n\nconst checkoutGitAuthorSchema = z.object({\n  name: z.string().min(1),\n  email: z.string().min(1),\n});\n\nconst checkoutTokenBasicAuthSchema = z.object({\n  kind: z.literal('basic'),\n  username: z.string().min(1),\n  token: z.string().min(1),\n  expires_at: z.string().datetime({offset: true}),\n  ...carryFields,\n});\n\nconst checkoutTokenBearerAuthSchema = z.object({\n  kind: z.literal('bearer'),\n  token: z.string().min(1),\n  expires_at: z.string().datetime({offset: true}),\n  ...carryFields,\n});\n\nexport const checkoutTokenAuthSchema = z.discriminatedUnion('kind', [\n  checkoutTokenBasicAuthSchema,\n  checkoutTokenBearerAuthSchema,\n]);\n\nexport type CheckoutTokenAuthDto = z.infer<typeof checkoutTokenAuthSchema>;\n\nexport const checkoutTokenResponseSchema = z.object({\n  repository_url: z.string().min(1),\n  ref: z.string().min(1),\n  git_author: checkoutGitAuthorSchema.optional(),\n  // Optional: credential-free providers (e.g. the debug source control) return a\n  // public clone URL with no auth material, so the runner clones without a token.\n  auth: checkoutTokenAuthSchema.optional(),\n});\n\nexport type CheckoutTokenResponseDto = z.infer<typeof checkoutTokenResponseSchema>;\n"],"names":["z","carryFields","carry","enum","host","string","min","persist","boolean","checkoutGitAuthorSchema","object","name","email","checkoutTokenBasicAuthSchema","kind","literal","username","token","expires_at","datetime","offset","checkoutTokenBearerAuthSchema","checkoutTokenAuthSchema","discriminatedUnion","checkoutTokenResponseSchema","repository_url","ref","git_author","optional","auth"],"mappings":"AAAA,SAAQA,CAAC,QAAO,MAAM;AAEtB,MAAMC,cAAc;IAClBC,OAAOF,EAAEG,IAAI,CAAC;QAAC;QAAU;KAAW;IACpCC,MAAMJ,EAAEK,MAAM,GAAGC,GAAG,CAAC;IACrBC,SAASP,EAAEQ,OAAO;AACpB;AAEA,MAAMC,0BAA0BT,EAAEU,MAAM,CAAC;IACvCC,MAAMX,EAAEK,MAAM,GAAGC,GAAG,CAAC;IACrBM,OAAOZ,EAAEK,MAAM,GAAGC,GAAG,CAAC;AACxB;AAEA,MAAMO,+BAA+Bb,EAAEU,MAAM,CAAC;IAC5CI,MAAMd,EAAEe,OAAO,CAAC;IAChBC,UAAUhB,EAAEK,MAAM,GAAGC,GAAG,CAAC;IACzBW,OAAOjB,EAAEK,MAAM,GAAGC,GAAG,CAAC;IACtBY,YAAYlB,EAAEK,MAAM,GAAGc,QAAQ,CAAC;QAACC,QAAQ;IAAI;IAC7C,GAAGnB,WAAW;AAChB;AAEA,MAAMoB,gCAAgCrB,EAAEU,MAAM,CAAC;IAC7CI,MAAMd,EAAEe,OAAO,CAAC;IAChBE,OAAOjB,EAAEK,MAAM,GAAGC,GAAG,CAAC;IACtBY,YAAYlB,EAAEK,MAAM,GAAGc,QAAQ,CAAC;QAACC,QAAQ;IAAI;IAC7C,GAAGnB,WAAW;AAChB;AAEA,OAAO,MAAMqB,0BAA0BtB,EAAEuB,kBAAkB,CAAC,QAAQ;IAClEV;IACAQ;CACD,EAAE;AAIH,OAAO,MAAMG,8BAA8BxB,EAAEU,MAAM,CAAC;IAClDe,gBAAgBzB,EAAEK,MAAM,GAAGC,GAAG,CAAC;IAC/BoB,KAAK1B,EAAEK,MAAM,GAAGC,GAAG,CAAC;IACpBqB,YAAYlB,wBAAwBmB,QAAQ;IAC5C,+EAA+E;IAC/E,gFAAgF;IAChFC,MAAMP,wBAAwBM,QAAQ;AACxC,GAAG"}

package/dist/schemas/checkout.d.ts

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+export declare const checkoutIntentSchema: z.ZodObject<{
+    repository_url: z.ZodString;
+    ref: z.ZodString;
+    provider: z.ZodString;
+    source_connection_id: z.ZodString;
+    external_repository_id: z.ZodString;
+}, z.core.$strip>;
+export type CheckoutIntentDto = z.infer<typeof checkoutIntentSchema>;
+//# sourceMappingURL=checkout.d.ts.map

package/dist/schemas/checkout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"checkout.d.ts","sourceRoot":"","sources":["../../src/schemas/checkout.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,CAAC,EAAC,MAAM,KAAK,CAAC;AAEtB,eAAO,MAAM,oBAAoB;;;;;;iBAM/B,CAAC;AAEH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC"}

package/dist/schemas/checkout.js

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+export const checkoutIntentSchema = z.object({
+    repository_url: z.string().min(1),
+    ref: z.string().min(1),
+    provider: z.string().min(1),
+    source_connection_id: z.string().uuid(),
+    external_repository_id: z.string().min(1)
+});
+
+//# sourceMappingURL=checkout.js.map

package/dist/schemas/checkout.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/schemas/checkout.ts"],"sourcesContent":["import {z} from 'zod';\n\nexport const checkoutIntentSchema = z.object({\n  repository_url: z.string().min(1),\n  ref: z.string().min(1),\n  provider: z.string().min(1),\n  source_connection_id: z.string().uuid(),\n  external_repository_id: z.string().min(1),\n});\n\nexport type CheckoutIntentDto = z.infer<typeof checkoutIntentSchema>;\n"],"names":["z","checkoutIntentSchema","object","repository_url","string","min","ref","provider","source_connection_id","uuid","external_repository_id"],"mappings":"AAAA,SAAQA,CAAC,QAAO,MAAM;AAEtB,OAAO,MAAMC,uBAAuBD,EAAEE,MAAM,CAAC;IAC3CC,gBAAgBH,EAAEI,MAAM,GAAGC,GAAG,CAAC;IAC/BC,KAAKN,EAAEI,MAAM,GAAGC,GAAG,CAAC;IACpBE,UAAUP,EAAEI,MAAM,GAAGC,GAAG,CAAC;IACzBG,sBAAsBR,EAAEI,MAAM,GAAGK,IAAI;IACrCC,wBAAwBV,EAAEI,MAAM,GAAGC,GAAG,CAAC;AACzC,GAAG"}

package/dist/schemas/index.d.ts

@@ -0,0 +1,11 @@
+export { type AgentRuntimeConfigQueryDto, agentRuntimeConfigQuerySchema, } from './agent-runtime-config.js';
+export { type CheckoutIntentDto, checkoutIntentSchema } from './checkout.js';
+export { type CheckoutTokenAuthDto, type CheckoutTokenResponseDto, checkoutTokenAuthSchema, checkoutTokenResponseSchema, } from './checkout-token.js';
+export { type JobDto, type JobStatusDto, type JobStatusReasonDto, jobDtoSchema, jobStatusReasonSchema, jobStatusSchema, } from './job.js';
+export { type NextStepResponseDto, nextStepResponseSchema, type ReportStepBodyDto, type ReportStepResponseDto, reportStepBodySchema, reportStepResponseSchema, STEP_RESPONSE_MAX_LENGTH, } from './job-execution.js';
+export { type JobListeningDto, type JobModeDto, jobListeningBatchSchema, jobListeningSchema, jobModeSchema, type ListenerStatusDto, type ListeningTriggerDto, listenerStatusSchema, listeningTriggerSchema, type ResolutionReasonDto, resolutionReasonSchema, type TriggerEventsBatchDto, triggerEventsBatchSchema, type WorkflowExecutionContextDto, type WorkflowExecutionEventDto, workflowExecutionContextSchema, workflowExecutionEventSchema, } from './job-listening.js';
+export { type LogOutcomeDto, logOutcomeSchema } from './log-outcome.js';
+export { type AgentConfigIssueDto, agentConfigIssueSchema, STEP_ERROR_MESSAGE_MAX_LENGTH, type StepAttemptDto, type StepDto, type StepErrorCategoryDto, type StepErrorDto, type StepErrorReasonDto, type StepGateResultDto, stepAttemptDtoSchema, stepDtoSchema, stepErrorCategorySchema, stepErrorDtoSchema, stepErrorReasonSchema, stepGateResultDtoSchema, } from './step.js';
+export { type RerunWorkflowRunBodyDto, rerunWorkflowRunBodySchema, type WorkflowRunAggregatesQueryDto, type WorkflowRunAggregatesResponseDto, type WorkflowRunAttemptDto, type WorkflowRunAttemptsResponseDto, type WorkflowRunDto, type WorkflowRunListQueryDto, type WorkflowRunListResponseDto, type WorkflowRunRerunModeDto, type WorkflowRunResponseDto, type WorkflowRunStatusDto, type WorkflowSourceSnapshotDto, workflowRunAggregatesQuerySchema, workflowRunAggregatesResponseSchema, workflowRunAttemptDtoSchema, workflowRunAttemptsResponseSchema, workflowRunDtoSchema, workflowRunListQuerySchema, workflowRunListResponseSchema, workflowRunRerunModeSchema, workflowRunResponseSchema, workflowRunStatusSchema, workflowSourceSnapshotSchema, } from './workflow-run.js';
+export { type JobExecutionDto, jobExecutionDtoSchema, jobExecutionStatusSchema, type WorkflowRunDetailResponseDto, type WorkflowRunJobDetailDto, type WorkflowRunJobExecutionDetailDto, type WorkflowRunStepDetailDto, workflowRunDetailResponseSchema, workflowRunJobDetailDtoSchema, workflowRunJobExecutionDetailDtoSchema, workflowRunStepDetailDtoSchema, } from './workflow-run-detail.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/schemas/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/schemas/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,0BAA0B,EAC/B,6BAA6B,GAC9B,MAAM,2BAA2B,CAAC;AACnC,OAAO,EAAC,KAAK,iBAAiB,EAAE,oBAAoB,EAAC,MAAM,eAAe,CAAC;AAC3E,OAAO,EACL,KAAK,oBAAoB,EACzB,KAAK,wBAAwB,EAC7B,uBAAuB,EACvB,2BAA2B,GAC5B,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EACL,KAAK,MAAM,EACX,KAAK,YAAY,EACjB,KAAK,kBAAkB,EACvB,YAAY,EACZ,qBAAqB,EACrB,eAAe,GAChB,MAAM,UAAU,CAAC;AAClB,OAAO,EACL,KAAK,mBAAmB,EACxB,sBAAsB,EACtB,KAAK,iBAAiB,EACtB,KAAK,qBAAqB,EAC1B,oBAAoB,EACpB,wBAAwB,EACxB,wBAAwB,GACzB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EACL,KAAK,eAAe,EACpB,KAAK,UAAU,EACf,uBAAuB,EACvB,kBAAkB,EAClB,aAAa,EACb,KAAK,iBAAiB,EACtB,KAAK,mBAAmB,EACxB,oBAAoB,EACpB,sBAAsB,EACtB,KAAK,mBAAmB,EACxB,sBAAsB,EACtB,KAAK,qBAAqB,EAC1B,wBAAwB,EACxB,KAAK,2BAA2B,EAChC,KAAK,yBAAyB,EAC9B,8BAA8B,EAC9B,4BAA4B,GAC7B,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAC,KAAK,aAAa,EAAE,gBAAgB,EAAC,MAAM,kBAAkB,CAAC;AACtE,OAAO,EACL,KAAK,mBAAmB,EACxB,sBAAsB,EACtB,6BAA6B,EAC7B,KAAK,cAAc,EACnB,KAAK,OAAO,EACZ,KAAK,oBAAoB,EACzB,KAAK,YAAY,EACjB,KAAK,kBAAkB,EACvB,KAAK,iBAAiB,EACtB,oBAAoB,EACpB,aAAa,EACb,uBAAuB,EACvB,kBAAkB,EAClB,qBAAqB,EACrB,uBAAuB,GACxB,MAAM,WAAW,CAAC;AACnB,OAAO,EACL,KAAK,uBAAuB,EAC5B,0BAA0B,EAC1B,KAAK,6BAA6B,EAClC,KAAK,gCAAgC,EACrC,KAAK,qBAAqB,EAC1B,KAAK,8BAA8B,EACnC,KAAK,cAAc,EACnB,KAAK,uBAAuB,EAC5B,KAAK,0BAA0B,EAC/B,KAAK,uBAAuB,EAC5B,KAAK,sBAAsB,EAC3B,KAAK,oBAAoB,EACzB,KAAK,yBAAyB,EAC9B,gCAAgC,EAChC,mCAAmC,EACnC,2BAA2B,EAC3B,iCAAiC,EACjC,oBAAoB,EACpB,0BAA0B,EAC1B,6BAA6B,EAC7B,0BAA0B,EAC1B,yBAAyB,EACzB,uBAAuB,EACvB,4BAA4B,GAC7B,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EACL,KAAK,eAAe,EACpB,qBAAqB,EACrB,wBAAwB,EACxB,KAAK,4BAA4B,EACjC,KAAK,uBAAuB,EAC5B,KAAK,gCAAgC,EACrC,KAAK,wBAAwB,EAC7B,+BAA+B,EAC/B,6BAA6B,EAC7B,sCAAsC,EACtC,8BAA8B,GAC/B,MAAM,0BAA0B,CAAC"}

package/dist/schemas/index.js

@@ -0,0 +1,12 @@
+export { agentRuntimeConfigQuerySchema } from './agent-runtime-config.js';
+export { checkoutIntentSchema } from './checkout.js';
+export { checkoutTokenAuthSchema, checkoutTokenResponseSchema } from './checkout-token.js';
+export { jobDtoSchema, jobStatusReasonSchema, jobStatusSchema } from './job.js';
+export { nextStepResponseSchema, reportStepBodySchema, reportStepResponseSchema, STEP_RESPONSE_MAX_LENGTH } from './job-execution.js';
+export { jobListeningBatchSchema, jobListeningSchema, jobModeSchema, listenerStatusSchema, listeningTriggerSchema, resolutionReasonSchema, triggerEventsBatchSchema, workflowExecutionContextSchema, workflowExecutionEventSchema } from './job-listening.js';
+export { logOutcomeSchema } from './log-outcome.js';
+export { agentConfigIssueSchema, STEP_ERROR_MESSAGE_MAX_LENGTH, stepAttemptDtoSchema, stepDtoSchema, stepErrorCategorySchema, stepErrorDtoSchema, stepErrorReasonSchema, stepGateResultDtoSchema } from './step.js';
+export { rerunWorkflowRunBodySchema, workflowRunAggregatesQuerySchema, workflowRunAggregatesResponseSchema, workflowRunAttemptDtoSchema, workflowRunAttemptsResponseSchema, workflowRunDtoSchema, workflowRunListQuerySchema, workflowRunListResponseSchema, workflowRunRerunModeSchema, workflowRunResponseSchema, workflowRunStatusSchema, workflowSourceSnapshotSchema } from './workflow-run.js';
+export { jobExecutionDtoSchema, jobExecutionStatusSchema, workflowRunDetailResponseSchema, workflowRunJobDetailDtoSchema, workflowRunJobExecutionDetailDtoSchema, workflowRunStepDetailDtoSchema } from './workflow-run-detail.js';
+
+//# sourceMappingURL=index.js.map

package/dist/schemas/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/schemas/index.ts"],"sourcesContent":["export {\n  type AgentRuntimeConfigQueryDto,\n  agentRuntimeConfigQuerySchema,\n} from './agent-runtime-config.js';\nexport {type CheckoutIntentDto, checkoutIntentSchema} from './checkout.js';\nexport {\n  type CheckoutTokenAuthDto,\n  type CheckoutTokenResponseDto,\n  checkoutTokenAuthSchema,\n  checkoutTokenResponseSchema,\n} from './checkout-token.js';\nexport {\n  type JobDto,\n  type JobStatusDto,\n  type JobStatusReasonDto,\n  jobDtoSchema,\n  jobStatusReasonSchema,\n  jobStatusSchema,\n} from './job.js';\nexport {\n  type NextStepResponseDto,\n  nextStepResponseSchema,\n  type ReportStepBodyDto,\n  type ReportStepResponseDto,\n  reportStepBodySchema,\n  reportStepResponseSchema,\n  STEP_RESPONSE_MAX_LENGTH,\n} from './job-execution.js';\nexport {\n  type JobListeningDto,\n  type JobModeDto,\n  jobListeningBatchSchema,\n  jobListeningSchema,\n  jobModeSchema,\n  type ListenerStatusDto,\n  type ListeningTriggerDto,\n  listenerStatusSchema,\n  listeningTriggerSchema,\n  type ResolutionReasonDto,\n  resolutionReasonSchema,\n  type TriggerEventsBatchDto,\n  triggerEventsBatchSchema,\n  type WorkflowExecutionContextDto,\n  type WorkflowExecutionEventDto,\n  workflowExecutionContextSchema,\n  workflowExecutionEventSchema,\n} from './job-listening.js';\nexport {type LogOutcomeDto, logOutcomeSchema} from './log-outcome.js';\nexport {\n  type AgentConfigIssueDto,\n  agentConfigIssueSchema,\n  STEP_ERROR_MESSAGE_MAX_LENGTH,\n  type StepAttemptDto,\n  type StepDto,\n  type StepErrorCategoryDto,\n  type StepErrorDto,\n  type StepErrorReasonDto,\n  type StepGateResultDto,\n  stepAttemptDtoSchema,\n  stepDtoSchema,\n  stepErrorCategorySchema,\n  stepErrorDtoSchema,\n  stepErrorReasonSchema,\n  stepGateResultDtoSchema,\n} from './step.js';\nexport {\n  type RerunWorkflowRunBodyDto,\n  rerunWorkflowRunBodySchema,\n  type WorkflowRunAggregatesQueryDto,\n  type WorkflowRunAggregatesResponseDto,\n  type WorkflowRunAttemptDto,\n  type WorkflowRunAttemptsResponseDto,\n  type WorkflowRunDto,\n  type WorkflowRunListQueryDto,\n  type WorkflowRunListResponseDto,\n  type WorkflowRunRerunModeDto,\n  type WorkflowRunResponseDto,\n  type WorkflowRunStatusDto,\n  type WorkflowSourceSnapshotDto,\n  workflowRunAggregatesQuerySchema,\n  workflowRunAggregatesResponseSchema,\n  workflowRunAttemptDtoSchema,\n  workflowRunAttemptsResponseSchema,\n  workflowRunDtoSchema,\n  workflowRunListQuerySchema,\n  workflowRunListResponseSchema,\n  workflowRunRerunModeSchema,\n  workflowRunResponseSchema,\n  workflowRunStatusSchema,\n  workflowSourceSnapshotSchema,\n} from './workflow-run.js';\nexport {\n  type JobExecutionDto,\n  jobExecutionDtoSchema,\n  jobExecutionStatusSchema,\n  type WorkflowRunDetailResponseDto,\n  type WorkflowRunJobDetailDto,\n  type WorkflowRunJobExecutionDetailDto,\n  type WorkflowRunStepDetailDto,\n  workflowRunDetailResponseSchema,\n  workflowRunJobDetailDtoSchema,\n  workflowRunJobExecutionDetailDtoSchema,\n  workflowRunStepDetailDtoSchema,\n} from './workflow-run-detail.js';\n"],"names":["agentRuntimeConfigQuerySchema","checkoutIntentSchema","checkoutTokenAuthSchema","checkoutTokenResponseSchema","jobDtoSchema","jobStatusReasonSchema","jobStatusSchema","nextStepResponseSchema","reportStepBodySchema","reportStepResponseSchema","STEP_RESPONSE_MAX_LENGTH","jobListeningBatchSchema","jobListeningSchema","jobModeSchema","listenerStatusSchema","listeningTriggerSchema","resolutionReasonSchema","triggerEventsBatchSchema","workflowExecutionContextSchema","workflowExecutionEventSchema","logOutcomeSchema","agentConfigIssueSchema","STEP_ERROR_MESSAGE_MAX_LENGTH","stepAttemptDtoSchema","stepDtoSchema","stepErrorCategorySchema","stepErrorDtoSchema","stepErrorReasonSchema","stepGateResultDtoSchema","rerunWorkflowRunBodySchema","workflowRunAggregatesQuerySchema","workflowRunAggregatesResponseSchema","workflowRunAttemptDtoSchema","workflowRunAttemptsResponseSchema","workflowRunDtoSchema","workflowRunListQuerySchema","workflowRunListResponseSchema","workflowRunRerunModeSchema","workflowRunResponseSchema","workflowRunStatusSchema","workflowSourceSnapshotSchema","jobExecutionDtoSchema","jobExecutionStatusSchema","workflowRunDetailResponseSchema","workflowRunJobDetailDtoSchema","workflowRunJobExecutionDetailDtoSchema","workflowRunStepDetailDtoSchema"],"mappings":"AAAA,SAEEA,6BAA6B,QACxB,4BAA4B;AACnC,SAAgCC,oBAAoB,QAAO,gBAAgB;AAC3E,SAGEC,uBAAuB,EACvBC,2BAA2B,QACtB,sBAAsB;AAC7B,SAIEC,YAAY,EACZC,qBAAqB,EACrBC,eAAe,QACV,WAAW;AAClB,SAEEC,sBAAsB,EAGtBC,oBAAoB,EACpBC,wBAAwB,EACxBC,wBAAwB,QACnB,qBAAqB;AAC5B,SAGEC,uBAAuB,EACvBC,kBAAkB,EAClBC,aAAa,EAGbC,oBAAoB,EACpBC,sBAAsB,EAEtBC,sBAAsB,EAEtBC,wBAAwB,EAGxBC,8BAA8B,EAC9BC,4BAA4B,QACvB,qBAAqB;AAC5B,SAA4BC,gBAAgB,QAAO,mBAAmB;AACtE,SAEEC,sBAAsB,EACtBC,6BAA6B,EAO7BC,oBAAoB,EACpBC,aAAa,EACbC,uBAAuB,EACvBC,kBAAkB,EAClBC,qBAAqB,EACrBC,uBAAuB,QAClB,YAAY;AACnB,SAEEC,0BAA0B,EAY1BC,gCAAgC,EAChCC,mCAAmC,EACnCC,2BAA2B,EAC3BC,iCAAiC,EACjCC,oBAAoB,EACpBC,0BAA0B,EAC1BC,6BAA6B,EAC7BC,0BAA0B,EAC1BC,yBAAyB,EACzBC,uBAAuB,EACvBC,4BAA4B,QACvB,oBAAoB;AAC3B,SAEEC,qBAAqB,EACrBC,wBAAwB,EAKxBC,+BAA+B,EAC/BC,6BAA6B,EAC7BC,sCAAsC,EACtCC,8BAA8B,QACzB,2BAA2B"}

package/dist/schemas/job-execution.d.ts

@@ -0,0 +1,116 @@
+import { z } from 'zod';
+export declare const STEP_RESPONSE_MAX_LENGTH: number;
+/**
+ * The job to progress is identified by the caller's lease-token claims, never by
+ * the request. An unknown job is a 404, not a `done`.
+ */
+export declare const nextStepResponseSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"step">;
+    step: z.ZodObject<{
+        id: z.ZodString;
+        job_execution_id: z.ZodString;
+        key: z.ZodNullable<z.ZodString>;
+        name: z.ZodString;
+        source_location: z.ZodNullable<z.ZodObject<{
+            start_line: z.ZodNumber;
+            end_line: z.ZodNumber;
+        }, z.core.$strip>>;
+        status: z.ZodString;
+        type: z.ZodString;
+        config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        error: z.ZodNullable<z.ZodObject<{
+            message: z.ZodString;
+            exit_code: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            signal: z.ZodOptional<z.ZodString>;
+            reason: z.ZodOptional<z.ZodEnum<{
+                checkout_failed: "checkout_failed";
+                checkout_auth_failed: "checkout_auth_failed";
+                checkout_unavailable: "checkout_unavailable";
+                git_unavailable: "git_unavailable";
+                workspace_prep_failed: "workspace_prep_failed";
+                setup_aborted: "setup_aborted";
+                config_unresolvable: "config_unresolvable";
+                output_invalid: "output_invalid";
+                agent_config_invalid: "agent_config_invalid";
+                agent_invocation_failed: "agent_invocation_failed";
+            }>>;
+            field: z.ZodOptional<z.ZodString>;
+            source: z.ZodOptional<z.ZodString>;
+            agent_config_issue: z.ZodOptional<z.ZodEnum<{
+                step_config_invalid: "step_config_invalid";
+                provider_not_configured: "provider_not_configured";
+                provider_unsupported: "provider_unsupported";
+                model_unavailable: "model_unavailable";
+                credentials_invalid: "credentials_invalid";
+            }>>;
+            category: z.ZodOptional<z.ZodEnum<{
+                setup: "setup";
+                user: "user";
+            }>>;
+        }, z.core.$strip>>;
+        position: z.ZodNumber;
+        current_attempt: z.ZodNumber;
+        created_at: z.ZodString;
+        updated_at: z.ZodString;
+    }, z.core.$strip>;
+    attempt: z.ZodNumber;
+    lease_token: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"done">;
+    status: z.ZodEnum<{
+        succeeded: "succeeded";
+        failed: "failed";
+    }>;
+}, z.core.$strip>], "kind">;
+export type NextStepResponseDto = z.infer<typeof nextStepResponseSchema>;
+export declare const reportStepBodySchema: z.ZodObject<{
+    status: z.ZodEnum<{
+        succeeded: "succeeded";
+        failed: "failed";
+    }>;
+    error: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        message: z.ZodString;
+        exit_code: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        signal: z.ZodOptional<z.ZodString>;
+        reason: z.ZodOptional<z.ZodEnum<{
+            checkout_failed: "checkout_failed";
+            checkout_auth_failed: "checkout_auth_failed";
+            checkout_unavailable: "checkout_unavailable";
+            git_unavailable: "git_unavailable";
+            workspace_prep_failed: "workspace_prep_failed";
+            setup_aborted: "setup_aborted";
+            config_unresolvable: "config_unresolvable";
+            output_invalid: "output_invalid";
+            agent_config_invalid: "agent_config_invalid";
+            agent_invocation_failed: "agent_invocation_failed";
+        }>>;
+        field: z.ZodOptional<z.ZodString>;
+        source: z.ZodOptional<z.ZodString>;
+        agent_config_issue: z.ZodOptional<z.ZodEnum<{
+            step_config_invalid: "step_config_invalid";
+            provider_not_configured: "provider_not_configured";
+            provider_unsupported: "provider_unsupported";
+            model_unavailable: "model_unavailable";
+            credentials_invalid: "credentials_invalid";
+        }>>;
+        category: z.ZodOptional<z.ZodEnum<{
+            setup: "setup";
+            user: "user";
+        }>>;
+    }, z.core.$strip>>>;
+    attempt: z.ZodOptional<z.ZodNumber>;
+    exit_code: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    output: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    response: z.ZodOptional<z.ZodString>;
+    log_outcome: z.ZodEnum<{
+        drained: "drained";
+        abandoned: "abandoned";
+    }>;
+}, z.core.$strip>;
+export type ReportStepBodyDto = z.infer<typeof reportStepBodySchema>;
+export declare const reportStepResponseSchema: z.ZodObject<{
+    ok: z.ZodBoolean;
+    cancel: z.ZodBoolean;
+}, z.core.$strip>;
+export type ReportStepResponseDto = z.infer<typeof reportStepResponseSchema>;
+//# sourceMappingURL=job-execution.d.ts.map

package/dist/schemas/job-execution.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"job-execution.d.ts","sourceRoot":"","sources":["../../src/schemas/job-execution.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,CAAC,EAAC,MAAM,KAAK,CAAC;AAItB,eAAO,MAAM,wBAAwB,QAAW,CAAC;AAEjD;;;GAGG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAwBjC,CAAC;AAEH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAEzE,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAwC7B,CAAC;AAEL,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAErE,eAAO,MAAM,wBAAwB;;;iBAOnC,CAAC;AAEH,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC"}

package/dist/schemas/job-execution.js

@@ -0,0 +1,42 @@
+import { z } from 'zod';
+import { logOutcomeSchema } from './log-outcome.js';
+import { stepDtoSchema, stepErrorDtoSchema } from './step.js';
+export const STEP_RESPONSE_MAX_LENGTH = 8 * 1024;
+/**
+ * The job to progress is identified by the caller's lease-token claims, never by
+ * the request. An unknown job is a 404, not a `done`.
+ */ export const nextStepResponseSchema = z.discriminatedUnion('kind', [
+    z.object({
+        kind: z.literal('step'),
+        step: stepDtoSchema,
+        attempt: z.number().int().positive().describe('Attempt number for this step dispatch. Echo it back when reporting the step result so stale reports from older attempts can be ignored.'),
+        lease_token: z.string().min(1).describe('Job-lease token re-scoped to this dispatched step attempt. The runner presents it as its lease for log-append authorization and carries it on later step requests.')
+    }),
+    z.object({
+        kind: z.literal('done'),
+        status: z.enum([
+            'succeeded',
+            'failed'
+        ]).describe('Terminal status of the job when no step remains to run.')
+    })
+]);
+export const reportStepBodySchema = z.object({
+    status: z.enum([
+        'succeeded',
+        'failed'
+    ]).describe('Final status reported for the step attempt.'),
+    error: stepErrorDtoSchema.optional().describe('Failure details. Required when status is failed.'),
+    attempt: z.number().int().positive().optional().describe('Attempt number echoed from next-step. Older runners may omit it; when present, it protects the workflow from stale reports.'),
+    exit_code: z.number().int().nullable().optional().describe('Process exit code for the step attempt. Persisted as the canonical attempt exit code and used by gate evaluation.'),
+    output: z.record(z.string(), z.unknown()).nullable().optional().describe('Structured output captured for attempt history. Large textual logs are stored separately.'),
+    response: z.string().max(STEP_RESPONSE_MAX_LENGTH).optional().describe('Capped final assistant response for agent step attempts. Omitted for run steps.'),
+    log_outcome: logOutcomeSchema.describe('Whether the runner drained all locally spooled logs before reporting, or abandoned the log stream for backend closure.')
+}).refine((body)=>body.status === 'succeeded' ? body.error == null : body.error != null, {
+    message: 'succeeded steps must not include an error and failed steps must include one'
+});
+export const reportStepResponseSchema = z.object({
+    ok: z.boolean().describe('Whether the step report was accepted.'),
+    cancel: z.boolean().describe('Whether the runner should stop working on the job because it finished without full success.')
+});
+
+//# sourceMappingURL=job-execution.js.map

package/dist/schemas/job-execution.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/schemas/job-execution.ts"],"sourcesContent":["import {z} from 'zod';\nimport {logOutcomeSchema} from './log-outcome.js';\nimport {stepDtoSchema, stepErrorDtoSchema} from './step.js';\n\nexport const STEP_RESPONSE_MAX_LENGTH = 8 * 1024;\n\n/**\n * The job to progress is identified by the caller's lease-token claims, never by\n * the request. An unknown job is a 404, not a `done`.\n */\nexport const nextStepResponseSchema = z.discriminatedUnion('kind', [\n  z.object({\n    kind: z.literal('step'),\n    step: stepDtoSchema,\n    attempt: z\n      .number()\n      .int()\n      .positive()\n      .describe(\n        'Attempt number for this step dispatch. Echo it back when reporting the step result so stale reports from older attempts can be ignored.',\n      ),\n    lease_token: z\n      .string()\n      .min(1)\n      .describe(\n        'Job-lease token re-scoped to this dispatched step attempt. The runner presents it as its lease for log-append authorization and carries it on later step requests.',\n      ),\n  }),\n  z.object({\n    kind: z.literal('done'),\n    status: z\n      .enum(['succeeded', 'failed'])\n      .describe('Terminal status of the job when no step remains to run.'),\n  }),\n]);\n\nexport type NextStepResponseDto = z.infer<typeof nextStepResponseSchema>;\n\nexport const reportStepBodySchema = z\n  .object({\n    status: z.enum(['succeeded', 'failed']).describe('Final status reported for the step attempt.'),\n    error: stepErrorDtoSchema\n      .optional()\n      .describe('Failure details. Required when status is failed.'),\n    attempt: z\n      .number()\n      .int()\n      .positive()\n      .optional()\n      .describe(\n        'Attempt number echoed from next-step. Older runners may omit it; when present, it protects the workflow from stale reports.',\n      ),\n    exit_code: z\n      .number()\n      .int()\n      .nullable()\n      .optional()\n      .describe(\n        'Process exit code for the step attempt. Persisted as the canonical attempt exit code and used by gate evaluation.',\n      ),\n    output: z\n      .record(z.string(), z.unknown())\n      .nullable()\n      .optional()\n      .describe(\n        'Structured output captured for attempt history. Large textual logs are stored separately.',\n      ),\n    response: z\n      .string()\n      .max(STEP_RESPONSE_MAX_LENGTH)\n      .optional()\n      .describe('Capped final assistant response for agent step attempts. Omitted for run steps.'),\n    log_outcome: logOutcomeSchema.describe(\n      'Whether the runner drained all locally spooled logs before reporting, or abandoned the log stream for backend closure.',\n    ),\n  })\n  .refine((body) => (body.status === 'succeeded' ? body.error == null : body.error != null), {\n    message: 'succeeded steps must not include an error and failed steps must include one',\n  });\n\nexport type ReportStepBodyDto = z.infer<typeof reportStepBodySchema>;\n\nexport const reportStepResponseSchema = z.object({\n  ok: z.boolean().describe('Whether the step report was accepted.'),\n  cancel: z\n    .boolean()\n    .describe(\n      'Whether the runner should stop working on the job because it finished without full success.',\n    ),\n});\n\nexport type ReportStepResponseDto = z.infer<typeof reportStepResponseSchema>;\n"],"names":["z","logOutcomeSchema","stepDtoSchema","stepErrorDtoSchema","STEP_RESPONSE_MAX_LENGTH","nextStepResponseSchema","discriminatedUnion","object","kind","literal","step","attempt","number","int","positive","describe","lease_token","string","min","status","enum","reportStepBodySchema","error","optional","exit_code","nullable","output","record","unknown","response","max","log_outcome","refine","body","message","reportStepResponseSchema","ok","boolean","cancel"],"mappings":"AAAA,SAAQA,CAAC,QAAO,MAAM;AACtB,SAAQC,gBAAgB,QAAO,mBAAmB;AAClD,SAAQC,aAAa,EAAEC,kBAAkB,QAAO,YAAY;AAE5D,OAAO,MAAMC,2BAA2B,IAAI,KAAK;AAEjD;;;CAGC,GACD,OAAO,MAAMC,yBAAyBL,EAAEM,kBAAkB,CAAC,QAAQ;IACjEN,EAAEO,MAAM,CAAC;QACPC,MAAMR,EAAES,OAAO,CAAC;QAChBC,MAAMR;QACNS,SAASX,EACNY,MAAM,GACNC,GAAG,GACHC,QAAQ,GACRC,QAAQ,CACP;QAEJC,aAAahB,EACViB,MAAM,GACNC,GAAG,CAAC,GACJH,QAAQ,CACP;IAEN;IACAf,EAAEO,MAAM,CAAC;QACPC,MAAMR,EAAES,OAAO,CAAC;QAChBU,QAAQnB,EACLoB,IAAI,CAAC;YAAC;YAAa;SAAS,EAC5BL,QAAQ,CAAC;IACd;CACD,EAAE;AAIH,OAAO,MAAMM,uBAAuBrB,EACjCO,MAAM,CAAC;IACNY,QAAQnB,EAAEoB,IAAI,CAAC;QAAC;QAAa;KAAS,EAAEL,QAAQ,CAAC;IACjDO,OAAOnB,mBACJoB,QAAQ,GACRR,QAAQ,CAAC;IACZJ,SAASX,EACNY,MAAM,GACNC,GAAG,GACHC,QAAQ,GACRS,QAAQ,GACRR,QAAQ,CACP;IAEJS,WAAWxB,EACRY,MAAM,GACNC,GAAG,GACHY,QAAQ,GACRF,QAAQ,GACRR,QAAQ,CACP;IAEJW,QAAQ1B,EACL2B,MAAM,CAAC3B,EAAEiB,MAAM,IAAIjB,EAAE4B,OAAO,IAC5BH,QAAQ,GACRF,QAAQ,GACRR,QAAQ,CACP;IAEJc,UAAU7B,EACPiB,MAAM,GACNa,GAAG,CAAC1B,0BACJmB,QAAQ,GACRR,QAAQ,CAAC;IACZgB,aAAa9B,iBAAiBc,QAAQ,CACpC;AAEJ,GACCiB,MAAM,CAAC,CAACC,OAAUA,KAAKd,MAAM,KAAK,cAAcc,KAAKX,KAAK,IAAI,OAAOW,KAAKX,KAAK,IAAI,MAAO;IACzFY,SAAS;AACX,GAAG;AAIL,OAAO,MAAMC,2BAA2BnC,EAAEO,MAAM,CAAC;IAC/C6B,IAAIpC,EAAEqC,OAAO,GAAGtB,QAAQ,CAAC;IACzBuB,QAAQtC,EACLqC,OAAO,GACPtB,QAAQ,CACP;AAEN,GAAG"}

package/dist/schemas/job-listening.d.ts

@@ -0,0 +1,93 @@
+import { z } from 'zod';
+export declare const jobModeSchema: z.ZodEnum<{
+    one_shot: "one_shot";
+    listening: "listening";
+}>;
+export declare const listenerStatusSchema: z.ZodEnum<{
+    listening: "listening";
+    inactive: "inactive";
+    resolved: "resolved";
+}>;
+export declare const resolutionReasonSchema: z.ZodEnum<{
+    until: "until";
+    timeout: "timeout";
+    max_executions: "max_executions";
+    cancelled: "cancelled";
+}>;
+export declare const listeningTriggerSchema: z.ZodObject<{
+    source: z.ZodString;
+    event: z.ZodString;
+    inputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    filter: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const jobListeningBatchSchema: z.ZodObject<{
+    debounce_ms: z.ZodOptional<z.ZodNumber>;
+    max_size: z.ZodOptional<z.ZodNumber>;
+    max_wait_ms: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const jobListeningSchema: z.ZodObject<{
+    on: z.ZodArray<z.ZodObject<{
+        source: z.ZodString;
+        event: z.ZodString;
+        inputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        filter: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    until: z.ZodNullable<z.ZodArray<z.ZodObject<{
+        source: z.ZodString;
+        event: z.ZodString;
+        inputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        filter: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    timeout_ms: z.ZodNullable<z.ZodNumber>;
+    max_executions: z.ZodNullable<z.ZodNumber>;
+    batch: z.ZodNullable<z.ZodObject<{
+        debounce_ms: z.ZodOptional<z.ZodNumber>;
+        max_size: z.ZodOptional<z.ZodNumber>;
+        max_wait_ms: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    on_resolve: z.ZodEnum<{
+        finish: "finish";
+        cancel: "cancel";
+    }>;
+    execution_timeout_ms: z.ZodNullable<z.ZodNumber>;
+    name: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export declare const workflowExecutionEventSchema: z.ZodObject<{
+    source: z.ZodString;
+    event: z.ZodString;
+    delivery_id: z.ZodString;
+    received_at: z.ZodString;
+    data: z.ZodUnknown;
+}, z.core.$strip>;
+export declare const workflowExecutionContextSchema: z.ZodObject<{
+    index: z.ZodNumber;
+    name: z.ZodString;
+    status: z.ZodString;
+    started_at: z.ZodNullable<z.ZodString>;
+    finished_at: z.ZodNullable<z.ZodString>;
+    events: z.ZodArray<z.ZodObject<{
+        source: z.ZodString;
+        event: z.ZodString;
+        delivery_id: z.ZodString;
+        received_at: z.ZodString;
+        data: z.ZodUnknown;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const triggerEventsBatchSchema: z.ZodObject<{
+    events: z.ZodArray<z.ZodObject<{
+        source: z.ZodString;
+        event: z.ZodString;
+        delivery_id: z.ZodString;
+        received_at: z.ZodString;
+        data: z.ZodUnknown;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type JobModeDto = z.infer<typeof jobModeSchema>;
+export type ListenerStatusDto = z.infer<typeof listenerStatusSchema>;
+export type ResolutionReasonDto = z.infer<typeof resolutionReasonSchema>;
+export type ListeningTriggerDto = z.infer<typeof listeningTriggerSchema>;
+export type JobListeningDto = z.infer<typeof jobListeningSchema>;
+export type WorkflowExecutionEventDto = z.infer<typeof workflowExecutionEventSchema>;
+export type WorkflowExecutionContextDto = z.infer<typeof workflowExecutionContextSchema>;
+export type TriggerEventsBatchDto = z.infer<typeof triggerEventsBatchSchema>;
+//# sourceMappingURL=job-listening.d.ts.map

package/dist/schemas/job-listening.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"job-listening.d.ts","sourceRoot":"","sources":["../../src/schemas/job-listening.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,CAAC,EAAC,MAAM,KAAK,CAAC;AAEtB,eAAO,MAAM,aAAa;;;EAAoC,CAAC;AAC/D,eAAO,MAAM,oBAAoB;;;;EAAgD,CAAC;AAClF,eAAO,MAAM,sBAAsB;;;;;EAA8D,CAAC;AAElG,eAAO,MAAM,sBAAsB;;;;;iBAKjC,CAAC;AAEH,eAAO,MAAM,uBAAuB;;;;iBAIlC,CAAC;AAEH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;iBAS7B,CAAC;AAEH,eAAO,MAAM,4BAA4B;;;;;;iBAMvC,CAAC;AAEH,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;iBAOzC,CAAC;AAEH,eAAO,MAAM,wBAAwB;;;;;;;;iBAEnC,CAAC;AAEH,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AACvD,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AACrE,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AACzE,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AACzE,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AACjE,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAC;AACrF,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,8BAA8B,CAAC,CAAC;AACzF,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC"}

package/dist/schemas/job-listening.js

@@ -0,0 +1,60 @@
+import { z } from 'zod';
+export const jobModeSchema = z.enum([
+    'one_shot',
+    'listening'
+]);
+export const listenerStatusSchema = z.enum([
+    'inactive',
+    'listening',
+    'resolved'
+]);
+export const resolutionReasonSchema = z.enum([
+    'until',
+    'timeout',
+    'max_executions',
+    'cancelled'
+]);
+export const listeningTriggerSchema = z.object({
+    source: z.string(),
+    event: z.string(),
+    inputs: z.record(z.string(), z.unknown()).optional(),
+    filter: z.string().optional()
+});
+export const jobListeningBatchSchema = z.object({
+    debounce_ms: z.number().int().positive().optional(),
+    max_size: z.number().int().positive().optional(),
+    max_wait_ms: z.number().int().positive().optional()
+});
+export const jobListeningSchema = z.object({
+    on: z.array(listeningTriggerSchema).min(1),
+    until: z.array(listeningTriggerSchema).min(1).nullable(),
+    timeout_ms: z.number().int().positive().nullable(),
+    max_executions: z.number().int().positive().nullable(),
+    batch: jobListeningBatchSchema.nullable(),
+    on_resolve: z.enum([
+        'finish',
+        'cancel'
+    ]),
+    execution_timeout_ms: z.number().int().positive().nullable(),
+    name: z.string().nullable()
+});
+export const workflowExecutionEventSchema = z.object({
+    source: z.string(),
+    event: z.string(),
+    delivery_id: z.string(),
+    received_at: z.string(),
+    data: z.unknown()
+});
+export const workflowExecutionContextSchema = z.object({
+    index: z.number().int().nonnegative(),
+    name: z.string(),
+    status: z.string(),
+    started_at: z.string().nullable(),
+    finished_at: z.string().nullable(),
+    events: z.array(workflowExecutionEventSchema)
+});
+export const triggerEventsBatchSchema = z.object({
+    events: z.array(workflowExecutionEventSchema)
+});
+
+//# sourceMappingURL=job-listening.js.map

package/dist/schemas/job-listening.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/schemas/job-listening.ts"],"sourcesContent":["import {z} from 'zod';\n\nexport const jobModeSchema = z.enum(['one_shot', 'listening']);\nexport const listenerStatusSchema = z.enum(['inactive', 'listening', 'resolved']);\nexport const resolutionReasonSchema = z.enum(['until', 'timeout', 'max_executions', 'cancelled']);\n\nexport const listeningTriggerSchema = z.object({\n  source: z.string(),\n  event: z.string(),\n  inputs: z.record(z.string(), z.unknown()).optional(),\n  filter: z.string().optional(),\n});\n\nexport const jobListeningBatchSchema = z.object({\n  debounce_ms: z.number().int().positive().optional(),\n  max_size: z.number().int().positive().optional(),\n  max_wait_ms: z.number().int().positive().optional(),\n});\n\nexport const jobListeningSchema = z.object({\n  on: z.array(listeningTriggerSchema).min(1),\n  until: z.array(listeningTriggerSchema).min(1).nullable(),\n  timeout_ms: z.number().int().positive().nullable(),\n  max_executions: z.number().int().positive().nullable(),\n  batch: jobListeningBatchSchema.nullable(),\n  on_resolve: z.enum(['finish', 'cancel']),\n  execution_timeout_ms: z.number().int().positive().nullable(),\n  name: z.string().nullable(),\n});\n\nexport const workflowExecutionEventSchema = z.object({\n  source: z.string(),\n  event: z.string(),\n  delivery_id: z.string(),\n  received_at: z.string(),\n  data: z.unknown(),\n});\n\nexport const workflowExecutionContextSchema = z.object({\n  index: z.number().int().nonnegative(),\n  name: z.string(),\n  status: z.string(),\n  started_at: z.string().nullable(),\n  finished_at: z.string().nullable(),\n  events: z.array(workflowExecutionEventSchema),\n});\n\nexport const triggerEventsBatchSchema = z.object({\n  events: z.array(workflowExecutionEventSchema),\n});\n\nexport type JobModeDto = z.infer<typeof jobModeSchema>;\nexport type ListenerStatusDto = z.infer<typeof listenerStatusSchema>;\nexport type ResolutionReasonDto = z.infer<typeof resolutionReasonSchema>;\nexport type ListeningTriggerDto = z.infer<typeof listeningTriggerSchema>;\nexport type JobListeningDto = z.infer<typeof jobListeningSchema>;\nexport type WorkflowExecutionEventDto = z.infer<typeof workflowExecutionEventSchema>;\nexport type WorkflowExecutionContextDto = z.infer<typeof workflowExecutionContextSchema>;\nexport type TriggerEventsBatchDto = z.infer<typeof triggerEventsBatchSchema>;\n"],"names":["z","jobModeSchema","enum","listenerStatusSchema","resolutionReasonSchema","listeningTriggerSchema","object","source","string","event","inputs","record","unknown","optional","filter","jobListeningBatchSchema","debounce_ms","number","int","positive","max_size","max_wait_ms","jobListeningSchema","on","array","min","until","nullable","timeout_ms","max_executions","batch","on_resolve","execution_timeout_ms","name","workflowExecutionEventSchema","delivery_id","received_at","data","workflowExecutionContextSchema","index","nonnegative","status","started_at","finished_at","events","triggerEventsBatchSchema"],"mappings":"AAAA,SAAQA,CAAC,QAAO,MAAM;AAEtB,OAAO,MAAMC,gBAAgBD,EAAEE,IAAI,CAAC;IAAC;IAAY;CAAY,EAAE;AAC/D,OAAO,MAAMC,uBAAuBH,EAAEE,IAAI,CAAC;IAAC;IAAY;IAAa;CAAW,EAAE;AAClF,OAAO,MAAME,yBAAyBJ,EAAEE,IAAI,CAAC;IAAC;IAAS;IAAW;IAAkB;CAAY,EAAE;AAElG,OAAO,MAAMG,yBAAyBL,EAAEM,MAAM,CAAC;IAC7CC,QAAQP,EAAEQ,MAAM;IAChBC,OAAOT,EAAEQ,MAAM;IACfE,QAAQV,EAAEW,MAAM,CAACX,EAAEQ,MAAM,IAAIR,EAAEY,OAAO,IAAIC,QAAQ;IAClDC,QAAQd,EAAEQ,MAAM,GAAGK,QAAQ;AAC7B,GAAG;AAEH,OAAO,MAAME,0BAA0Bf,EAAEM,MAAM,CAAC;IAC9CU,aAAahB,EAAEiB,MAAM,GAAGC,GAAG,GAAGC,QAAQ,GAAGN,QAAQ;IACjDO,UAAUpB,EAAEiB,MAAM,GAAGC,GAAG,GAAGC,QAAQ,GAAGN,QAAQ;IAC9CQ,aAAarB,EAAEiB,MAAM,GAAGC,GAAG,GAAGC,QAAQ,GAAGN,QAAQ;AACnD,GAAG;AAEH,OAAO,MAAMS,qBAAqBtB,EAAEM,MAAM,CAAC;IACzCiB,IAAIvB,EAAEwB,KAAK,CAACnB,wBAAwBoB,GAAG,CAAC;IACxCC,OAAO1B,EAAEwB,KAAK,CAACnB,wBAAwBoB,GAAG,CAAC,GAAGE,QAAQ;IACtDC,YAAY5B,EAAEiB,MAAM,GAAGC,GAAG,GAAGC,QAAQ,GAAGQ,QAAQ;IAChDE,gBAAgB7B,EAAEiB,MAAM,GAAGC,GAAG,GAAGC,QAAQ,GAAGQ,QAAQ;IACpDG,OAAOf,wBAAwBY,QAAQ;IACvCI,YAAY/B,EAAEE,IAAI,CAAC;QAAC;QAAU;KAAS;IACvC8B,sBAAsBhC,EAAEiB,MAAM,GAAGC,GAAG,GAAGC,QAAQ,GAAGQ,QAAQ;IAC1DM,MAAMjC,EAAEQ,MAAM,GAAGmB,QAAQ;AAC3B,GAAG;AAEH,OAAO,MAAMO,+BAA+BlC,EAAEM,MAAM,CAAC;IACnDC,QAAQP,EAAEQ,MAAM;IAChBC,OAAOT,EAAEQ,MAAM;IACf2B,aAAanC,EAAEQ,MAAM;IACrB4B,aAAapC,EAAEQ,MAAM;IACrB6B,MAAMrC,EAAEY,OAAO;AACjB,GAAG;AAEH,OAAO,MAAM0B,iCAAiCtC,EAAEM,MAAM,CAAC;IACrDiC,OAAOvC,EAAEiB,MAAM,GAAGC,GAAG,GAAGsB,WAAW;IACnCP,MAAMjC,EAAEQ,MAAM;IACdiC,QAAQzC,EAAEQ,MAAM;IAChBkC,YAAY1C,EAAEQ,MAAM,GAAGmB,QAAQ;IAC/BgB,aAAa3C,EAAEQ,MAAM,GAAGmB,QAAQ;IAChCiB,QAAQ5C,EAAEwB,KAAK,CAACU;AAClB,GAAG;AAEH,OAAO,MAAMW,2BAA2B7C,EAAEM,MAAM,CAAC;IAC/CsC,QAAQ5C,EAAEwB,KAAK,CAACU;AAClB,GAAG"}