@shipfox/api-definitions-dto 2.0.0

package/.turbo/turbo-build.log

@@ -0,0 +1,2 @@
+$ shipfox-swc
+Successfully compiled: 5 files with swc (38.62ms)

package/.turbo/turbo-type$colon$emit.log

@@ -0,0 +1 @@
+$ shipfox-tsc-emit

package/.turbo/turbo-type.log

@@ -0,0 +1 @@
+$ shipfox-tsc-check

package/CHANGELOG.md

@@ -0,0 +1,28 @@
+# @shipfox/api-definitions-dto
+
+## 2.0.0
+
+### Minor Changes
+
+- 1b0d344: Publishes the complete API runtime closure with packed-consumer-safe internal imports and records its exact package set in application releases.
+
+## 0.0.1
+
+### Patch Changes
+
+- 59ba68b: Integrates workflow definitions with accepted workflow documents and normalized workflow models.
+- 7fa8f0b: Fix VCS sync failing when a manual definition shares a config_path. The
+  `definitions_wd_project_id_config_path_unique` index was source-agnostic, so a
+  manual (or validated) definition and a ref/sha-keyed VCS definition at the same
+  `config_path` collided on an index that was not the VCS upsert's `ON CONFLICT`
+  arbiter, raising an unhandled unique violation and breaking sync. The index (and
+  the manual upsert predicate) is now scoped to manual rows so the two coexist.
+
+  A CHECK constraint and request validation now bind `source` to its git
+  coordinates (vcs rows carry a ref or sha; manual rows carry neither), so the
+  index predicate's correctness is enforced rather than incidental.
+
+- 9a5aac4: Adds cron trigger schedule and timezone fields with source-specific document validation.
+- 61de795: Adds canonical runner label validation and default runner label fallback for workflow definition parsing.
+- 2933c33: Adds drain-boundary Zod validation for current outbox publisher event payloads.
+- b8919da: Removes the unused workflow-spec, job, and step schemas now that `@shipfox/workflow-document` owns workflow document parsing, keeping only the still-used `TriggerDto` type.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Shipfox
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/events.d.ts

