@hexabot-ai/types 3.0.7-beta.0 → 3.1.0-beta.0

package/dist/cjs/workflow/domain.js

@@ -5,7 +5,7 @@
  * Full terms: see LICENSE.md.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.directionTypeSchema = exports.mcpServerTransportSchema = exports.memoryScopeSchema = exports.workflowVersionActionSchema = exports.workflowTypeSchema = exports.DirectionType = exports.McpServerTransport = exports.MemoryScope = exports.WorkflowVersionAction = exports.WorkflowType = void 0;
+exports.webhookJwtAlgorithmSchema = exports.webhookAuthTypeSchema = exports.directionTypeSchema = exports.mcpServerTransportSchema = exports.memoryScopeSchema = exports.workflowVersionActionSchema = exports.workflowTypeSchema = exports.WebhookJwtAlgorithm = exports.WebhookAuthType = exports.DirectionType = exports.McpServerTransport = exports.MemoryScope = exports.WorkflowVersionAction = exports.WorkflowType = void 0;
 const zod_1 = require("zod");
 var WorkflowType;
 (function (WorkflowType) {
@@ -37,8 +37,23 @@ var DirectionType;
     DirectionType["HORIZONTAL"] = "horizontal";
     DirectionType["VERTICAL"] = "vertical";
 })(DirectionType || (exports.DirectionType = DirectionType = {}));
+var WebhookAuthType;
+(function (WebhookAuthType) {
+    WebhookAuthType["none"] = "none";
+    WebhookAuthType["basic"] = "basic";
+    WebhookAuthType["header"] = "header";
+    WebhookAuthType["jwt"] = "jwt";
+})(WebhookAuthType || (exports.WebhookAuthType = WebhookAuthType = {}));
+var WebhookJwtAlgorithm;
+(function (WebhookJwtAlgorithm) {
+    WebhookJwtAlgorithm["HS256"] = "HS256";
+    WebhookJwtAlgorithm["HS384"] = "HS384";
+    WebhookJwtAlgorithm["HS512"] = "HS512";
+})(WebhookJwtAlgorithm || (exports.WebhookJwtAlgorithm = WebhookJwtAlgorithm = {}));
 exports.workflowTypeSchema = zod_1.z.enum(WorkflowType);
 exports.workflowVersionActionSchema = zod_1.z.enum(WorkflowVersionAction);
 exports.memoryScopeSchema = zod_1.z.enum(MemoryScope);
 exports.mcpServerTransportSchema = zod_1.z.enum(McpServerTransport);
 exports.directionTypeSchema = zod_1.z.enum(DirectionType);
+exports.webhookAuthTypeSchema = zod_1.z.enum(WebhookAuthType);
+exports.webhookJwtAlgorithmSchema = zod_1.z.enum(WebhookJwtAlgorithm);

package/dist/cjs/workflow/index.js

@@ -5,15 +5,20 @@
  * Full terms: see LICENSE.md.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.workflowTransferResourceKindSchema = exports.workflowImportResultSchema = exports.workflowImportResourceResultSchema = exports.workflowImportResourceActionSchema = exports.workflowExportBundleWorkflowDependencySchema = exports.workflowExportBundleV1Schema = exports.workflowExportBundleSchema = exports.workflowExportBundleMemoryDefinitionSchema = exports.workflowExportBundleMcpServerSchema = exports.workflowExportBundleLabelSchema = exports.workflowExportBundleLabelGroupSchema = exports.workflowExportBundleCredentialSchema = exports.workflowExportBundleContentTypeSchema = exports.WORKFLOW_TRANSFER_RESOURCE_KIND_PATTERN = exports.WORKFLOW_EXPORT_BUNDLE_KIND = exports.mcpServerStubSchema = exports.mcpServerSchema = exports.mcpServerFullSchema = exports.memoryRecordStubSchema = exports.memoryRecordSchema = exports.memoryRecordFullSchema = exports.memoryDefinitionStubSchema = exports.memoryDefinitionSchema = exports.memoryDefinitionFullSchema = exports.workflowRunStubSchema = exports.workflowRunSchema = exports.workflowRunFullSchema = exports.resolveRunDurationMs = exports.workflowVersionStubSchema = exports.workflowVersionSchema = exports.workflowVersionFullSchema = exports.workflowStubSchema = exports.workflowSchema = exports.workflowFullSchema = exports.createWorkflowFullSchema = exports.WorkflowVersionAction = exports.WorkflowType = exports.MemoryScope = exports.McpServerTransport = exports.DirectionType = void 0;
+exports.workflowTransferResourceKindSchema = exports.workflowImportResultSchema = exports.workflowImportResourceResultSchema = exports.workflowImportResourceActionSchema = exports.workflowExportBundleWorkflowDependencySchema = exports.workflowExportBundleV1Schema = exports.workflowExportBundleSchema = exports.workflowExportBundleMemoryDefinitionSchema = exports.workflowExportBundleMcpServerSchema = exports.workflowExportBundleLabelSchema = exports.workflowExportBundleLabelGroupSchema = exports.workflowExportBundleCredentialSchema = exports.workflowExportBundleContentTypeSchema = exports.WORKFLOW_TRANSFER_RESOURCE_KIND_PATTERN = exports.WORKFLOW_EXPORT_BUNDLE_KIND = exports.mcpServerStubSchema = exports.mcpServerSchema = exports.mcpServerFullSchema = exports.memoryRecordStubSchema = exports.memoryRecordSchema = exports.memoryRecordFullSchema = exports.memoryDefinitionStubSchema = exports.memoryDefinitionSchema = exports.memoryDefinitionFullSchema = exports.workflowRunStubSchema = exports.workflowRunSchema = exports.workflowRunFullSchema = exports.resolveRunDurationMs = exports.workflowVersionStubSchema = exports.workflowVersionSchema = exports.workflowVersionFullSchema = exports.workflowStubSchema = exports.workflowSchema = exports.workflowFullSchema = exports.webhookTriggerSchema = exports.createWorkflowFullSchema = exports.WorkflowVersionAction = exports.WorkflowType = exports.webhookJwtAlgorithmSchema = exports.webhookAuthTypeSchema = exports.WebhookJwtAlgorithm = exports.WebhookAuthType = exports.MemoryScope = exports.McpServerTransport = exports.DirectionType = void 0;
 var domain_1 = require("./domain");
 Object.defineProperty(exports, "DirectionType", { enumerable: true, get: function () { return domain_1.DirectionType; } });
 Object.defineProperty(exports, "McpServerTransport", { enumerable: true, get: function () { return domain_1.McpServerTransport; } });
 Object.defineProperty(exports, "MemoryScope", { enumerable: true, get: function () { return domain_1.MemoryScope; } });
+Object.defineProperty(exports, "WebhookAuthType", { enumerable: true, get: function () { return domain_1.WebhookAuthType; } });
+Object.defineProperty(exports, "WebhookJwtAlgorithm", { enumerable: true, get: function () { return domain_1.WebhookJwtAlgorithm; } });
+Object.defineProperty(exports, "webhookAuthTypeSchema", { enumerable: true, get: function () { return domain_1.webhookAuthTypeSchema; } });
+Object.defineProperty(exports, "webhookJwtAlgorithmSchema", { enumerable: true, get: function () { return domain_1.webhookJwtAlgorithmSchema; } });
 Object.defineProperty(exports, "WorkflowType", { enumerable: true, get: function () { return domain_1.WorkflowType; } });
 Object.defineProperty(exports, "WorkflowVersionAction", { enumerable: true, get: function () { return domain_1.WorkflowVersionAction; } });
 var workflow_1 = require("./workflow");
 Object.defineProperty(exports, "createWorkflowFullSchema", { enumerable: true, get: function () { return workflow_1.createWorkflowFullSchema; } });
+Object.defineProperty(exports, "webhookTriggerSchema", { enumerable: true, get: function () { return workflow_1.webhookTriggerSchema; } });
 Object.defineProperty(exports, "workflowFullSchema", { enumerable: true, get: function () { return workflow_1.workflowFullSchema; } });
 Object.defineProperty(exports, "workflowSchema", { enumerable: true, get: function () { return workflow_1.workflowSchema; } });
 Object.defineProperty(exports, "workflowStubSchema", { enumerable: true, get: function () { return workflow_1.workflowStubSchema; } });

package/dist/cjs/workflow/workflow.js

@@ -5,7 +5,7 @@
  * Full terms: see LICENSE.md.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.workflowFullSchema = exports.createWorkflowFullSchema = exports.workflowSchema = exports.workflowStubSchema = void 0;
+exports.workflowFullSchema = exports.createWorkflowFullSchema = exports.workflowSchema = exports.workflowStubSchema = exports.webhookTriggerSchema = void 0;
 const zod_1 = require("zod");
 const aliases_1 = require("../shared/aliases");
 const base_1 = require("../shared/base");
@@ -15,6 +15,77 @@ const user_1 = require("../user/user");
 const domain_1 = require("./domain");
 const helpers_1 = require("./helpers");
 const workflow_version_1 = require("./workflow-version");