@@ -0,0 +1,61 @@
+import { z } from 'zod';
+export declare const DEFINITION_RESOLVED: "definitions.definition.resolved";
+export declare const DEFINITION_DELETED: "definitions.definition.deleted";
+export declare const DEFINITION_INVALID: "definitions.definition.invalid";
+export declare const definitionResolvedEventSchema: z.ZodObject<{
+    definitionId: z.ZodString;
+    projectId: z.ZodString;
+    workspaceId: z.ZodString;
+    configPath: z.ZodNullable<z.ZodString>;
+    triggers: z.ZodRecord<z.ZodString, z.ZodObject<{
+        source: z.ZodString;
+        event: z.ZodString;
+        with: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        filter: z.ZodOptional<z.ZodString>;
+        config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type DefinitionResolvedEvent = z.infer<typeof definitionResolvedEventSchema>;
+export declare const definitionDeletedEventSchema: z.ZodObject<{
+    definitionId: z.ZodString;
+    projectId: z.ZodString;
+    workspaceId: z.ZodString;
+}, z.core.$strip>;
+export type DefinitionDeletedEvent = z.infer<typeof definitionDeletedEventSchema>;
+export declare const definitionInvalidEventSchema: z.ZodObject<{
+    projectId: z.ZodString;
+    ref: z.ZodString;
+    errors: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export type DefinitionInvalidEvent = z.infer<typeof definitionInvalidEventSchema>;
+export interface DefinitionsEventMap {
+    [DEFINITION_RESOLVED]: DefinitionResolvedEvent;
+    [DEFINITION_DELETED]: DefinitionDeletedEvent;
+    [DEFINITION_INVALID]: DefinitionInvalidEvent;
+}
+export declare const definitionsEventSchemas: {
+    "definitions.definition.resolved": z.ZodObject<{
+        definitionId: z.ZodString;
+        projectId: z.ZodString;
+        workspaceId: z.ZodString;
+        configPath: z.ZodNullable<z.ZodString>;
+        triggers: z.ZodRecord<z.ZodString, z.ZodObject<{
+            source: z.ZodString;
+            event: z.ZodString;
+            with: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            filter: z.ZodOptional<z.ZodString>;
+            config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    "definitions.definition.deleted": z.ZodObject<{
+        definitionId: z.ZodString;
+        projectId: z.ZodString;
+        workspaceId: z.ZodString;
+    }, z.core.$strip>;
+    "definitions.definition.invalid": z.ZodObject<{
+        projectId: z.ZodString;
+        ref: z.ZodString;
+        errors: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>;
+};
+//# sourceMappingURL=events.d.ts.map

package/dist/events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"events.d.ts","sourceRoot":"","sources":["../src/events.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,CAAC,EAAC,MAAM,KAAK,CAAC;AAKtB,eAAO,MAAM,mBAAmB,EAAG,iCAA0C,CAAC;AAC9E,eAAO,MAAM,kBAAkB,EAAG,gCAAyC,CAAC;AAC5E,eAAO,MAAM,kBAAkB,EAAG,gCAAyC,CAAC;AAE5E,eAAO,MAAM,6BAA6B;;;;;;;;;;;;iBAMxC,CAAC;AACH,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,6BAA6B,CAAC,CAAC;AAEpF,eAAO,MAAM,4BAA4B;;;;iBAIvC,CAAC;AACH,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAC;AAElF,eAAO,MAAM,4BAA4B;;;;iBAIvC,CAAC;AACH,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAC;AAElF,MAAM,WAAW,mBAAmB;IAClC,CAAC,mBAAmB,CAAC,EAAE,uBAAuB,CAAC;IAC/C,CAAC,kBAAkB,CAAC,EAAE,sBAAsB,CAAC;IAC7C,CAAC,kBAAkB,CAAC,EAAE,sBAAsB,CAAC;CAC9C;AAED,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;CAIoB,CAAC"}

package/dist/events.js

@@ -0,0 +1,30 @@
+import { z } from 'zod';
+import { triggerDtoSchema } from '#schemas/trigger.js';
+const nonEmptyStringSchema = z.string().nonempty();
+export const DEFINITION_RESOLVED = 'definitions.definition.resolved';
+export const DEFINITION_DELETED = 'definitions.definition.deleted';
+export const DEFINITION_INVALID = 'definitions.definition.invalid';
+export const definitionResolvedEventSchema = z.object({
+    definitionId: nonEmptyStringSchema,
+    projectId: nonEmptyStringSchema,
+    workspaceId: nonEmptyStringSchema,
+    configPath: z.string().nullable(),
+    triggers: z.record(z.string(), triggerDtoSchema)
+});
+export const definitionDeletedEventSchema = z.object({
+    definitionId: nonEmptyStringSchema,
+    projectId: nonEmptyStringSchema,
+    workspaceId: nonEmptyStringSchema
+});
+export const definitionInvalidEventSchema = z.object({
+    projectId: nonEmptyStringSchema,
+    ref: nonEmptyStringSchema,
+    errors: z.array(z.string())
+});
+export const definitionsEventSchemas = {
+    [DEFINITION_RESOLVED]: definitionResolvedEventSchema,
+    [DEFINITION_DELETED]: definitionDeletedEventSchema,
+    [DEFINITION_INVALID]: definitionInvalidEventSchema
+};
+
+//# sourceMappingURL=events.js.map

package/dist/events.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/events.ts"],"sourcesContent":["import {z} from 'zod';\nimport {triggerDtoSchema} from '#schemas/trigger.js';\n\nconst nonEmptyStringSchema = z.string().nonempty();\n\nexport const DEFINITION_RESOLVED = 'definitions.definition.resolved' as const;\nexport const DEFINITION_DELETED = 'definitions.definition.deleted' as const;\nexport const DEFINITION_INVALID = 'definitions.definition.invalid' as const;\n\nexport const definitionResolvedEventSchema = z.object({\n  definitionId: nonEmptyStringSchema,\n  projectId: nonEmptyStringSchema,\n  workspaceId: nonEmptyStringSchema,\n  configPath: z.string().nullable(),\n  triggers: z.record(z.string(), triggerDtoSchema),\n});\nexport type DefinitionResolvedEvent = z.infer<typeof definitionResolvedEventSchema>;\n\nexport const definitionDeletedEventSchema = z.object({\n  definitionId: nonEmptyStringSchema,\n  projectId: nonEmptyStringSchema,\n  workspaceId: nonEmptyStringSchema,\n});\nexport type DefinitionDeletedEvent = z.infer<typeof definitionDeletedEventSchema>;\n\nexport const definitionInvalidEventSchema = z.object({\n  projectId: nonEmptyStringSchema,\n  ref: nonEmptyStringSchema,\n  errors: z.array(z.string()),\n});\nexport type DefinitionInvalidEvent = z.infer<typeof definitionInvalidEventSchema>;\n\nexport interface DefinitionsEventMap {\n  [DEFINITION_RESOLVED]: DefinitionResolvedEvent;\n  [DEFINITION_DELETED]: DefinitionDeletedEvent;\n  [DEFINITION_INVALID]: DefinitionInvalidEvent;\n}\n\nexport const definitionsEventSchemas = {\n  [DEFINITION_RESOLVED]: definitionResolvedEventSchema,\n  [DEFINITION_DELETED]: definitionDeletedEventSchema,\n  [DEFINITION_INVALID]: definitionInvalidEventSchema,\n} satisfies Record<keyof DefinitionsEventMap, z.ZodType>;\n"],"names":["z","triggerDtoSchema","nonEmptyStringSchema","string","nonempty","DEFINITION_RESOLVED","DEFINITION_DELETED","DEFINITION_INVALID","definitionResolvedEventSchema","object","definitionId","projectId","workspaceId","configPath","nullable","triggers","record","definitionDeletedEventSchema","definitionInvalidEventSchema","ref","errors","array","definitionsEventSchemas"],"mappings":"AAAA,SAAQA,CAAC,QAAO,MAAM;AACtB,SAAQC,gBAAgB,QAAO,sBAAsB;AAErD,MAAMC,uBAAuBF,EAAEG,MAAM,GAAGC,QAAQ;AAEhD,OAAO,MAAMC,sBAAsB,kCAA2C;AAC9E,OAAO,MAAMC,qBAAqB,iCAA0C;AAC5E,OAAO,MAAMC,qBAAqB,iCAA0C;AAE5E,OAAO,MAAMC,gCAAgCR,EAAES,MAAM,CAAC;IACpDC,cAAcR;IACdS,WAAWT;IACXU,aAAaV;IACbW,YAAYb,EAAEG,MAAM,GAAGW,QAAQ;IAC/BC,UAAUf,EAAEgB,MAAM,CAAChB,EAAEG,MAAM,IAAIF;AACjC,GAAG;AAGH,OAAO,MAAMgB,+BAA+BjB,EAAES,MAAM,CAAC;IACnDC,cAAcR;IACdS,WAAWT;IACXU,aAAaV;AACf,GAAG;AAGH,OAAO,MAAMgB,+BAA+BlB,EAAES,MAAM,CAAC;IACnDE,WAAWT;IACXiB,KAAKjB;IACLkB,QAAQpB,EAAEqB,KAAK,CAACrB,EAAEG,MAAM;AAC1B,GAAG;AASH,OAAO,MAAMmB,0BAA0B;IACrC,CAACjB,oBAAoB,EAAEG;IACvB,CAACF,mBAAmB,EAAEW;IACtB,CAACV,mBAAmB,EAAEW;AACxB,EAAyD"}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { type CreateDefinitionBodyDto, createDefinitionBodySchema, type DefinitionDto, type DefinitionListQueryDto, type DefinitionListResponseDto, type DefinitionResponseDto, type DefinitionSyncSummaryDto, type DefinitionValidationErrorDto, definitionDtoSchema, definitionListQuerySchema, definitionListResponseSchema, definitionResponseSchema, definitionSyncSummarySchema, definitionValidationErrorSchema, type TriggerDto, } from '#schemas/index.js';
+export { DEFINITION_DELETED, DEFINITION_INVALID, DEFINITION_RESOLVED, type DefinitionDeletedEvent, type DefinitionInvalidEvent, type DefinitionResolvedEvent, type DefinitionsEventMap, definitionDeletedEventSchema, definitionInvalidEventSchema, definitionResolvedEventSchema, definitionsEventSchemas, } from './events.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,uBAAuB,EAC5B,0BAA0B,EAC1B,KAAK,aAAa,EAClB,KAAK,sBAAsB,EAC3B,KAAK,yBAAyB,EAC9B,KAAK,qBAAqB,EAC1B,KAAK,wBAAwB,EAC7B,KAAK,4BAA4B,EACjC,mBAAmB,EACnB,yBAAyB,EACzB,4BAA4B,EAC5B,wBAAwB,EACxB,2BAA2B,EAC3B,+BAA+B,EAC/B,KAAK,UAAU,GAChB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EACL,kBAAkB,EAClB,kBAAkB,EAClB,mBAAmB,EACnB,KAAK,sBAAsB,EAC3B,KAAK,sBAAsB,EAC3B,KAAK,uBAAuB,EAC5B,KAAK,mBAAmB,EACxB,4BAA4B,EAC5B,4BAA4B,EAC5B,6BAA6B,EAC7B,uBAAuB,GACxB,MAAM,aAAa,CAAC"}

package/dist/index.js

@@ -0,0 +1,4 @@
+export { createDefinitionBodySchema, definitionDtoSchema, definitionListQuerySchema, definitionListResponseSchema, definitionResponseSchema, definitionSyncSummarySchema, definitionValidationErrorSchema } from '#schemas/index.js';
+export { DEFINITION_DELETED, DEFINITION_INVALID, DEFINITION_RESOLVED, definitionDeletedEventSchema, definitionInvalidEventSchema, definitionResolvedEventSchema, definitionsEventSchemas } from './events.js';
+
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["export {\n  type CreateDefinitionBodyDto,\n  createDefinitionBodySchema,\n  type DefinitionDto,\n  type DefinitionListQueryDto,\n  type DefinitionListResponseDto,\n  type DefinitionResponseDto,\n  type DefinitionSyncSummaryDto,\n  type DefinitionValidationErrorDto,\n  definitionDtoSchema,\n  definitionListQuerySchema,\n  definitionListResponseSchema,\n  definitionResponseSchema,\n  definitionSyncSummarySchema,\n  definitionValidationErrorSchema,\n  type TriggerDto,\n} from '#schemas/index.js';\nexport {\n  DEFINITION_DELETED,\n  DEFINITION_INVALID,\n  DEFINITION_RESOLVED,\n  type DefinitionDeletedEvent,\n  type DefinitionInvalidEvent,\n  type DefinitionResolvedEvent,\n  type DefinitionsEventMap,\n  definitionDeletedEventSchema,\n  definitionInvalidEventSchema,\n  definitionResolvedEventSchema,\n  definitionsEventSchemas,\n} from './events.js';\n"],"names":["createDefinitionBodySchema","definitionDtoSchema","definitionListQuerySchema","definitionListResponseSchema","definitionResponseSchema","definitionSyncSummarySchema","definitionValidationErrorSchema","DEFINITION_DELETED","DEFINITION_INVALID","DEFINITION_RESOLVED","definitionDeletedEventSchema","definitionInvalidEventSchema","definitionResolvedEventSchema","definitionsEventSchemas"],"mappings":"AAAA,SAEEA,0BAA0B,EAO1BC,mBAAmB,EACnBC,yBAAyB,EACzBC,4BAA4B,EAC5BC,wBAAwB,EACxBC,2BAA2B,EAC3BC,+BAA+B,QAE1B,oBAAoB;AAC3B,SACEC,kBAAkB,EAClBC,kBAAkB,EAClBC,mBAAmB,EAKnBC,4BAA4B,EAC5BC,4BAA4B,EAC5BC,6BAA6B,EAC7BC,uBAAuB,QAClB,cAAc"}

package/dist/schemas/dto.d.ts

@@ -0,0 +1,148 @@
+import { z } from 'zod';
+export declare const createDefinitionBodySchema: z.ZodObject<{
+    project_id: z.ZodString;
+    config_path: z.ZodOptional<z.ZodString>;
+    source: z.ZodOptional<z.ZodEnum<{
+        manual: "manual";
+        vcs: "vcs";
+    }>>;
+    yaml: z.ZodString;
+    sha: z.ZodOptional<z.ZodString>;
+    ref: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type CreateDefinitionBodyDto = z.infer<typeof createDefinitionBodySchema>;
+export declare const definitionDtoSchema: z.ZodObject<{
+    id: z.ZodString;
+    project_id: z.ZodString;
+    config_path: z.ZodNullable<z.ZodString>;
+    source: z.ZodEnum<{
+        manual: "manual";
+        vcs: "vcs";
+    }>;
+    sha: z.ZodNullable<z.ZodString>;
+    ref: z.ZodNullable<z.ZodString>;
+    name: z.ZodString;
+    workflow_document: z.ZodUnknown;
+    workflow_model: z.ZodUnknown;
+    manual_trigger: z.ZodNullable<z.ZodObject<{
+        name: z.ZodString;
+    }, z.core.$strip>>;
+    fetched_at: z.ZodString;
+    created_at: z.ZodString;
+    updated_at: z.ZodString;
+}, z.core.$strip>;
+export type DefinitionDto = z.infer<typeof definitionDtoSchema>;
+export declare const definitionResponseSchema: z.ZodObject<{
+    id: z.ZodString;
+    project_id: z.ZodString;
+    config_path: z.ZodNullable<z.ZodString>;
+    source: z.ZodEnum<{
+        manual: "manual";
+        vcs: "vcs";
+    }>;
+    sha: z.ZodNullable<z.ZodString>;
+    ref: z.ZodNullable<z.ZodString>;
+    name: z.ZodString;
+    workflow_document: z.ZodUnknown;
+    workflow_model: z.ZodUnknown;
+    manual_trigger: z.ZodNullable<z.ZodObject<{
+        name: z.ZodString;
+    }, z.core.$strip>>;
+    fetched_at: z.ZodString;
+    created_at: z.ZodString;
+    updated_at: z.ZodString;
+}, z.core.$strip>;
+export type DefinitionResponseDto = z.infer<typeof definitionResponseSchema>;
+export declare const definitionValidationErrorSchema: z.ZodObject<{
+    message: z.ZodString;
+    path: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type DefinitionValidationErrorDto = z.infer<typeof definitionValidationErrorSchema>;
+export declare const definitionListQuerySchema: z.ZodObject<{
+    project_id: z.ZodString;
+    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    cursor: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type DefinitionListQueryDto = z.infer<typeof definitionListQuerySchema>;
+export declare const definitionSyncSummarySchema: z.ZodObject<{
+    ref: z.ZodNullable<z.ZodString>;
+    status: z.ZodEnum<{
+        pending: "pending";
+        syncing: "syncing";
+        succeeded: "succeeded";
+        failed: "failed";
+    }>;
+    last_sync_at: z.ZodString;
+    started_at: z.ZodNullable<z.ZodString>;
+    finished_at: z.ZodNullable<z.ZodString>;
+    last_error_code: z.ZodNullable<z.ZodEnum<{
+        unknown: "unknown";
+        "no-workflow-files": "no-workflow-files";
+        "invalid-definition": "invalid-definition";
+        "provider-repository-not-found": "provider-repository-not-found";
+        "provider-file-not-found": "provider-file-not-found";
+        "provider-access-denied": "provider-access-denied";
+        "provider-rate-limited": "provider-rate-limited";
+        "provider-timeout": "provider-timeout";
+        "provider-unavailable": "provider-unavailable";
+        "provider-malformed-response": "provider-malformed-response";
+        "content-too-large": "content-too-large";
+        "too-many-files": "too-many-files";
+        "connection-unavailable": "connection-unavailable";
+    }>>;
+    last_error_message: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type DefinitionSyncSummaryDto = z.infer<typeof definitionSyncSummarySchema>;
+export declare const definitionListResponseSchema: z.ZodObject<{
+    definitions: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        project_id: z.ZodString;
+        config_path: z.ZodNullable<z.ZodString>;
+        source: z.ZodEnum<{
+            manual: "manual";
+            vcs: "vcs";
+        }>;
+        sha: z.ZodNullable<z.ZodString>;
+        ref: z.ZodNullable<z.ZodString>;
+        name: z.ZodString;
+        workflow_document: z.ZodUnknown;
+        workflow_model: z.ZodUnknown;
+        manual_trigger: z.ZodNullable<z.ZodObject<{
+            name: z.ZodString;
+        }, z.core.$strip>>;
+        fetched_at: z.ZodString;
+        created_at: z.ZodString;
+        updated_at: z.ZodString;
+    }, z.core.$strip>>;
+    sync: z.ZodNullable<z.ZodObject<{
+        ref: z.ZodNullable<z.ZodString>;
+        status: z.ZodEnum<{
+            pending: "pending";
+            syncing: "syncing";
+            succeeded: "succeeded";
+            failed: "failed";
+        }>;
+        last_sync_at: z.ZodString;
+        started_at: z.ZodNullable<z.ZodString>;
+        finished_at: z.ZodNullable<z.ZodString>;
+        last_error_code: z.ZodNullable<z.ZodEnum<{
+            unknown: "unknown";
+            "no-workflow-files": "no-workflow-files";
+            "invalid-definition": "invalid-definition";
+            "provider-repository-not-found": "provider-repository-not-found";
+            "provider-file-not-found": "provider-file-not-found";
+            "provider-access-denied": "provider-access-denied";
+            "provider-rate-limited": "provider-rate-limited";
+            "provider-timeout": "provider-timeout";
+            "provider-unavailable": "provider-unavailable";
+            "provider-malformed-response": "provider-malformed-response";
+            "content-too-large": "content-too-large";
+            "too-many-files": "too-many-files";
+            "connection-unavailable": "connection-unavailable";
+        }>>;
+        last_error_message: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+    next_cursor: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type DefinitionListResponseDto = z.infer<typeof definitionListResponseSchema>;
+//# sourceMappingURL=dto.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"dto.d.ts","sourceRoot":"","sources":["../../src/schemas/dto.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,CAAC,EAAC,MAAM,KAAK,CAAC;AAEtB,eAAO,MAAM,0BAA0B;;;;;;;;;;iBAiCnC,CAAC;AAEL,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAEjF,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;iBAkB9B,CAAC;AAEH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEhE,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;iBAAsB,CAAC;AAE5D,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAE7E,eAAO,MAAM,+BAA+B;;;iBAG1C,CAAC;AAEH,MAAM,MAAM,4BAA4B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,+BAA+B,CAAC,CAAC;AAE3F,eAAO,MAAM,yBAAyB;;;;iBAIpC,CAAC;AAEH,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAE/E,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAwBtC,CAAC;AAEH,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAEnF,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAIvC,CAAC;AAEH,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAC"}

package/dist/schemas/dto.js

@@ -0,0 +1,109 @@
+import { z } from 'zod';
+export const createDefinitionBodySchema = z.object({
+    project_id: z.string().uuid(),
+    config_path: z.string().min(1).optional(),
+    source: z.enum([
+        'manual',
+        'vcs'
+    ]).optional(),
+    yaml: z.string().min(1).max(1_000_000),
+    sha: z.string().optional(),
+    ref: z.string().optional()
+}).superRefine((value, ctx)=>{
+    const source = value.source ?? 'manual';
+    if (source === 'vcs' && !value.config_path) {
+        ctx.addIssue({
+            code: 'custom',
+            message: 'config_path is required for VCS definitions',
+            path: [
+                'config_path'
+            ]
+        });
+    }
+    const hasRefOrSha = value.ref != null || value.sha != null;
+    if (source === 'vcs' && !hasRefOrSha) {
+        ctx.addIssue({
+            code: 'custom',
+            message: 'VCS definitions require a ref or sha',
+            path: [
+                'ref'
+            ]
+        });
+    }
+    if (source === 'manual' && hasRefOrSha) {
+        ctx.addIssue({
+            code: 'custom',
+            message: 'manual definitions must not set ref or sha',
+            path: value.ref != null ? [
+                'ref'
+            ] : [
+                'sha'
+            ]
+        });
+    }
+});
+export const definitionDtoSchema = z.object({
+    id: z.string().uuid(),
+    project_id: z.string().uuid(),
+    config_path: z.string().nullable(),
+    source: z.enum([
+        'manual',
+        'vcs'
+    ]),
+    sha: z.string().nullable(),
+    ref: z.string().nullable(),
+    name: z.string(),
+    workflow_document: z.unknown(),
+    workflow_model: z.unknown(),
+    manual_trigger: z.object({
+        name: z.string()
+    }).nullable(),
+    fetched_at: z.string(),
+    created_at: z.string(),
+    updated_at: z.string()
+});
+export const definitionResponseSchema = definitionDtoSchema;
+export const definitionValidationErrorSchema = z.object({
+    message: z.string(),
+    path: z.string().optional()
+});
+export const definitionListQuerySchema = z.object({
+    project_id: z.string().uuid(),
+    limit: z.coerce.number().int().min(1).max(100).default(50),
+    cursor: z.string().optional()
+});
+export const definitionSyncSummarySchema = z.object({
+    ref: z.string().nullable(),
+    status: z.enum([
+        'pending',
+        'syncing',
+        'succeeded',
+        'failed'
+    ]),
+    last_sync_at: z.string(),
+    started_at: z.string().nullable(),
+    finished_at: z.string().nullable(),
+    last_error_code: z.enum([
+        'no-workflow-files',
+        'invalid-definition',
+        'provider-repository-not-found',
+        'provider-file-not-found',
+        'provider-access-denied',
+        'provider-rate-limited',
+        'provider-timeout',
+        'provider-unavailable',
+        'provider-malformed-response',
+        'content-too-large',
+        'too-many-files',
+        'connection-unavailable',
+        'unknown'
+    ]).nullable(),
+    last_error_message: z.string().nullable()
+});
+export const definitionListResponseSchema = z.object({
+    definitions: z.array(definitionResponseSchema),
+    sync: definitionSyncSummarySchema.nullable(),
+    next_cursor: z.string().nullable()
+});
+
+//# sourceMappingURL=dto.js.map

package/dist/schemas/dto.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/schemas/dto.ts"],"sourcesContent":["import {z} from 'zod';\n\nexport const createDefinitionBodySchema = z\n  .object({\n    project_id: z.string().uuid(),\n    config_path: z.string().min(1).optional(),\n    source: z.enum(['manual', 'vcs']).optional(),\n    yaml: z.string().min(1).max(1_000_000),\n    sha: z.string().optional(),\n    ref: z.string().optional(),\n  })\n  .superRefine((value, ctx) => {\n    const source = value.source ?? 'manual';\n    if (source === 'vcs' && !value.config_path) {\n      ctx.addIssue({\n        code: 'custom',\n        message: 'config_path is required for VCS definitions',\n        path: ['config_path'],\n      });\n    }\n    const hasRefOrSha = value.ref != null || value.sha != null;\n    if (source === 'vcs' && !hasRefOrSha) {\n      ctx.addIssue({\n        code: 'custom',\n        message: 'VCS definitions require a ref or sha',\n        path: ['ref'],\n      });\n    }\n    if (source === 'manual' && hasRefOrSha) {\n      ctx.addIssue({\n        code: 'custom',\n        message: 'manual definitions must not set ref or sha',\n        path: value.ref != null ? ['ref'] : ['sha'],\n      });\n    }\n  });\n\nexport type CreateDefinitionBodyDto = z.infer<typeof createDefinitionBodySchema>;\n\nexport const definitionDtoSchema = z.object({\n  id: z.string().uuid(),\n  project_id: z.string().uuid(),\n  config_path: z.string().nullable(),\n  source: z.enum(['manual', 'vcs']),\n  sha: z.string().nullable(),\n  ref: z.string().nullable(),\n  name: z.string(),\n  workflow_document: z.unknown(),\n  workflow_model: z.unknown(),\n  manual_trigger: z\n    .object({\n      name: z.string(),\n    })\n    .nullable(),\n  fetched_at: z.string(),\n  created_at: z.string(),\n  updated_at: z.string(),\n});\n\nexport type DefinitionDto = z.infer<typeof definitionDtoSchema>;\n\nexport const definitionResponseSchema = definitionDtoSchema;\n\nexport type DefinitionResponseDto = z.infer<typeof definitionResponseSchema>;\n\nexport const definitionValidationErrorSchema = z.object({\n  message: z.string(),\n  path: z.string().optional(),\n});\n\nexport type DefinitionValidationErrorDto = z.infer<typeof definitionValidationErrorSchema>;\n\nexport const definitionListQuerySchema = z.object({\n  project_id: z.string().uuid(),\n  limit: z.coerce.number().int().min(1).max(100).default(50),\n  cursor: z.string().optional(),\n});\n\nexport type DefinitionListQueryDto = z.infer<typeof definitionListQuerySchema>;\n\nexport const definitionSyncSummarySchema = z.object({\n  ref: z.string().nullable(),\n  status: z.enum(['pending', 'syncing', 'succeeded', 'failed']),\n  last_sync_at: z.string(),\n  started_at: z.string().nullable(),\n  finished_at: z.string().nullable(),\n  last_error_code: z\n    .enum([\n      'no-workflow-files',\n      'invalid-definition',\n      'provider-repository-not-found',\n      'provider-file-not-found',\n      'provider-access-denied',\n      'provider-rate-limited',\n      'provider-timeout',\n      'provider-unavailable',\n      'provider-malformed-response',\n      'content-too-large',\n      'too-many-files',\n      'connection-unavailable',\n      'unknown',\n    ])\n    .nullable(),\n  last_error_message: z.string().nullable(),\n});\n\nexport type DefinitionSyncSummaryDto = z.infer<typeof definitionSyncSummarySchema>;\n\nexport const definitionListResponseSchema = z.object({\n  definitions: z.array(definitionResponseSchema),\n  sync: definitionSyncSummarySchema.nullable(),\n  next_cursor: z.string().nullable(),\n});\n\nexport type DefinitionListResponseDto = z.infer<typeof definitionListResponseSchema>;\n"],"names":["z","createDefinitionBodySchema","object","project_id","string","uuid","config_path","min","optional","source","enum","yaml","max","sha","ref","superRefine","value","ctx","addIssue","code","message","path","hasRefOrSha","definitionDtoSchema","id","nullable","name","workflow_document","unknown","workflow_model","manual_trigger","fetched_at","created_at","updated_at","definitionResponseSchema","definitionValidationErrorSchema","definitionListQuerySchema","limit","coerce","number","int","default","cursor","definitionSyncSummarySchema","status","last_sync_at","started_at","finished_at","last_error_code","last_error_message","definitionListResponseSchema","definitions","array","sync","next_cursor"],"mappings":"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"}

package/dist/schemas/index.d.ts

@@ -0,0 +1,3 @@
+export { type CreateDefinitionBodyDto, createDefinitionBodySchema, type DefinitionDto, type DefinitionListQueryDto, type DefinitionListResponseDto, type DefinitionResponseDto, type DefinitionSyncSummaryDto, type DefinitionValidationErrorDto, definitionDtoSchema, definitionListQuerySchema, definitionListResponseSchema, definitionResponseSchema, definitionSyncSummarySchema, definitionValidationErrorSchema, } from './dto.js';
+export type { TriggerDto } from './trigger.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,uBAAuB,EAC5B,0BAA0B,EAC1B,KAAK,aAAa,EAClB,KAAK,sBAAsB,EAC3B,KAAK,yBAAyB,EAC9B,KAAK,qBAAqB,EAC1B,KAAK,wBAAwB,EAC7B,KAAK,4BAA4B,EACjC,mBAAmB,EACnB,yBAAyB,EACzB,4BAA4B,EAC5B,wBAAwB,EACxB,2BAA2B,EAC3B,+BAA+B,GAChC,MAAM,UAAU,CAAC;AAClB,YAAY,EAAC,UAAU,EAAC,MAAM,cAAc,CAAC"}

package/dist/schemas/index.js

@@ -0,0 +1,3 @@
+export { createDefinitionBodySchema, definitionDtoSchema, definitionListQuerySchema, definitionListResponseSchema, definitionResponseSchema, definitionSyncSummarySchema, definitionValidationErrorSchema } from './dto.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 CreateDefinitionBodyDto,\n  createDefinitionBodySchema,\n  type DefinitionDto,\n  type DefinitionListQueryDto,\n  type DefinitionListResponseDto,\n  type DefinitionResponseDto,\n  type DefinitionSyncSummaryDto,\n  type DefinitionValidationErrorDto,\n  definitionDtoSchema,\n  definitionListQuerySchema,\n  definitionListResponseSchema,\n  definitionResponseSchema,\n  definitionSyncSummarySchema,\n  definitionValidationErrorSchema,\n} from './dto.js';\nexport type {TriggerDto} from './trigger.js';\n"],"names":["createDefinitionBodySchema","definitionDtoSchema","definitionListQuerySchema","definitionListResponseSchema","definitionResponseSchema","definitionSyncSummarySchema","definitionValidationErrorSchema"],"mappings":"AAAA,SAEEA,0BAA0B,EAO1BC,mBAAmB,EACnBC,yBAAyB,EACzBC,4BAA4B,EAC5BC,wBAAwB,EACxBC,2BAA2B,EAC3BC,+BAA+B,QAC1B,WAAW"}

package/dist/schemas/trigger.d.ts

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+export declare const triggerDtoSchema: z.ZodObject<{
+    source: z.ZodString;
+    event: z.ZodString;
+    with: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    filter: z.ZodOptional<z.ZodString>;
+    config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+export type TriggerDto = z.infer<typeof triggerDtoSchema>;
+//# sourceMappingURL=trigger.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"trigger.d.ts","sourceRoot":"","sources":["../../src/schemas/trigger.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,CAAC,EAAC,MAAM,KAAK,CAAC;AAEtB,eAAO,MAAM,gBAAgB;;;;;;iBAM3B,CAAC;AACH,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC"}

package/dist/schemas/trigger.js

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+export const triggerDtoSchema = z.object({
+    source: z.string(),
+    event: z.string(),
+    with: z.record(z.string(), z.unknown()).optional(),
+    filter: z.string().optional(),
+    config: z.record(z.string(), z.unknown()).optional()
+});
+
+//# sourceMappingURL=trigger.js.map

package/dist/schemas/trigger.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/schemas/trigger.ts"],"sourcesContent":["import {z} from 'zod';\n\nexport const triggerDtoSchema = z.object({\n  source: z.string(),\n  event: z.string(),\n  with: z.record(z.string(), z.unknown()).optional(),\n  filter: z.string().optional(),\n  config: z.record(z.string(), z.unknown()).optional(),\n});\nexport type TriggerDto = z.infer<typeof triggerDtoSchema>;\n"],"names":["z","triggerDtoSchema","object","source","string","event","with","record","unknown","optional","filter","config"],"mappings":"AAAA,SAAQA,CAAC,QAAO,MAAM;AAEtB,OAAO,MAAMC,mBAAmBD,EAAEE,MAAM,CAAC;IACvCC,QAAQH,EAAEI,MAAM;IAChBC,OAAOL,EAAEI,MAAM;IACfE,MAAMN,EAAEO,MAAM,CAACP,EAAEI,MAAM,IAAIJ,EAAEQ,OAAO,IAAIC,QAAQ;IAChDC,QAAQV,EAAEI,MAAM,GAAGK,QAAQ;IAC3BE,QAAQX,EAAEO,MAAM,CAACP,EAAEI,MAAM,IAAIJ,EAAEQ,OAAO,IAAIC,QAAQ;AACpD,GAAG"}