+const nullableString = (0, preprocess_1.preprocess)(helpers_1.nullishToNull, zod_1.z.string().nullable().optional());
+const webhookTriggerBaseShape = {
+    enabled: zod_1.z.coerce.boolean().default(false),
+};
+// Secrets are never stored inline on the workflow: each secret lives in the
+// credentials store and the trigger config only carries its credential id.
+exports.webhookTriggerSchema = (0, preprocess_1.preprocess)((value) => {
+    // Default the discriminator so a config without an explicit authType still
+    // validates as an unauthenticated webhook (matches the previous behaviour).
+    const record = (0, object_1.toRecord)(value);
+    if (record && record.authType == null) {
+        return { ...record, authType: domain_1.WebhookAuthType.none };
+    }
+    return value;
+}, zod_1.z
+    .discriminatedUnion("authType", [
+    zod_1.z.object({
+        ...webhookTriggerBaseShape,
+        authType: zod_1.z.literal(domain_1.WebhookAuthType.none),
+    }),
+    zod_1.z.object({
+        ...webhookTriggerBaseShape,
+        authType: zod_1.z.literal(domain_1.WebhookAuthType.basic),
+        username: nullableString,
+        passwordCredentialId: nullableString,
+    }),
+    zod_1.z.object({
+        ...webhookTriggerBaseShape,
+        authType: zod_1.z.literal(domain_1.WebhookAuthType.header),
+        headerName: nullableString,
+        headerValueCredentialId: nullableString,
+    }),
+    zod_1.z.object({
+        ...webhookTriggerBaseShape,
+        authType: zod_1.z.literal(domain_1.WebhookAuthType.jwt),
+        jwtSecretCredentialId: nullableString,
+        jwtAlgorithm: (0, preprocess_1.preprocess)(helpers_1.nullishToNull, domain_1.webhookJwtAlgorithmSchema.nullable().optional()),
+    }),
+])
+    // An enabled webhook with an unset credential reference would otherwise
+    // authenticate empty credentials, so references are mandatory once
+    // enabled.
+    .superRefine((config, ctx) => {
+    if (!config.enabled) {
+        return;
+    }
+    const requireCredential = (field, value) => {
+        if (!value) {
+            ctx.addIssue({
+                code: "custom",
+                path: [field],
+                message: `${field} is required when the webhook trigger is enabled`,
+            });
+        }
+    };
+    switch (config.authType) {
+        case domain_1.WebhookAuthType.basic:
+            requireCredential("username", config.username);
+            requireCredential("passwordCredentialId", config.passwordCredentialId);
+            break;
+        case domain_1.WebhookAuthType.header:
+            requireCredential("headerName", config.headerName);
+            requireCredential("headerValueCredentialId", config.headerValueCredentialId);
+            break;
+        case domain_1.WebhookAuthType.jwt:
+            requireCredential("jwtSecretCredentialId", config.jwtSecretCredentialId);
+            break;
+        default:
+            break;
+    }
+}));
 const workflowAliasMap = {
     currentVersionId: "currentVersion",
     publishedVersionId: "publishedVersion",
@@ -31,6 +102,7 @@ const workflowStubObjectSchema = base_1.baseStubSchema.extend({
     y: zod_1.z.coerce.number(),
     zoom: zod_1.z.coerce.number(),
     direction: domain_1.directionTypeSchema,
+    webhookTrigger: (0, preprocess_1.preprocess)(helpers_1.nullishToNull, exports.webhookTriggerSchema.nullable()).optional(),
 });
 const withWorkflowAliases = (value) => {
     const original = (0, object_1.toRecord)(value);

package/dist/esm/workflow/domain.js

@@ -34,8 +34,23 @@ export var DirectionType;
     DirectionType["HORIZONTAL"] = "horizontal";
     DirectionType["VERTICAL"] = "vertical";
 })(DirectionType || (DirectionType = {}));
+export var WebhookAuthType;
+(function (WebhookAuthType) {
+    WebhookAuthType["none"] = "none";
+    WebhookAuthType["basic"] = "basic";
+    WebhookAuthType["header"] = "header";
+    WebhookAuthType["jwt"] = "jwt";
+})(WebhookAuthType || (WebhookAuthType = {}));
+export var WebhookJwtAlgorithm;
+(function (WebhookJwtAlgorithm) {
+    WebhookJwtAlgorithm["HS256"] = "HS256";
+    WebhookJwtAlgorithm["HS384"] = "HS384";
+    WebhookJwtAlgorithm["HS512"] = "HS512";
+})(WebhookJwtAlgorithm || (WebhookJwtAlgorithm = {}));
 export const workflowTypeSchema = z.enum(WorkflowType);
 export const workflowVersionActionSchema = z.enum(WorkflowVersionAction);
 export const memoryScopeSchema = z.enum(MemoryScope);
 export const mcpServerTransportSchema = z.enum(McpServerTransport);
 export const directionTypeSchema = z.enum(DirectionType);
+export const webhookAuthTypeSchema = z.enum(WebhookAuthType);
+export const webhookJwtAlgorithmSchema = z.enum(WebhookJwtAlgorithm);

package/dist/esm/workflow/index.js

@@ -3,8 +3,8 @@
  * Copyright (c) 2026 Hexastack.
  * Full terms: see LICENSE.md.
  */
-export { DirectionType, McpServerTransport, MemoryScope, WorkflowType, WorkflowVersionAction, } from "./domain";
-export { createWorkflowFullSchema, workflowFullSchema, workflowSchema, workflowStubSchema, } from "./workflow";
+export { DirectionType, McpServerTransport, MemoryScope, WebhookAuthType, WebhookJwtAlgorithm, webhookAuthTypeSchema, webhookJwtAlgorithmSchema, WorkflowType, WorkflowVersionAction, } from "./domain";
+export { createWorkflowFullSchema, webhookTriggerSchema, workflowFullSchema, workflowSchema, workflowStubSchema, } from "./workflow";
 export { workflowVersionFullSchema, workflowVersionSchema, workflowVersionStubSchema, } from "./workflow-version";
 export { resolveRunDurationMs, workflowRunFullSchema, workflowRunSchema, workflowRunStubSchema, } from "./workflow-run";
 export { memoryDefinitionFullSchema, memoryDefinitionSchema, memoryDefinitionStubSchema, } from "./memory-definition";

package/dist/esm/workflow/workflow.js

@@ -9,9 +9,80 @@ import { baseStubSchema } from "../shared/base";
 import { cloneWithPrototype, toRecord } from "../shared/object";
 import { preprocess } from "../shared/preprocess";
 import { userSchema } from "../user/user";
-import { directionTypeSchema, workflowTypeSchema } from "./domain";
+import { directionTypeSchema, WebhookAuthType, webhookJwtAlgorithmSchema, workflowTypeSchema, } from "./domain";
 import { nullishToNull } from "./helpers";
 import { workflowVersionSchema } from "./workflow-version";
+const nullableString = preprocess(nullishToNull, z.string().nullable().optional());
+const webhookTriggerBaseShape = {
+    enabled: z.coerce.boolean().default(false),
+};
+// Secrets are never stored inline on the workflow: each secret lives in the
+// credentials store and the trigger config only carries its credential id.
+export const webhookTriggerSchema = preprocess((value) => {
+    // Default the discriminator so a config without an explicit authType still
+    // validates as an unauthenticated webhook (matches the previous behaviour).
+    const record = toRecord(value);
+    if (record && record.authType == null) {
+        return { ...record, authType: WebhookAuthType.none };
+    }
+    return value;
+}, z
+    .discriminatedUnion("authType", [
+    z.object({
+        ...webhookTriggerBaseShape,
+        authType: z.literal(WebhookAuthType.none),
+    }),
+    z.object({
+        ...webhookTriggerBaseShape,
+        authType: z.literal(WebhookAuthType.basic),
+        username: nullableString,
+        passwordCredentialId: nullableString,
+    }),
+    z.object({
+        ...webhookTriggerBaseShape,
+        authType: z.literal(WebhookAuthType.header),
+        headerName: nullableString,
+        headerValueCredentialId: nullableString,
+    }),
+    z.object({
+        ...webhookTriggerBaseShape,
+        authType: z.literal(WebhookAuthType.jwt),
+        jwtSecretCredentialId: nullableString,
+        jwtAlgorithm: preprocess(nullishToNull, webhookJwtAlgorithmSchema.nullable().optional()),
+    }),
+])
+    // An enabled webhook with an unset credential reference would otherwise
+    // authenticate empty credentials, so references are mandatory once
+    // enabled.
+    .superRefine((config, ctx) => {
+    if (!config.enabled) {
+        return;
+    }
+    const requireCredential = (field, value) => {
+        if (!value) {
+            ctx.addIssue({
+                code: "custom",
+                path: [field],
+                message: `${field} is required when the webhook trigger is enabled`,
+            });
+        }
+    };
+    switch (config.authType) {
+        case WebhookAuthType.basic:
+            requireCredential("username", config.username);
+            requireCredential("passwordCredentialId", config.passwordCredentialId);
+            break;
+        case WebhookAuthType.header:
+            requireCredential("headerName", config.headerName);
+            requireCredential("headerValueCredentialId", config.headerValueCredentialId);
+            break;
+        case WebhookAuthType.jwt:
+            requireCredential("jwtSecretCredentialId", config.jwtSecretCredentialId);
+            break;
+        default:
+            break;
+    }
+}));
 const workflowAliasMap = {
     currentVersionId: "currentVersion",
     publishedVersionId: "publishedVersion",
@@ -28,6 +99,7 @@ const workflowStubObjectSchema = baseStubSchema.extend({
     y: z.coerce.number(),
     zoom: z.coerce.number(),
     direction: directionTypeSchema,
+    webhookTrigger: preprocess(nullishToNull, webhookTriggerSchema.nullable()).optional(),
 });
 const withWorkflowAliases = (value) => {
     const original = toRecord(value);

package/dist/types/channel/source-full.d.ts

@@ -23,6 +23,25 @@ export declare const sourceFullSchema: z.ZodType<{
         direction: import("..").DirectionType;
         createdBy: string | null;
         runAfterMs: number;
+        webhookTrigger?: {
+            authType: import("..").WebhookAuthType.none;
+            enabled: boolean;
+        } | {
+            authType: import("..").WebhookAuthType.basic;
+            username: string | null | undefined;
+            passwordCredentialId: string | null | undefined;
+            enabled: boolean;
+        } | {
+            authType: import("..").WebhookAuthType.header;
+            headerName: string | null | undefined;
+            headerValueCredentialId: string | null | undefined;
+            enabled: boolean;
+        } | {
+            authType: import("..").WebhookAuthType.jwt;
+            jwtSecretCredentialId: string | null | undefined;
+            jwtAlgorithm: import("..").WebhookJwtAlgorithm | null | undefined;
+            enabled: boolean;
+        } | null | undefined;
         currentVersion?: string | null | undefined;
         publishedVersion?: string | null | undefined;
     } | null;
@@ -50,6 +69,25 @@ export declare const sourceFullSchema: z.ZodType<{
         direction: import("..").DirectionType;
         createdBy: string | null;
         runAfterMs: number;
+        webhookTrigger?: {
+            authType: import("..").WebhookAuthType.none;
+            enabled: boolean;
+        } | {
+            authType: import("..").WebhookAuthType.basic;
+            username: string | null | undefined;
+            passwordCredentialId: string | null | undefined;
+            enabled: boolean;
+        } | {
+            authType: import("..").WebhookAuthType.header;
+            headerName: string | null | undefined;
+            headerValueCredentialId: string | null | undefined;
+            enabled: boolean;
+        } | {
+            authType: import("..").WebhookAuthType.jwt;
+            jwtSecretCredentialId: string | null | undefined;
+            jwtAlgorithm: import("..").WebhookJwtAlgorithm | null | undefined;
+            enabled: boolean;
+        } | null | undefined;
         currentVersion?: string | null | undefined;
         publishedVersion?: string | null | undefined;
     } | null;

package/dist/types/channel/source-full.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"source-full.d.ts","sourceRoot":"","sources":["../../../src/channel/source-full.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAQxB,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAQ5B,CAAC;AAEF,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC"}
+{"version":3,"file":"source-full.d.ts","sourceRoot":"","sources":["../../../src/channel/source-full.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAQxB,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAQ5B,CAAC;AAEF,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC"}

package/dist/types/workflow/domain.d.ts

@@ -24,9 +24,22 @@ export declare enum DirectionType {
     HORIZONTAL = "horizontal",
     VERTICAL = "vertical"
 }
+export declare enum WebhookAuthType {
+    none = "none",
+    basic = "basic",
+    header = "header",
+    jwt = "jwt"
+}
+export declare enum WebhookJwtAlgorithm {
+    HS256 = "HS256",
+    HS384 = "HS384",
+    HS512 = "HS512"
+}
 export declare const workflowTypeSchema: z.ZodEnum<typeof WorkflowType>;
 export declare const workflowVersionActionSchema: z.ZodEnum<typeof WorkflowVersionAction>;
 export declare const memoryScopeSchema: z.ZodEnum<typeof MemoryScope>;
 export declare const mcpServerTransportSchema: z.ZodEnum<typeof McpServerTransport>;
 export declare const directionTypeSchema: z.ZodEnum<typeof DirectionType>;
+export declare const webhookAuthTypeSchema: z.ZodEnum<typeof WebhookAuthType>;
+export declare const webhookJwtAlgorithmSchema: z.ZodEnum<typeof WebhookJwtAlgorithm>;
 //# sourceMappingURL=domain.d.ts.map

package/dist/types/workflow/domain.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"domain.d.ts","sourceRoot":"","sources":["../../../src/workflow/domain.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,oBAAY,YAAY;IACtB,cAAc,mBAAmB;IACjC,MAAM,WAAW;IACjB,SAAS,cAAc;CACxB;AAED,oBAAY,qBAAqB;IAC/B,MAAM,WAAW;IACjB,MAAM,WAAW;IACjB,OAAO,YAAY;IACnB,MAAM,WAAW;CAClB;AAED,oBAAY,WAAW;IACrB,MAAM,WAAW;IACjB,QAAQ,aAAa;IACrB,MAAM,WAAW;IACjB,GAAG,QAAQ;CACZ;AAED,oBAAY,kBAAkB;IAC5B,IAAI,SAAS;IACb,KAAK,UAAU;CAChB;AAED,oBAAY,aAAa;IACvB,UAAU,eAAe;IACzB,QAAQ,aAAa;CACtB;AAED,eAAO,MAAM,kBAAkB,gCAAuB,CAAC;AAEvD,eAAO,MAAM,2BAA2B,yCAAgC,CAAC;AAEzE,eAAO,MAAM,iBAAiB,+BAAsB,CAAC;AAErD,eAAO,MAAM,wBAAwB,sCAA6B,CAAC;AAEnE,eAAO,MAAM,mBAAmB,iCAAwB,CAAC"}
+{"version":3,"file":"domain.d.ts","sourceRoot":"","sources":["../../../src/workflow/domain.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,oBAAY,YAAY;IACtB,cAAc,mBAAmB;IACjC,MAAM,WAAW;IACjB,SAAS,cAAc;CACxB;AAED,oBAAY,qBAAqB;IAC/B,MAAM,WAAW;IACjB,MAAM,WAAW;IACjB,OAAO,YAAY;IACnB,MAAM,WAAW;CAClB;AAED,oBAAY,WAAW;IACrB,MAAM,WAAW;IACjB,QAAQ,aAAa;IACrB,MAAM,WAAW;IACjB,GAAG,QAAQ;CACZ;AAED,oBAAY,kBAAkB;IAC5B,IAAI,SAAS;IACb,KAAK,UAAU;CAChB;AAED,oBAAY,aAAa;IACvB,UAAU,eAAe;IACzB,QAAQ,aAAa;CACtB;AAED,oBAAY,eAAe;IACzB,IAAI,SAAS;IACb,KAAK,UAAU;IACf,MAAM,WAAW;IACjB,GAAG,QAAQ;CACZ;AAED,oBAAY,mBAAmB;IAC7B,KAAK,UAAU;IACf,KAAK,UAAU;IACf,KAAK,UAAU;CAChB;AAED,eAAO,MAAM,kBAAkB,gCAAuB,CAAC;AAEvD,eAAO,MAAM,2BAA2B,yCAAgC,CAAC;AAEzE,eAAO,MAAM,iBAAiB,+BAAsB,CAAC;AAErD,eAAO,MAAM,wBAAwB,sCAA6B,CAAC;AAEnE,eAAO,MAAM,mBAAmB,iCAAwB,CAAC;AAEzD,eAAO,MAAM,qBAAqB,mCAA0B,CAAC;AAE7D,eAAO,MAAM,yBAAyB,uCAA8B,CAAC"}

package/dist/types/workflow/index.d.ts

@@ -1,5 +1,5 @@
-export { DirectionType, McpServerTransport, MemoryScope, WorkflowType, WorkflowVersionAction, } from "./domain";
-export { createWorkflowFullSchema, workflowFullSchema, workflowSchema, workflowStubSchema, type Workflow, type WorkflowDefinitionParser, type WorkflowFull, type WorkflowStub, } from "./workflow";
+export { DirectionType, McpServerTransport, MemoryScope, WebhookAuthType, WebhookJwtAlgorithm, webhookAuthTypeSchema, webhookJwtAlgorithmSchema, WorkflowType, WorkflowVersionAction, } from "./domain";
+export { createWorkflowFullSchema, webhookTriggerSchema, workflowFullSchema, workflowSchema, workflowStubSchema, type WebhookTriggerConfig, type Workflow, type WorkflowDefinitionParser, type WorkflowFull, type WorkflowStub, } from "./workflow";
 export { workflowVersionFullSchema, workflowVersionSchema, workflowVersionStubSchema, type WorkflowVersion, type WorkflowVersionFull, type WorkflowVersionStub, } from "./workflow-version";
 export { resolveRunDurationMs, workflowRunFullSchema, workflowRunSchema, workflowRunStubSchema, type WorkflowRun, type WorkflowRunFull, type WorkflowRunStub, } from "./workflow-run";
 export { memoryDefinitionFullSchema, memoryDefinitionSchema, memoryDefinitionStubSchema, type MemoryDefinition, type MemoryDefinitionFull, type MemoryDefinitionStub, } from "./memory-definition";

package/dist/types/workflow/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/workflow/index.ts"],"names":[],"mappings":"AAMA,OAAO,EACL,aAAa,EACb,kBAAkB,EAClB,WAAW,EACX,YAAY,EACZ,qBAAqB,GACtB,MAAM,UAAU,CAAC;AAElB,OAAO,EACL,wBAAwB,EACxB,kBAAkB,EAClB,cAAc,EACd,kBAAkB,EAClB,KAAK,QAAQ,EACb,KAAK,wBAAwB,EAC7B,KAAK,YAAY,EACjB,KAAK,YAAY,GAClB,MAAM,YAAY,CAAC;AAEpB,OAAO,EACL,yBAAyB,EACzB,qBAAqB,EACrB,yBAAyB,EACzB,KAAK,eAAe,EACpB,KAAK,mBAAmB,EACxB,KAAK,mBAAmB,GACzB,MAAM,oBAAoB,CAAC;AAE5B,OAAO,EACL,oBAAoB,EACpB,qBAAqB,EACrB,iBAAiB,EACjB,qBAAqB,EACrB,KAAK,WAAW,EAChB,KAAK,eAAe,EACpB,KAAK,eAAe,GACrB,MAAM,gBAAgB,CAAC;AAExB,OAAO,EACL,0BAA0B,EAC1B,sBAAsB,EACtB,0BAA0B,EAC1B,KAAK,gBAAgB,EACrB,KAAK,oBAAoB,EACzB,KAAK,oBAAoB,GAC1B,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EACL,sBAAsB,EACtB,kBAAkB,EAClB,sBAAsB,EACtB,KAAK,YAAY,EACjB,KAAK,gBAAgB,EACrB,KAAK,gBAAgB,GACtB,MAAM,iBAAiB,CAAC;AAEzB,OAAO,EACL,mBAAmB,EACnB,eAAe,EACf,mBAAmB,EACnB,KAAK,SAAS,EACd,KAAK,aAAa,EAClB,KAAK,aAAa,GACnB,MAAM,cAAc,CAAC;AAEtB,OAAO,EACL,2BAA2B,EAC3B,uCAAuC,EACvC,qCAAqC,EACrC,oCAAoC,EACpC,oCAAoC,EACpC,+BAA+B,EAC/B,mCAAmC,EACnC,0CAA0C,EAC1C,0BAA0B,EAC1B,4BAA4B,EAC5B,4CAA4C,EAC5C,kCAAkC,EAClC,kCAAkC,EAClC,0BAA0B,EAC1B,kCAAkC,EAClC,KAAK,oBAAoB,EACzB,KAAK,+BAA+B,EACpC,KAAK,8BAA8B,EACnC,KAAK,yBAAyB,EAC9B,KAAK,8BAA8B,EACnC,KAAK,6BAA6B,EAClC,KAAK,oCAAoC,EACzC,KAAK,sBAAsB,EAC3B,KAAK,sCAAsC,EAC3C,KAAK,4BAA4B,EACjC,KAAK,4BAA4B,EACjC,KAAK,oBAAoB,GAC1B,MAAM,qBAAqB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/workflow/index.ts"],"names":[],"mappings":"AAMA,OAAO,EACL,aAAa,EACb,kBAAkB,EAClB,WAAW,EACX,eAAe,EACf,mBAAmB,EACnB,qBAAqB,EACrB,yBAAyB,EACzB,YAAY,EACZ,qBAAqB,GACtB,MAAM,UAAU,CAAC;AAElB,OAAO,EACL,wBAAwB,EACxB,oBAAoB,EACpB,kBAAkB,EAClB,cAAc,EACd,kBAAkB,EAClB,KAAK,oBAAoB,EACzB,KAAK,QAAQ,EACb,KAAK,wBAAwB,EAC7B,KAAK,YAAY,EACjB,KAAK,YAAY,GAClB,MAAM,YAAY,CAAC;AAEpB,OAAO,EACL,yBAAyB,EACzB,qBAAqB,EACrB,yBAAyB,EACzB,KAAK,eAAe,EACpB,KAAK,mBAAmB,EACxB,KAAK,mBAAmB,GACzB,MAAM,oBAAoB,CAAC;AAE5B,OAAO,EACL,oBAAoB,EACpB,qBAAqB,EACrB,iBAAiB,EACjB,qBAAqB,EACrB,KAAK,WAAW,EAChB,KAAK,eAAe,EACpB,KAAK,eAAe,GACrB,MAAM,gBAAgB,CAAC;AAExB,OAAO,EACL,0BAA0B,EAC1B,sBAAsB,EACtB,0BAA0B,EAC1B,KAAK,gBAAgB,EACrB,KAAK,oBAAoB,EACzB,KAAK,oBAAoB,GAC1B,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EACL,sBAAsB,EACtB,kBAAkB,EAClB,sBAAsB,EACtB,KAAK,YAAY,EACjB,KAAK,gBAAgB,EACrB,KAAK,gBAAgB,GACtB,MAAM,iBAAiB,CAAC;AAEzB,OAAO,EACL,mBAAmB,EACnB,eAAe,EACf,mBAAmB,EACnB,KAAK,SAAS,EACd,KAAK,aAAa,EAClB,KAAK,aAAa,GACnB,MAAM,cAAc,CAAC;AAEtB,OAAO,EACL,2BAA2B,EAC3B,uCAAuC,EACvC,qCAAqC,EACrC,oCAAoC,EACpC,oCAAoC,EACpC,+BAA+B,EAC/B,mCAAmC,EACnC,0CAA0C,EAC1C,0BAA0B,EAC1B,4BAA4B,EAC5B,4CAA4C,EAC5C,kCAAkC,EAClC,kCAAkC,EAClC,0BAA0B,EAC1B,kCAAkC,EAClC,KAAK,oBAAoB,EACzB,KAAK,+BAA+B,EACpC,KAAK,8BAA8B,EACnC,KAAK,yBAAyB,EAC9B,KAAK,8BAA8B,EACnC,KAAK,6BAA6B,EAClC,KAAK,oCAAoC,EACzC,KAAK,sBAAsB,EAC3B,KAAK,sCAAsC,EAC3C,KAAK,4BAA4B,EACjC,KAAK,4BAA4B,EACjC,KAAK,oBAAoB,GAC1B,MAAM,qBAAqB,CAAC"}

package/dist/types/workflow/memory-record.d.ts

@@ -178,6 +178,25 @@ export declare const memoryRecordFullSchema: z.ZodObject<{
         direction: import("./domain").DirectionType;
         createdBy: string | null;
         runAfterMs: number;
+        webhookTrigger?: {
+            authType: import("./domain").WebhookAuthType.none;
+            enabled: boolean;
+        } | {
+            authType: import("./domain").WebhookAuthType.basic;
+            username: string | null | undefined;
+            passwordCredentialId: string | null | undefined;
+            enabled: boolean;
+        } | {
+            authType: import("./domain").WebhookAuthType.header;
+            headerName: string | null | undefined;
+            headerValueCredentialId: string | null | undefined;
+            enabled: boolean;
+        } | {
+            authType: import("./domain").WebhookAuthType.jwt;
+            jwtSecretCredentialId: string | null | undefined;
+            jwtAlgorithm: import("./domain").WebhookJwtAlgorithm | null | undefined;
+            enabled: boolean;
+        } | null | undefined;
         currentVersion?: string | null | undefined;
         publishedVersion?: string | null | undefined;
     }, unknown, z.core.$ZodTypeInternals<{
@@ -196,6 +215,25 @@ export declare const memoryRecordFullSchema: z.ZodObject<{
         direction: import("./domain").DirectionType;
         createdBy: string | null;
         runAfterMs: number;
+        webhookTrigger?: {
+            authType: import("./domain").WebhookAuthType.none;
+            enabled: boolean;
+        } | {
+            authType: import("./domain").WebhookAuthType.basic;
+            username: string | null | undefined;
+            passwordCredentialId: string | null | undefined;
+            enabled: boolean;
+        } | {
+            authType: import("./domain").WebhookAuthType.header;
+            headerName: string | null | undefined;
+            headerValueCredentialId: string | null | undefined;
+            enabled: boolean;
+        } | {
+            authType: import("./domain").WebhookAuthType.jwt;
+            jwtSecretCredentialId: string | null | undefined;
+            jwtAlgorithm: import("./domain").WebhookJwtAlgorithm | null | undefined;
+            enabled: boolean;
+        } | null | undefined;
         currentVersion?: string | null | undefined;
         publishedVersion?: string | null | undefined;
     }, unknown>>>>;

package/dist/types/workflow/memory-record.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"memory-record.d.ts","sourceRoot":"","sources":["../../../src/workflow/memory-record.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAwBxB,eAAO,MAAM,sBAAsB;;;;;;;iBAA+B,CAAC;AAEnE,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;YAwB9B,CAAC;AAEF,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAMjC,CAAC;AAEH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAEtE,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE9D,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC"}
+{"version":3,"file":"memory-record.d.ts","sourceRoot":"","sources":["../../../src/workflow/memory-record.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAwBxB,eAAO,MAAM,sBAAsB;;;;;;;iBAA+B,CAAC;AAEnE,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;YAwB9B,CAAC;AAEF,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAMjC,CAAC;AAEH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAEtE,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE9D,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC"}

package/dist/types/workflow/workflow-run.d.ts

@@ -159,6 +159,25 @@ export declare const workflowRunFullSchema: z.ZodType<{
         direction: import("./domain").DirectionType;
         createdBy: string | null;
         runAfterMs: number;
+        webhookTrigger?: {
+            authType: import("./domain").WebhookAuthType.none;
+            enabled: boolean;
+        } | {
+            authType: import("./domain").WebhookAuthType.basic;
+            username: string | null | undefined;
+            passwordCredentialId: string | null | undefined;
+            enabled: boolean;
+        } | {
+            authType: import("./domain").WebhookAuthType.header;
+            headerName: string | null | undefined;
+            headerValueCredentialId: string | null | undefined;
+            enabled: boolean;
+        } | {
+            authType: import("./domain").WebhookAuthType.jwt;
+            jwtSecretCredentialId: string | null | undefined;
+            jwtAlgorithm: import("./domain").WebhookJwtAlgorithm | null | undefined;
+            enabled: boolean;
+        } | null | undefined;
         currentVersion?: string | null | undefined;
         publishedVersion?: string | null | undefined;
     };
@@ -313,6 +332,25 @@ export declare const workflowRunFullSchema: z.ZodType<{
         direction: import("./domain").DirectionType;
         createdBy: string | null;
         runAfterMs: number;
+        webhookTrigger?: {
+            authType: import("./domain").WebhookAuthType.none;
+            enabled: boolean;
+        } | {
+            authType: import("./domain").WebhookAuthType.basic;
+            username: string | null | undefined;
+            passwordCredentialId: string | null | undefined;
+            enabled: boolean;
+        } | {
+            authType: import("./domain").WebhookAuthType.header;
+            headerName: string | null | undefined;
+            headerValueCredentialId: string | null | undefined;
+            enabled: boolean;
+        } | {
+            authType: import("./domain").WebhookAuthType.jwt;
+            jwtSecretCredentialId: string | null | undefined;
+            jwtAlgorithm: import("./domain").WebhookJwtAlgorithm | null | undefined;
+            enabled: boolean;
+        } | null | undefined;
         currentVersion?: string | null | undefined;
         publishedVersion?: string | null | undefined;
     };

package/dist/types/workflow/workflow-run.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"workflow-run.d.ts","sourceRoot":"","sources":["../../../src/workflow/workflow-run.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAgBxB,QAAA,MAAM,uBAAuB;;;;;;EAM3B,CAAC;AAYH,eAAO,MAAM,oBAAoB,GAAI,KAAK;IACxC,SAAS,CAAC,EAAE,IAAI,GAAG,MAAM,GAAG,IAAI,CAAC;IACjC,UAAU,CAAC,EAAE,IAAI,GAAG,MAAM,GAAG,IAAI,CAAC;IAClC,QAAQ,CAAC,EAAE,IAAI,GAAG,MAAM,GAAG,IAAI,CAAC;IAChC,WAAW,CAAC,EAAE,IAAI,GAAG,MAAM,GAAG,IAAI,CAAC;IACnC,MAAM,CAAC,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,GAAG,IAAI,CAAC;CACzD,KAAG,MAAM,GAAG,IAiBZ,CAAC;AAqDF,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAGjC,CAAC;AAEF,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAoB7B,CAAC;AAEF,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAejC,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAEpE,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAE5D,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC"}
+{"version":3,"file":"workflow-run.d.ts","sourceRoot":"","sources":["../../../src/workflow/workflow-run.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAgBxB,QAAA,MAAM,uBAAuB;;;;;;EAM3B,CAAC;AAYH,eAAO,MAAM,oBAAoB,GAAI,KAAK;IACxC,SAAS,CAAC,EAAE,IAAI,GAAG,MAAM,GAAG,IAAI,CAAC;IACjC,UAAU,CAAC,EAAE,IAAI,GAAG,MAAM,GAAG,IAAI,CAAC;IAClC,QAAQ,CAAC,EAAE,IAAI,GAAG,MAAM,GAAG,IAAI,CAAC;IAChC,WAAW,CAAC,EAAE,IAAI,GAAG,MAAM,GAAG,IAAI,CAAC;IACnC,MAAM,CAAC,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,GAAG,IAAI,CAAC;CACzD,KAAG,MAAM,GAAG,IAiBZ,CAAC;AAqDF,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAGjC,CAAC;AAEF,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAoB7B,CAAC;AAEF,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAejC,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAEpE,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAE5D,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC"}

package/dist/types/workflow/workflow-transfer.d.ts

@@ -280,6 +280,25 @@ export declare const workflowImportResultSchema: z.ZodObject<{
         direction: import("./domain").DirectionType;
         createdBy: string | null;
         runAfterMs: number;
+        webhookTrigger?: {
+            authType: import("./domain").WebhookAuthType.none;
+            enabled: boolean;
+        } | {
+            authType: import("./domain").WebhookAuthType.basic;
+            username: string | null | undefined;
+            passwordCredentialId: string | null | undefined;
+            enabled: boolean;
+        } | {
+            authType: import("./domain").WebhookAuthType.header;
+            headerName: string | null | undefined;
+            headerValueCredentialId: string | null | undefined;
+            enabled: boolean;
+        } | {
+            authType: import("./domain").WebhookAuthType.jwt;
+            jwtSecretCredentialId: string | null | undefined;
+            jwtAlgorithm: import("./domain").WebhookJwtAlgorithm | null | undefined;
+            enabled: boolean;
+        } | null | undefined;
         currentVersion?: string | null | undefined;
         publishedVersion?: string | null | undefined;
     }, unknown, z.core.$ZodTypeInternals<{
@@ -298,6 +317,25 @@ export declare const workflowImportResultSchema: z.ZodObject<{
         direction: import("./domain").DirectionType;
         createdBy: string | null;
         runAfterMs: number;
+        webhookTrigger?: {
+            authType: import("./domain").WebhookAuthType.none;
+            enabled: boolean;
+        } | {
+            authType: import("./domain").WebhookAuthType.basic;
+            username: string | null | undefined;
+            passwordCredentialId: string | null | undefined;
+            enabled: boolean;
+        } | {
+            authType: import("./domain").WebhookAuthType.header;
+            headerName: string | null | undefined;
+            headerValueCredentialId: string | null | undefined;
+            enabled: boolean;
+        } | {
+            authType: import("./domain").WebhookAuthType.jwt;
+            jwtSecretCredentialId: string | null | undefined;
+            jwtAlgorithm: import("./domain").WebhookJwtAlgorithm | null | undefined;
+            enabled: boolean;
+        } | null | undefined;
         currentVersion?: string | null | undefined;
         publishedVersion?: string | null | undefined;
     }, unknown>>;

package/dist/types/workflow/workflow-transfer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"workflow-transfer.d.ts","sourceRoot":"","sources":["../../../src/workflow/workflow-transfer.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAUxB,eAAO,MAAM,2BAA2B,4BAA4B,CAAC;AAErE,eAAO,MAAM,uCAAuC,QACP,CAAC;AAE9C,eAAO,MAAM,kCAAkC,aAGE,CAAC;AAwBlD,eAAO,MAAM,0CAA0C;;;;;;;kBAOrD,CAAC;AAEH,eAAO,MAAM,oCAAoC;;;;kBAI/C,CAAC;AAEH,eAAO,MAAM,mCAAmC;;;;;;;;;;kBAU9C,CAAC;AAEH,eAAO,MAAM,qCAAqC;;;;kBAIhD,CAAC;AAEH,eAAO,MAAM,oCAAoC;;;kBAG/C,CAAC;AAEH,eAAO,MAAM,+BAA+B;;;;;;kBAM1C,CAAC;AAEH,eAAO,MAAM,4CAA4C;;;;;;;;;;;;;;;;;;;;;;kBAKvD,CAAC;AAgBH,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAQvC,CAAC;AAEH,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAA+B,CAAC;AAEvE,eAAO,MAAM,kCAAkC;;;;EAI7C,CAAC;AAEH,eAAO,MAAM,kCAAkC;;;;;;;;;;kBAM7C,CAAC;AAEH,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAIrC,CAAC;AAEH,MAAM,MAAM,oCAAoC,GAAG,CAAC,CAAC,KAAK,CACxD,OAAO,0CAA0C,CAClD,CAAC;AAEF,MAAM,MAAM,8BAA8B,GAAG,CAAC,CAAC,KAAK,CAClD,OAAO,oCAAoC,CAC5C,CAAC;AAEF,MAAM,MAAM,6BAA6B,GAAG,CAAC,CAAC,KAAK,CACjD,OAAO,mCAAmC,CAC3C,CAAC;AAEF,MAAM,MAAM,+BAA+B,GAAG,CAAC,CAAC,KAAK,CACnD,OAAO,qCAAqC,CAC7C,CAAC;AAEF,MAAM,MAAM,8BAA8B,GAAG,CAAC,CAAC,KAAK,CAClD,OAAO,oCAAoC,CAC5C,CAAC;AAEF,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAC7C,OAAO,+BAA+B,CACvC,CAAC;AAEF,MAAM,MAAM,sCAAsC,GAAG,CAAC,CAAC,KAAK,CAC1D,OAAO,4CAA4C,CACpD,CAAC;AAEF,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAC1C,OAAO,4BAA4B,CACpC,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAE9E,MAAM,MAAM,4BAA4B,GAAG,CAAC,CAAC,KAAK,CAChD,OAAO,kCAAkC,CAC1C,CAAC;AAEF,MAAM,MAAM,4BAA4B,GAAG,CAAC,CAAC,KAAK,CAChD,OAAO,kCAAkC,CAC1C,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC"}
+{"version":3,"file":"workflow-transfer.d.ts","sourceRoot":"","sources":["../../../src/workflow/workflow-transfer.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAUxB,eAAO,MAAM,2BAA2B,4BAA4B,CAAC;AAErE,eAAO,MAAM,uCAAuC,QACP,CAAC;AAE9C,eAAO,MAAM,kCAAkC,aAGE,CAAC;AAwBlD,eAAO,MAAM,0CAA0C;;;;;;;kBAOrD,CAAC;AAEH,eAAO,MAAM,oCAAoC;;;;kBAI/C,CAAC;AAEH,eAAO,MAAM,mCAAmC;;;;;;;;;;kBAU9C,CAAC;AAEH,eAAO,MAAM,qCAAqC;;;;kBAIhD,CAAC;AAEH,eAAO,MAAM,oCAAoC;;;kBAG/C,CAAC;AAEH,eAAO,MAAM,+BAA+B;;;;;;kBAM1C,CAAC;AAEH,eAAO,MAAM,4CAA4C;;;;;;;;;;;;;;;;;;;;;;kBAKvD,CAAC;AAgBH,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAQvC,CAAC;AAEH,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAA+B,CAAC;AAEvE,eAAO,MAAM,kCAAkC;;;;EAI7C,CAAC;AAEH,eAAO,MAAM,kCAAkC;;;;;;;;;;kBAM7C,CAAC;AAEH,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAIrC,CAAC;AAEH,MAAM,MAAM,oCAAoC,GAAG,CAAC,CAAC,KAAK,CACxD,OAAO,0CAA0C,CAClD,CAAC;AAEF,MAAM,MAAM,8BAA8B,GAAG,CAAC,CAAC,KAAK,CAClD,OAAO,oCAAoC,CAC5C,CAAC;AAEF,MAAM,MAAM,6BAA6B,GAAG,CAAC,CAAC,KAAK,CACjD,OAAO,mCAAmC,CAC3C,CAAC;AAEF,MAAM,MAAM,+BAA+B,GAAG,CAAC,CAAC,KAAK,CACnD,OAAO,qCAAqC,CAC7C,CAAC;AAEF,MAAM,MAAM,8BAA8B,GAAG,CAAC,CAAC,KAAK,CAClD,OAAO,oCAAoC,CAC5C,CAAC;AAEF,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAC7C,OAAO,+BAA+B,CACvC,CAAC;AAEF,MAAM,MAAM,sCAAsC,GAAG,CAAC,CAAC,KAAK,CAC1D,OAAO,4CAA4C,CACpD,CAAC;AAEF,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAC1C,OAAO,4BAA4B,CACpC,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAE9E,MAAM,MAAM,4BAA4B,GAAG,CAAC,CAAC,KAAK,CAChD,OAAO,kCAAkC,CAC1C,CAAC;AAEF,MAAM,MAAM,4BAA4B,GAAG,CAAC,CAAC,KAAK,CAChD,OAAO,kCAAkC,CAC1C,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC"}

package/dist/types/workflow/workflow-version.d.ts

@@ -84,6 +84,25 @@ export declare const workflowVersionFullSchema: z.ZodObject<{
         direction: import("./domain").DirectionType;
         createdBy: string | null;
         runAfterMs: number;
+        webhookTrigger?: {
+            authType: import("./domain").WebhookAuthType.none;
+            enabled: boolean;
+        } | {
+            authType: import("./domain").WebhookAuthType.basic;
+            username: string | null | undefined;
+            passwordCredentialId: string | null | undefined;
+            enabled: boolean;
+        } | {
+            authType: import("./domain").WebhookAuthType.header;
+            headerName: string | null | undefined;
+            headerValueCredentialId: string | null | undefined;
+            enabled: boolean;
+        } | {
+            authType: import("./domain").WebhookAuthType.jwt;
+            jwtSecretCredentialId: string | null | undefined;
+            jwtAlgorithm: import("./domain").WebhookJwtAlgorithm | null | undefined;
+            enabled: boolean;
+        } | null | undefined;
         currentVersion?: string | null | undefined;
         publishedVersion?: string | null | undefined;
     }, unknown, z.core.$ZodTypeInternals<{
@@ -102,6 +121,25 @@ export declare const workflowVersionFullSchema: z.ZodObject<{
         direction: import("./domain").DirectionType;
         createdBy: string | null;
         runAfterMs: number;
+        webhookTrigger?: {
+            authType: import("./domain").WebhookAuthType.none;
+            enabled: boolean;
+        } | {
+            authType: import("./domain").WebhookAuthType.basic;
+            username: string | null | undefined;
+            passwordCredentialId: string | null | undefined;
+            enabled: boolean;
+        } | {
+            authType: import("./domain").WebhookAuthType.header;
+            headerName: string | null | undefined;
+            headerValueCredentialId: string | null | undefined;
+            enabled: boolean;
+        } | {
+            authType: import("./domain").WebhookAuthType.jwt;
+            jwtSecretCredentialId: string | null | undefined;
+            jwtAlgorithm: import("./domain").WebhookJwtAlgorithm | null | undefined;
+            enabled: boolean;
+        } | null | undefined;
         currentVersion?: string | null | undefined;
         publishedVersion?: string | null | undefined;
     }, unknown>>>;

package/dist/types/workflow/workflow-version.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"workflow-version.d.ts","sourceRoot":"","sources":["../../../src/workflow/workflow-version.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAuBxB,eAAO,MAAM,yBAAyB;;;;;;;;;iBAAkC,CAAC;AAEzE,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;YAgBjC,CAAC;AAEF,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAYrC,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAE5E,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAEpE,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC"}
+{"version":3,"file":"workflow-version.d.ts","sourceRoot":"","sources":["../../../src/workflow/workflow-version.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAuBxB,eAAO,MAAM,yBAAyB;;;;;;;;;iBAAkC,CAAC;AAEzE,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;YAgBjC,CAAC;AAEF,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAYrC,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAE5E,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAEpE,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC"}

package/dist/types/workflow/workflow.d.ts

@@ -1,4 +1,43 @@
 import { z } from "zod";
+import { WebhookAuthType } from "./domain";
+export declare const webhookTriggerSchema: z.ZodType<{
+    authType: WebhookAuthType.none;
+    enabled: boolean;
+} | {
+    authType: WebhookAuthType.basic;
+    username: string | null | undefined;
+    passwordCredentialId: string | null | undefined;
+    enabled: boolean;
+} | {
+    authType: WebhookAuthType.header;
+    headerName: string | null | undefined;
+    headerValueCredentialId: string | null | undefined;
+    enabled: boolean;
+} | {
+    authType: WebhookAuthType.jwt;
+    jwtSecretCredentialId: string | null | undefined;
+    jwtAlgorithm: import("./domain").WebhookJwtAlgorithm | null | undefined;
+    enabled: boolean;
+}, unknown, z.core.$ZodTypeInternals<{
+    authType: WebhookAuthType.none;
+    enabled: boolean;
+} | {
+    authType: WebhookAuthType.basic;
+    username: string | null | undefined;
+    passwordCredentialId: string | null | undefined;
+    enabled: boolean;
+} | {
+    authType: WebhookAuthType.header;
+    headerName: string | null | undefined;
+    headerValueCredentialId: string | null | undefined;
+    enabled: boolean;
+} | {
+    authType: WebhookAuthType.jwt;
+    jwtSecretCredentialId: string | null | undefined;
+    jwtAlgorithm: import("./domain").WebhookJwtAlgorithm | null | undefined;
+    enabled: boolean;
+}, unknown>>;
+export type WebhookTriggerConfig = z.infer<typeof webhookTriggerSchema>;
 export type WorkflowDefinitionParser = (definitionYml: string) => unknown;
 export declare const workflowStubSchema: z.ZodObject<{
     id: z.ZodString;
@@ -14,6 +53,43 @@ export declare const workflowStubSchema: z.ZodObject<{
     y: z.ZodCoercedNumber<unknown>;
     zoom: z.ZodCoercedNumber<unknown>;
     direction: z.ZodEnum<typeof import("./domain").DirectionType>;
+    webhookTrigger: z.ZodOptional<z.ZodType<{
+        authType: WebhookAuthType.none;
+        enabled: boolean;
+    } | {
+        authType: WebhookAuthType.basic;
+        username: string | null | undefined;
+        passwordCredentialId: string | null | undefined;
+        enabled: boolean;
+    } | {
+        authType: WebhookAuthType.header;
+        headerName: string | null | undefined;
+        headerValueCredentialId: string | null | undefined;
+        enabled: boolean;
+    } | {
+        authType: WebhookAuthType.jwt;
+        jwtSecretCredentialId: string | null | undefined;
+        jwtAlgorithm: import("./domain").WebhookJwtAlgorithm | null | undefined;
+        enabled: boolean;
+    } | null, unknown, z.core.$ZodTypeInternals<{
+        authType: WebhookAuthType.none;
+        enabled: boolean;
+    } | {
+        authType: WebhookAuthType.basic;
+        username: string | null | undefined;
+        passwordCredentialId: string | null | undefined;
+        enabled: boolean;
+    } | {
+        authType: WebhookAuthType.header;
+        headerName: string | null | undefined;
+        headerValueCredentialId: string | null | undefined;
+        enabled: boolean;
+    } | {
+        authType: WebhookAuthType.jwt;
+        jwtSecretCredentialId: string | null | undefined;
+        jwtAlgorithm: import("./domain").WebhookJwtAlgorithm | null | undefined;
+        enabled: boolean;
+    } | null, unknown>>>;
 }, z.core.$strip>;
 export declare const workflowSchema: z.ZodType<{
     id: string;
@@ -31,6 +107,25 @@ export declare const workflowSchema: z.ZodType<{
     direction: import("./domain").DirectionType;
     createdBy: string | null;
     runAfterMs: number;
+    webhookTrigger?: {
+        authType: WebhookAuthType.none;
+        enabled: boolean;
+    } | {
+        authType: WebhookAuthType.basic;
+        username: string | null | undefined;
+        passwordCredentialId: string | null | undefined;
+        enabled: boolean;
+    } | {
+        authType: WebhookAuthType.header;
+        headerName: string | null | undefined;
+        headerValueCredentialId: string | null | undefined;
+        enabled: boolean;
+    } | {
+        authType: WebhookAuthType.jwt;
+        jwtSecretCredentialId: string | null | undefined;
+        jwtAlgorithm: import("./domain").WebhookJwtAlgorithm | null | undefined;
+        enabled: boolean;
+    } | null | undefined;
     currentVersion?: string | null | undefined;
     publishedVersion?: string | null | undefined;
 }, unknown, z.core.$ZodTypeInternals<{
@@ -49,6 +144,25 @@ export declare const workflowSchema: z.ZodType<{
     direction: import("./domain").DirectionType;
     createdBy: string | null;
     runAfterMs: number;
+    webhookTrigger?: {
+        authType: WebhookAuthType.none;
+        enabled: boolean;
+    } | {
+        authType: WebhookAuthType.basic;
+        username: string | null | undefined;
+        passwordCredentialId: string | null | undefined;
+        enabled: boolean;
+    } | {
+        authType: WebhookAuthType.header;
+        headerName: string | null | undefined;
+        headerValueCredentialId: string | null | undefined;
+        enabled: boolean;
+    } | {
+        authType: WebhookAuthType.jwt;
+        jwtSecretCredentialId: string | null | undefined;
+        jwtAlgorithm: import("./domain").WebhookJwtAlgorithm | null | undefined;
+        enabled: boolean;
+    } | null | undefined;
     currentVersion?: string | null | undefined;
     publishedVersion?: string | null | undefined;
 }, unknown>>;
@@ -128,6 +242,25 @@ export declare const createWorkflowFullSchema: (options?: {
             sub?: string | undefined;
         } | undefined;
     } | null;
+    webhookTrigger?: {
+        authType: WebhookAuthType.none;
+        enabled: boolean;
+    } | {
+        authType: WebhookAuthType.basic;
+        username: string | null | undefined;
+        passwordCredentialId: string | null | undefined;
+        enabled: boolean;
+    } | {
+        authType: WebhookAuthType.header;
+        headerName: string | null | undefined;
+        headerValueCredentialId: string | null | undefined;
+        enabled: boolean;
+    } | {
+        authType: WebhookAuthType.jwt;
+        jwtSecretCredentialId: string | null | undefined;
+        jwtAlgorithm: import("./domain").WebhookJwtAlgorithm | null | undefined;
+        enabled: boolean;
+    } | null | undefined;
     definitionYml?: string | undefined;
     definition?: any;
 }, unknown, z.core.$ZodTypeInternals<{
@@ -204,6 +337,25 @@ export declare const createWorkflowFullSchema: (options?: {
             sub?: string | undefined;
         } | undefined;
     } | null;
+    webhookTrigger?: {
+        authType: WebhookAuthType.none;
+        enabled: boolean;
+    } | {
+        authType: WebhookAuthType.basic;
+        username: string | null | undefined;
+        passwordCredentialId: string | null | undefined;
+        enabled: boolean;
+    } | {
+        authType: WebhookAuthType.header;
+        headerName: string | null | undefined;
+        headerValueCredentialId: string | null | undefined;
+        enabled: boolean;
+    } | {
+        authType: WebhookAuthType.jwt;
+        jwtSecretCredentialId: string | null | undefined;
+        jwtAlgorithm: import("./domain").WebhookJwtAlgorithm | null | undefined;
+        enabled: boolean;
+    } | null | undefined;
     definitionYml?: string | undefined;
     definition?: any;
 }, unknown>>;
@@ -281,6 +433,25 @@ export declare const workflowFullSchema: z.ZodType<{
             sub?: string | undefined;
         } | undefined;
     } | null;
+    webhookTrigger?: {
+        authType: WebhookAuthType.none;
+        enabled: boolean;
+    } | {
+        authType: WebhookAuthType.basic;
+        username: string | null | undefined;
+        passwordCredentialId: string | null | undefined;
+        enabled: boolean;
+    } | {
+        authType: WebhookAuthType.header;
+        headerName: string | null | undefined;
+        headerValueCredentialId: string | null | undefined;
+        enabled: boolean;
+    } | {
+        authType: WebhookAuthType.jwt;
+        jwtSecretCredentialId: string | null | undefined;
+        jwtAlgorithm: import("./domain").WebhookJwtAlgorithm | null | undefined;
+        enabled: boolean;
+    } | null | undefined;
     definitionYml?: string | undefined;
     definition?: any;
 }, unknown, z.core.$ZodTypeInternals<{
@@ -357,6 +528,25 @@ export declare const workflowFullSchema: z.ZodType<{
             sub?: string | undefined;
         } | undefined;
     } | null;
+    webhookTrigger?: {
+        authType: WebhookAuthType.none;
+        enabled: boolean;
+    } | {
+        authType: WebhookAuthType.basic;
+        username: string | null | undefined;
+        passwordCredentialId: string | null | undefined;
+        enabled: boolean;
+    } | {
+        authType: WebhookAuthType.header;
+        headerName: string | null | undefined;
+        headerValueCredentialId: string | null | undefined;
+        enabled: boolean;
+    } | {
+        authType: WebhookAuthType.jwt;
+        jwtSecretCredentialId: string | null | undefined;
+        jwtAlgorithm: import("./domain").WebhookJwtAlgorithm | null | undefined;
+        enabled: boolean;
+    } | null | undefined;
     definitionYml?: string | undefined;
     definition?: any;
 }, unknown>>;

package/dist/types/workflow/workflow.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"workflow.d.ts","sourceRoot":"","sources":["../../../src/workflow/workflow.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAYxB,MAAM,MAAM,wBAAwB,GAAG,CAAC,aAAa,EAAE,MAAM,KAAK,OAAO,CAAC;AAuG1E,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;iBAA2B,CAAC;AAE3D,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAsB1B,CAAC;AAEF,eAAO,MAAM,wBAAwB,GAAI,UAAU;IACjD,eAAe,CAAC,EAAE,wBAAwB,CAAC;CAC5C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAKA,CAAC;AAEF,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAA6B,CAAC;AAE7D,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE9D,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAEtD,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC"}
+{"version":3,"file":"workflow.d.ts","sourceRoot":"","sources":["../../../src/workflow/workflow.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAQxB,OAAO,EAEL,eAAe,EAGhB,MAAM,UAAU,CAAC;AAclB,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAqFhC,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAExE,MAAM,MAAM,wBAAwB,GAAG,CAAC,aAAa,EAAE,MAAM,KAAK,OAAO,CAAC;AA2G1E,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAA2B,CAAC;AAE3D,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAsB1B,CAAC;AAEF,eAAO,MAAM,wBAAwB,GAAI,UAAU;IACjD,eAAe,CAAC,EAAE,wBAAwB,CAAC;CAC5C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAKA,CAAC;AAEF,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAA6B,CAAC;AAE7D,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE9D,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAEtD,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hexabot-ai/types",
-  "version": "3.0.7-beta.0",
+  "version": "3.1.0-beta.0",
   "description": "Shared zod schemas and inferred entity types for Hexabot.",
   "main": "dist/cjs/index.js",
   "module": "dist/esm/index.js",
@@ -47,7 +47,8 @@
     "build": "pnpm run build:cjs && pnpm run build:esm",
     "build:cjs": "tsc -p tsconfig.build.cjs.json",
     "build:esm": "tsc -p tsconfig.build.esm.json",
-    "dev": "pnpm exec concurrently -k -n cjs,esm \"pnpm run build:cjs:watch\" \"pnpm run build:esm:watch\"",
+    "dev": "pnpm run build:cjs:watch",
+    "dev:full": "pnpm exec concurrently -k -n cjs,esm \"pnpm run build:cjs:watch\" \"pnpm run build:esm:watch\"",
     "build:watch": "tsc -p tsconfig.json --watch",
     "lint": "eslint \"src/**/*.ts\" \"jest.config.ts\"",
     "lint:fix": "eslint \"src/**/*.ts\" \"jest.config.ts\" --fix",

package/src/index.test.ts

@@ -56,6 +56,8 @@ import {
   threadFullSchema,
   userFullSchema,
   userSchema,
+  webhookTriggerSchema,
+  WebhookAuthType,
   workflowFullSchema,
   workflowExportBundleSchema,
   workflowExportBundleV1Schema,
@@ -68,6 +70,50 @@ import {
 describe("@hexabot-ai/types schemas", () => {
   const now = "2026-01-01T00:00:00.000Z";
 
+  it("never carries inline webhook secrets", () => {
+    // Unknown keys (e.g. an inline secret sent by a stale client) are
+    // stripped: only credential references are part of the config shape.
+    const parsed = webhookTriggerSchema.parse({
+      enabled: true,
+      authType: WebhookAuthType.jwt,
+      jwtSecret: "plaintext-secret",
+      jwtSecretCredentialId: "cred-1",
+    });
+
+    expect("jwtSecret" in parsed).toBe(false);
+    expect(
+      (parsed as { jwtSecretCredentialId?: string | null })
+        .jwtSecretCredentialId,
+    ).toBe("cred-1");
+  });
+
+  it("requires credential refs once the webhook is enabled", () => {
+    expect(() =>
+      webhookTriggerSchema.parse({
+        enabled: true,
+        authType: WebhookAuthType.basic,
+        username: "ada",
+        passwordCredentialId: null,
+      }),
+    ).toThrow();
+    expect(() =>
+      webhookTriggerSchema.parse({
+        enabled: true,
+        authType: WebhookAuthType.basic,
+        username: "ada",
+        passwordCredentialId: "cred-1",
+      }),
+    ).not.toThrow();
+    // Disabled webhooks can be saved without credentials.
+    expect(() =>
+      webhookTriggerSchema.parse({
+        enabled: false,
+        authType: WebhookAuthType.jwt,
+        jwtSecretCredentialId: null,
+      }),
+    ).not.toThrow();
+  });
+
   it("maps user aliases and strips unknown keys", () => {
     const parsed = userSchema.parse({
       id: "u_1",

package/src/workflow/domain.ts

@@ -36,6 +36,19 @@ export enum DirectionType {
   VERTICAL = "vertical",
 }
 
+export enum WebhookAuthType {
+  none = "none",
+  basic = "basic",
+  header = "header",
+  jwt = "jwt",
+}
+
+export enum WebhookJwtAlgorithm {
+  HS256 = "HS256",
+  HS384 = "HS384",
+  HS512 = "HS512",
+}
+
 export const workflowTypeSchema = z.enum(WorkflowType);
 
 export const workflowVersionActionSchema = z.enum(WorkflowVersionAction);
@@ -45,3 +58,7 @@ export const memoryScopeSchema = z.enum(MemoryScope);
 export const mcpServerTransportSchema = z.enum(McpServerTransport);
 
 export const directionTypeSchema = z.enum(DirectionType);
+
+export const webhookAuthTypeSchema = z.enum(WebhookAuthType);
+
+export const webhookJwtAlgorithmSchema = z.enum(WebhookJwtAlgorithm);

package/src/workflow/index.ts

@@ -8,15 +8,21 @@ export {
   DirectionType,
   McpServerTransport,
   MemoryScope,
+  WebhookAuthType,
+  WebhookJwtAlgorithm,
+  webhookAuthTypeSchema,
+  webhookJwtAlgorithmSchema,
   WorkflowType,
   WorkflowVersionAction,
 } from "./domain";
 
 export {
   createWorkflowFullSchema,
+  webhookTriggerSchema,
   workflowFullSchema,
   workflowSchema,
   workflowStubSchema,
+  type WebhookTriggerConfig,
   type Workflow,
   type WorkflowDefinitionParser,
   type WorkflowFull,

package/src/workflow/workflow.ts

@@ -12,10 +12,114 @@ import { cloneWithPrototype, toRecord } from "../shared/object";
 import { preprocess } from "../shared/preprocess";
 import { userSchema } from "../user/user";
 
-import { directionTypeSchema, workflowTypeSchema } from "./domain";
+import {
+  directionTypeSchema,
+  WebhookAuthType,
+  webhookJwtAlgorithmSchema,
+  workflowTypeSchema,
+} from "./domain";
 import { nullishToNull } from "./helpers";
 import { workflowVersionSchema } from "./workflow-version";
 
+const nullableString = preprocess(
+  nullishToNull,
+  z.string().nullable().optional(),
+);
+const webhookTriggerBaseShape = {
+  enabled: z.coerce.boolean().default(false),
+};
+
+// Secrets are never stored inline on the workflow: each secret lives in the
+// credentials store and the trigger config only carries its credential id.
+export const webhookTriggerSchema = preprocess(
+  (value) => {
+    // Default the discriminator so a config without an explicit authType still
+    // validates as an unauthenticated webhook (matches the previous behaviour).
+    const record = toRecord(value);
+    if (record && record.authType == null) {
+      return { ...record, authType: WebhookAuthType.none };
+    }
+
+    return value;
+  },
+  z
+    .discriminatedUnion("authType", [
+      z.object({
+        ...webhookTriggerBaseShape,
+        authType: z.literal(WebhookAuthType.none),
+      }),
+      z.object({
+        ...webhookTriggerBaseShape,
+        authType: z.literal(WebhookAuthType.basic),
+        username: nullableString,
+        passwordCredentialId: nullableString,
+      }),
+      z.object({
+        ...webhookTriggerBaseShape,
+        authType: z.literal(WebhookAuthType.header),
+        headerName: nullableString,
+        headerValueCredentialId: nullableString,
+      }),
+      z.object({
+        ...webhookTriggerBaseShape,
+        authType: z.literal(WebhookAuthType.jwt),
+        jwtSecretCredentialId: nullableString,
+        jwtAlgorithm: preprocess(
+          nullishToNull,
+          webhookJwtAlgorithmSchema.nullable().optional(),
+        ),
+      }),
+    ])
+    // An enabled webhook with an unset credential reference would otherwise
+    // authenticate empty credentials, so references are mandatory once
+    // enabled.
+    .superRefine((config, ctx) => {
+      if (!config.enabled) {
+        return;
+      }
+
+      const requireCredential = (
+        field: string,
+        value: string | null | undefined,
+      ) => {
+        if (!value) {
+          ctx.addIssue({
+            code: "custom",
+            path: [field],
+            message: `${field} is required when the webhook trigger is enabled`,
+          });
+        }
+      };
+
+      switch (config.authType) {
+        case WebhookAuthType.basic:
+          requireCredential("username", config.username);
+          requireCredential(
+            "passwordCredentialId",
+            config.passwordCredentialId,
+          );
+          break;
+        case WebhookAuthType.header:
+          requireCredential("headerName", config.headerName);
+          requireCredential(
+            "headerValueCredentialId",
+            config.headerValueCredentialId,
+          );
+          break;
+        case WebhookAuthType.jwt:
+          requireCredential(
+            "jwtSecretCredentialId",
+            config.jwtSecretCredentialId,
+          );
+          break;
+        default:
+          break;
+      }
+    }),
+);
+
+export type WebhookTriggerConfig = z.infer<typeof webhookTriggerSchema>;
+
 export type WorkflowDefinitionParser = (definitionYml: string) => unknown;
 const workflowAliasMap = {
   currentVersionId: "currentVersion",
@@ -33,6 +137,10 @@ const workflowStubObjectSchema = baseStubSchema.extend({
   y: z.coerce.number(),
   zoom: z.coerce.number(),
   direction: directionTypeSchema,
+  webhookTrigger: preprocess(
+    nullishToNull,
+    webhookTriggerSchema.nullable(),
+  ).optional(),
 });
 const withWorkflowAliases = (value: unknown): unknown => {
   const original = toRecord(value);