@hexabot-ai/types 3.0.0-alpha.0

package/LICENSE.md

@@ -0,0 +1,120 @@
+# Fair Core License, Version 1.0, ALv2 Future License
+
+## Abbreviation
+
+FCL-1.0-ALv2
+
+## Notice
+
+Copyright 2025 Hexastack
+
+## Terms and Conditions
+
+### Licensor ("We")
+
+The party offering the Software under these Terms and Conditions.
+
+### The Software
+
+The "Software" is each version of the software that we make available under
+these Terms and Conditions, as indicated by our inclusion of these Terms and
+Conditions with the Software.
+
+### License Grant
+
+Subject to your compliance with this License Grant and the Limitations,
+Patents, Redistribution and Trademark clauses below, we hereby grant you the
+right to use, copy, modify, create derivative works, publicly perform, publicly
+display and redistribute the Software for any Permitted Purpose identified
+below.
+
+### Permitted Purpose
+
+A Permitted Purpose is any purpose other than a Competing Use. A Competing Use
+means making the Software available to others in a commercial product or
+service that:
+
+1. substitutes for the Software;
+
+2. substitutes for any other product or service we offer using the Software
+   that exists as of the date we make the Software available; or
+
+3. offers the same or substantially similar functionality as the Software.
+
+Permitted Purposes specifically include using the Software:
+
+1. for your internal use and access;
+
+2. for non-commercial education;
+
+3. for non-commercial research; and
+
+4. in connection with professional services that you provide to a licensee
+   using the Software in accordance with these Terms and Conditions.
+
+### Limitations
+
+You must not move, change, disable, or circumvent the license key functionality
+in the Software; or modify any portion of the Software protected by the license
+key to:
+
+1. enable access to the protected functionality without a valid license key; or
+
+2. remove the protected functionality.
+
+### Patents
+
+To the extent your use for a Permitted Purpose would necessarily infringe our
+patents, the license grant above includes a license under our patents. If you
+make a claim against any party that the Software infringes or contributes to
+the infringement of any patent, then your patent license to the Software ends
+immediately.
+
+### Redistribution
+
+The Terms and Conditions apply to all copies, modifications and derivatives of
+the Software.
+
+If you redistribute any copies, modifications or derivatives of the Software,
+you must include a copy of or a link to these Terms and Conditions and not
+remove any copyright or other proprietary notices provided in or with the
+Software.
+
+### Disclaimer
+
+THE SOFTWARE IS PROVIDED "AS IS" AND WITHOUT WARRANTIES OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING WITHOUT LIMITATION WARRANTIES OF FITNESS FOR A PARTICULAR
+PURPOSE, MERCHANTABILITY, TITLE OR NON-INFRINGEMENT.
+
+IN NO EVENT WILL WE HAVE ANY LIABILITY TO YOU ARISING OUT OF OR RELATED TO THE
+SOFTWARE, INCLUDING INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES,
+EVEN IF WE HAVE BEEN INFORMED OF THEIR POSSIBILITY IN ADVANCE.
+
+In the event the provision of this Disclaimer section is unenforceable under
+applicable law, the licenses granted herein are void.
+
+### Trademarks
+
+Except for displaying the License Details and identifying us as the origin of
+the Software, you have no right under these Terms and Conditions to use our
+trademarks, trade names, service marks or product names.
+
+## Grant of Future License
+
+We hereby irrevocably grant you an additional license to use the Software,
+under the Apache License, Version 2.0, that is effective on the second
+anniversary of the date we make the Software available. On or after that date,
+you may use the Software under the Apache License, Version 2.0, in which case
+the following will apply:
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use
+this file except in compliance with the License.
+
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed
+under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+CONDITIONS OF ANY KIND, either express or implied. See the License for the
+specific language governing permissions and limitations under the License.

package/README.md

@@ -0,0 +1,172 @@
+# @hexabot-ai/types
+
+Shared zod-first runtime contracts for Hexabot API entity outputs.
+
+## Migrated Modules
+
+- `analytics`: `Stats*`, `IntegrationHealth*`
+- `audit`: `AuditLog*`
+- `channel`: `Source*`, `ChannelMetadata*`
+- `chat`: `LabelGroup*`, `Label*`, `Subscriber*`, `Thread*`, `Message*`
+- `cms`: `ContentType*`, `Content*`, `Menu*`
+- `i18n`: `Language*`, `Translation*`
+- `setting`: `Setting*`, `Metadata*`
+- `user`: `UserProfile*`, `Model*`, `Permission*`, `Role*`, `Credential*`, `User*`
+- `workflow`: `Workflow*`, `WorkflowVersion*`, `WorkflowRun*`, `MemoryDefinition*`, `MemoryRecord*`, `McpServer*`
+- `utils/test/dummy`: `Dummy*`
+- `attachment`: `Attachment*`
+
+`AuditLog` includes nullable `actorLabel` and `resourceLabel` display fields in
+addition to the stable actor/resource identifiers.
+
+## Standard Export Pattern
+
+Each migrated entity exposes:
+
+- `*StubSchema`, `*Schema`, `*FullSchema`
+- `type *Stub`, `type *`, `type *Full`
+
+Example:
+
+```ts
+import {
+  subscriberFullSchema,
+  type SubscriberFull,
+} from "@hexabot-ai/types";
+
+const payload: SubscriberFull = subscriberFullSchema.parse(data);
+```
+
+## Shared Chat Message Contracts
+
+Chat message contracts are centralized in `@hexabot-ai/types` and are strictly discriminator-based.
+
+```ts
+import {
+  ActionOptionsSchema,
+  ButtonType,
+  FileType,
+  IncomingMessageType,
+  OutgoingMessageType,
+  stdOutgoingMessageSchema,
+  attachmentPayloadSchema,
+  messageSchema,
+  stdIncomingMessageSchema,
+  stdOutgoingEnvelopeSchema,
+} from "@hexabot-ai/types";
+```
+
+### Outgoing Contract (`StdOutgoingMessage`)
+
+All outgoing messages use:
+
+- `{ type, data }`
+
+`type` discriminator variants:
+
+- `text`: `data = { text }`
+- `quickReply`: `data = { text, quickReplies }`
+- `buttons`: `data = { text, buttons }`
+- `attachment`: `data = { attachment, quickReplies? }`
+- `list`: `data = { options, elements, pagination }`
+- `carousel`: `data = { options, elements, pagination }`
+
+Example:
+
+```ts
+const outgoing = stdOutgoingMessageSchema.parse({
+  type: OutgoingMessageType.quickReply,
+  data: {
+    text: "Choose one",
+    quickReplies: [{ title: "Yes", payload: "yes" }],
+  },
+});
+```
+
+### Incoming Contract (`StdIncomingMessage`)
+
+All incoming messages use:
+
+- `{ type, data }`
+
+`type` discriminator variants:
+
+- `text`: `data = { text }`
+- `postback`: `data = { text, payload }`
+- `quickReply`: `data = { text, payload }`
+- `location`: `data = { coordinates: { lat, lon } }`
+- `attachment`: `data = { serializedText, attachment }`
+  `attachment` can be a single attachment or an array.
+
+Example:
+
+```ts
+const incoming = stdIncomingMessageSchema.parse({
+  type: IncomingMessageType.location,
+  data: {
+    coordinates: { lat: 36.8, lon: 10.2 },
+  },
+});
+```
+
+### Envelopes and Persistence
+
+- `StdOutgoingMessageEnvelope` is the same contract as `StdOutgoingMessage` (`{ type, data }`).
+- `StdOutgoingEnvelope` adds the system envelope variant:
+  - `type: OutgoingMessageType.system`
+  - `data: { outcome?: string; data?: unknown }`
+- Persisted chat message entities (`messageSchema`) validate `message` as:
+  - `StdIncomingMessage | StdOutgoingMessage`
+
+Legacy flat payloads and alias-based message shapes are intentionally unsupported.
+
+## Workflow Parser Bridge
+
+Use a parser-aware full workflow schema to preserve `definitionYml` and `definition` derivation:
+
+```ts
+import { createWorkflowFullSchema } from "@hexabot-ai/types";
+
+const workflow = createWorkflowFullSchema({
+  parseDefinition: (definitionYml) => {
+    // API-side parser with binding-aware validation
+    return parseWorkflowDefinition(definitionYml);
+  },
+}).parse(data);
+```
+
+You can also build a reusable schema:
+
+```ts
+import { createWorkflowFullSchema } from "@hexabot-ai/types";
+
+const schema = createWorkflowFullSchema({ parseDefinition });
+const workflow = schema.parse(data);
+```
+
+## Alias Compatibility
+
+Common ORM alias mappings from legacy class-transformer DTOs are preserved, including:
+
+- `groupId`, `contentTypeId`, `parentId`
+- `sourceId`, `defaultWorkflowId`
+- `subscriberId`, `senderId`, `recipientId`, `sentById`, `threadId`
+- `ownerId`, `modelId`, `roleId`, `credentialId`
+- `currentVersionId`, `publishedVersionId`, `createdById`
+- `workflowId`, `workflowVersionId`, `triggeredById`
+- `definitionId`, `runId`
+
+Unknown keys are stripped by default.
+
+## Compatibility Notes
+
+- Legacy API enum/type paths can re-export from this package without value changes.
+- Schema parsing preserves nullable/optional normalization used by API entity outputs.
+- Mixed owner/triggeredBy contracts (`Subscriber | User`) are supported in workflow full contracts.
+- Sensitive output parity is preserved for credentials (`value` is not part of output contracts).
+
+## Breaking-Change Notes
+
+- Runtime DTO output classes are replaced by zod schemas + inferred TS types.
+- `@Type(() => OutputClass)` patterns should be replaced by direct zod schema parsing.
+- Consumers that previously instantiated output DTO classes (`new X()`) must use plain objects typed by exported `type X`.

package/dist/cjs/analytics/index.js

@@ -0,0 +1,18 @@
+"use strict";
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2026 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.statsStubSchema = exports.statsSchema = exports.statsFullSchema = exports.StatsType = exports.integrationHealthStatusSchema = exports.integrationHealthResponseSchema = exports.integrationHealthKindSchema = exports.integrationHealthItemSchema = void 0;
+var integration_health_1 = require("./integration-health");
+Object.defineProperty(exports, "integrationHealthItemSchema", { enumerable: true, get: function () { return integration_health_1.integrationHealthItemSchema; } });
+Object.defineProperty(exports, "integrationHealthKindSchema", { enumerable: true, get: function () { return integration_health_1.integrationHealthKindSchema; } });
+Object.defineProperty(exports, "integrationHealthResponseSchema", { enumerable: true, get: function () { return integration_health_1.integrationHealthResponseSchema; } });
+Object.defineProperty(exports, "integrationHealthStatusSchema", { enumerable: true, get: function () { return integration_health_1.integrationHealthStatusSchema; } });
+var stats_1 = require("./stats");
+Object.defineProperty(exports, "StatsType", { enumerable: true, get: function () { return stats_1.StatsType; } });
+Object.defineProperty(exports, "statsFullSchema", { enumerable: true, get: function () { return stats_1.statsFullSchema; } });
+Object.defineProperty(exports, "statsSchema", { enumerable: true, get: function () { return stats_1.statsSchema; } });
+Object.defineProperty(exports, "statsStubSchema", { enumerable: true, get: function () { return stats_1.statsStubSchema; } });

package/dist/cjs/analytics/integration-health.js

@@ -0,0 +1,30 @@
+"use strict";
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2026 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.integrationHealthResponseSchema = exports.integrationHealthItemSchema = exports.integrationHealthKindSchema = exports.integrationHealthStatusSchema = void 0;
+const zod_1 = require("zod");
+exports.integrationHealthStatusSchema = zod_1.z.enum([
+    "healthy",
+    "warning",
+    "unhealthy",
+    "disabled",
+]);
+exports.integrationHealthKindSchema = zod_1.z.enum(["channel", "service"]);
+exports.integrationHealthItemSchema = zod_1.z.object({
+    id: zod_1.z.string(),
+    kind: exports.integrationHealthKindSchema,
+    name: zod_1.z.string(),
+    status: exports.integrationHealthStatusSchema,
+    checkedAt: zod_1.z.string().datetime({ offset: true }),
+    reason: zod_1.z.string().optional(),
+    message: zod_1.z.string().optional(),
+    details: zod_1.z.record(zod_1.z.string(), zod_1.z.unknown()).optional(),
+});
+exports.integrationHealthResponseSchema = zod_1.z.object({
+    checkedAt: zod_1.z.string().datetime({ offset: true }),
+    integrations: zod_1.z.array(exports.integrationHealthItemSchema),
+});

package/dist/cjs/analytics/stats.js

@@ -0,0 +1,32 @@
+"use strict";
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2026 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.statsFullSchema = exports.statsSchema = exports.statsStubSchema = exports.StatsType = void 0;
+const zod_1 = require("zod");
+const base_1 = require("../shared/base");
+var StatsType;
+(function (StatsType) {
+    StatsType["outgoing"] = "outgoing";
+    StatsType["new_users"] = "new_users";
+    StatsType["all_messages"] = "all_messages";
+    StatsType["incoming"] = "incoming";
+    StatsType["returning_users"] = "returning_users";
+    StatsType["retention"] = "retention";
+    StatsType["echo"] = "echo";
+    StatsType["new_threads"] = "new_threads";
+    StatsType["handoffs"] = "handoffs";
+})(StatsType || (exports.StatsType = StatsType = {}));
+const statsTypeSchema = zod_1.z.enum(StatsType);
+const statsObjectSchema = base_1.baseStubSchema.extend({
+    type: statsTypeSchema,
+    day: zod_1.z.coerce.date(),
+    value: zod_1.z.coerce.number(),
+    name: zod_1.z.string(),
+});
+exports.statsStubSchema = statsObjectSchema;
+exports.statsSchema = statsObjectSchema;
+exports.statsFullSchema = statsObjectSchema;

package/dist/cjs/attachment/attachment.js

@@ -0,0 +1,53 @@
+"use strict";
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2026 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.attachmentFullSchema = exports.attachmentSchema = exports.attachmentStubSchema = exports.attachmentOwnerSchema = exports.AttachmentAccess = exports.AttachmentResourceRef = exports.AttachmentCreatedByRef = void 0;
+const zod_1 = require("zod");
+const aliases_1 = require("../shared/aliases");
+const base_1 = require("../shared/base");
+const preprocess_1 = require("../shared/preprocess");
+const user_profile_assigned_1 = require("../user/user-profile-assigned");
+var AttachmentCreatedByRef;
+(function (AttachmentCreatedByRef) {
+    AttachmentCreatedByRef["User"] = "User";
+    AttachmentCreatedByRef["Subscriber"] = "Subscriber";
+})(AttachmentCreatedByRef || (exports.AttachmentCreatedByRef = AttachmentCreatedByRef = {}));
+var AttachmentResourceRef;
+(function (AttachmentResourceRef) {
+    AttachmentResourceRef["SettingAttachment"] = "Setting";
+    AttachmentResourceRef["UserAvatar"] = "User";
+    AttachmentResourceRef["SubscriberAvatar"] = "Subscriber";
+    AttachmentResourceRef["ContentAttachment"] = "Content";
+    AttachmentResourceRef["MessageAttachment"] = "Message";
+})(AttachmentResourceRef || (exports.AttachmentResourceRef = AttachmentResourceRef = {}));
+var AttachmentAccess;
+(function (AttachmentAccess) {
+    AttachmentAccess["Public"] = "public";
+    AttachmentAccess["Private"] = "private";
+})(AttachmentAccess || (exports.AttachmentAccess = AttachmentAccess = {}));
+const attachmentAliasMap = {
+    createdById: "createdBy",
+};
+exports.attachmentOwnerSchema = user_profile_assigned_1.userProfileAssignedSchema;
+const attachmentStubObjectSchema = base_1.baseStubSchema.extend({
+    name: zod_1.z.string(),
+    type: zod_1.z.string(),
+    size: zod_1.z.coerce.number(),
+    location: zod_1.z.string(),
+    channel: (0, preprocess_1.preprocess)((value) => (value == null ? undefined : value), zod_1.z.record(zod_1.z.string(), zod_1.z.unknown()).optional()).optional(),
+    createdByRef: zod_1.z.enum(AttachmentCreatedByRef).optional(),
+    resourceRef: zod_1.z.enum(AttachmentResourceRef),
+    access: zod_1.z.enum(AttachmentAccess),
+    url: (0, preprocess_1.preprocess)((value) => (value == null ? "" : value), zod_1.z.string()),
+});
+exports.attachmentStubSchema = attachmentStubObjectSchema;
+exports.attachmentSchema = (0, preprocess_1.preprocess)((value) => (0, aliases_1.withAliases)(value, attachmentAliasMap), attachmentStubObjectSchema.extend({
+    createdBy: (0, preprocess_1.preprocess)((value) => (value == null ? null : (0, aliases_1.asId)(value)), zod_1.z.string().nullable()).optional(),
+}));
+exports.attachmentFullSchema = attachmentStubObjectSchema.extend({
+    createdBy: exports.attachmentOwnerSchema.nullable().optional(),
+});

package/dist/cjs/attachment/index.js

@@ -0,0 +1,16 @@
+"use strict";
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2026 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.attachmentStubSchema = exports.attachmentSchema = exports.attachmentOwnerSchema = exports.attachmentFullSchema = exports.AttachmentResourceRef = exports.AttachmentCreatedByRef = exports.AttachmentAccess = void 0;
+var attachment_1 = require("./attachment");
+Object.defineProperty(exports, "AttachmentAccess", { enumerable: true, get: function () { return attachment_1.AttachmentAccess; } });
+Object.defineProperty(exports, "AttachmentCreatedByRef", { enumerable: true, get: function () { return attachment_1.AttachmentCreatedByRef; } });
+Object.defineProperty(exports, "AttachmentResourceRef", { enumerable: true, get: function () { return attachment_1.AttachmentResourceRef; } });
+Object.defineProperty(exports, "attachmentFullSchema", { enumerable: true, get: function () { return attachment_1.attachmentFullSchema; } });
+Object.defineProperty(exports, "attachmentOwnerSchema", { enumerable: true, get: function () { return attachment_1.attachmentOwnerSchema; } });
+Object.defineProperty(exports, "attachmentSchema", { enumerable: true, get: function () { return attachment_1.attachmentSchema; } });
+Object.defineProperty(exports, "attachmentStubSchema", { enumerable: true, get: function () { return attachment_1.attachmentStubSchema; } });

package/dist/cjs/audit/audit-log.js

@@ -0,0 +1,33 @@
+"use strict";
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2026 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.auditLogFullSchema = exports.auditLogSchema = void 0;
+const zod_1 = require("zod");
+const base_1 = require("../shared/base");
+const preprocess_1 = require("../shared/preprocess");
+const nullableRecordSchema = (0, preprocess_1.preprocess)((value) => (value == null ? null : value), zod_1.z.unknown().nullable());
+exports.auditLogSchema = base_1.baseStubSchema.extend({
+    resourceId: zod_1.z.string(),
+    resourceType: zod_1.z.string(),
+    resourceLabel: zod_1.z.string().nullable(),
+    operationId: zod_1.z.string(),
+    operationType: zod_1.z.string(),
+    operationStatus: zod_1.z.enum(["UNSPECIFIED", "SUCCEEDED", "FAILED"]),
+    actorId: zod_1.z.string(),
+    actorType: zod_1.z.string(),
+    actorLabel: zod_1.z.string().nullable(),
+    actorIp: zod_1.z.string().nullable(),
+    actorAgent: zod_1.z.string().nullable(),
+    requestId: zod_1.z.string().nullable(),
+    requestMethod: zod_1.z.string().nullable(),
+    requestPath: zod_1.z.string().nullable(),
+    dataBefore: nullableRecordSchema,
+    dataAfter: nullableRecordSchema,
+    dataDiff: nullableRecordSchema,
+    raw: nullableRecordSchema,
+});
+exports.auditLogFullSchema = exports.auditLogSchema;

package/dist/cjs/audit/index.js

@@ -0,0 +1,11 @@
+"use strict";
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2026 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.auditLogSchema = exports.auditLogFullSchema = void 0;
+var audit_log_1 = require("./audit-log");
+Object.defineProperty(exports, "auditLogFullSchema", { enumerable: true, get: function () { return audit_log_1.auditLogFullSchema; } });
+Object.defineProperty(exports, "auditLogSchema", { enumerable: true, get: function () { return audit_log_1.auditLogSchema; } });

package/dist/cjs/channel/channel-metadata.js

@@ -0,0 +1,15 @@
+"use strict";
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2026 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.channelMetadataSchema = void 0;
+const zod_1 = require("zod");
+const jsonObjectSchema = zod_1.z.record(zod_1.z.string(), zod_1.z.unknown());
+const channelMetadataObjectSchema = zod_1.z.object({
+    name: zod_1.z.string(),
+    settingsSchema: jsonObjectSchema,
+});
+exports.channelMetadataSchema = channelMetadataObjectSchema;

package/dist/cjs/channel/index.js

@@ -0,0 +1,15 @@
+"use strict";
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2026 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.channelMetadataSchema = exports.sourceFullSchema = exports.sourceStubSchema = exports.sourceSchema = void 0;
+var source_1 = require("./source");
+Object.defineProperty(exports, "sourceSchema", { enumerable: true, get: function () { return source_1.sourceSchema; } });
+Object.defineProperty(exports, "sourceStubSchema", { enumerable: true, get: function () { return source_1.sourceStubSchema; } });
+var source_full_1 = require("./source-full");
+Object.defineProperty(exports, "sourceFullSchema", { enumerable: true, get: function () { return source_full_1.sourceFullSchema; } });
+var channel_metadata_1 = require("./channel-metadata");
+Object.defineProperty(exports, "channelMetadataSchema", { enumerable: true, get: function () { return channel_metadata_1.channelMetadataSchema; } });

package/dist/cjs/channel/source-full.js

@@ -0,0 +1,16 @@
+"use strict";
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2026 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sourceFullSchema = void 0;
+const zod_1 = require("zod");
+const aliases_1 = require("../shared/aliases");
+const preprocess_1 = require("../shared/preprocess");
+const workflow_1 = require("../workflow/workflow");
+const source_1 = require("./source");
+exports.sourceFullSchema = (0, preprocess_1.preprocess)((value) => (0, aliases_1.withAliases)(value, source_1.sourceAliasMap), source_1.sourceObjectSchema.extend({
+    defaultWorkflow: (0, preprocess_1.preprocess)((value) => (value == null ? null : value), zod_1.z.lazy(() => workflow_1.workflowSchema).nullable()),
+}));

package/dist/cjs/channel/source.js

@@ -0,0 +1,25 @@
+"use strict";
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2026 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sourceSchema = exports.sourceStubSchema = exports.sourceObjectSchema = exports.sourceAliasMap = void 0;
+const zod_1 = require("zod");
+const aliases_1 = require("../shared/aliases");
+const base_1 = require("../shared/base");
+const preprocess_1 = require("../shared/preprocess");
+exports.sourceAliasMap = {
+    defaultWorkflowId: "defaultWorkflow",
+};
+exports.sourceObjectSchema = base_1.baseStubSchema.extend({
+    name: zod_1.z.string(),
+    channel: zod_1.z.string(),
+    settings: (0, preprocess_1.preprocess)((value) => value && typeof value === "object" && !Array.isArray(value) ? value : {}, zod_1.z.record(zod_1.z.string(), zod_1.z.unknown())),
+    state: zod_1.z.coerce.boolean(),
+});
+exports.sourceStubSchema = exports.sourceObjectSchema;
+exports.sourceSchema = (0, preprocess_1.preprocess)((value) => (0, aliases_1.withAliases)(value, exports.sourceAliasMap), exports.sourceObjectSchema.extend({
+    defaultWorkflow: (0, preprocess_1.preprocess)((value) => (value == null ? null : (0, aliases_1.asId)(value)), zod_1.z.string().nullable()),
+}));

package/dist/cjs/chat/attachment.js

@@ -0,0 +1,32 @@
+"use strict";
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2026 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.attachmentPayloadSchema = exports.attachmentRefSchema = exports.fileTypeSchema = exports.FileType = void 0;
+const zod_1 = require("zod");
+var FileType;
+(function (FileType) {
+    FileType["image"] = "image";
+    FileType["video"] = "video";
+    FileType["audio"] = "audio";
+    FileType["file"] = "file";
+    FileType["unknown"] = "unknown";
+})(FileType || (exports.FileType = FileType = {}));
+exports.fileTypeSchema = zod_1.z.enum(FileType);
+exports.attachmentRefSchema = zod_1.z.union([
+    zod_1.z.object({
+        id: zod_1.z.string().nullable(),
+        url: zod_1.z.string().optional(),
+    }),
+    zod_1.z.object({
+        id: zod_1.z.string().nullable().optional(),
+        url: zod_1.z.string(),
+    }),
+]);
+exports.attachmentPayloadSchema = zod_1.z.object({
+    type: exports.fileTypeSchema,
+    payload: exports.attachmentRefSchema,
+});

package/dist/cjs/chat/button.js

@@ -0,0 +1,70 @@
+"use strict";
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2026 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PayloadType = exports.buttonSchema = exports.ButtonType = void 0;
+const zod_1 = require("zod");
+var ButtonType;
+(function (ButtonType) {
+    ButtonType["postback"] = "postback";
+    ButtonType["web_url"] = "web_url";
+})(ButtonType || (exports.ButtonType = ButtonType = {}));
+exports.buttonSchema = zod_1.z
+    .object({
+    type: zod_1.z.enum([ButtonType.postback, ButtonType.web_url]).meta({
+        title: "Type",
+        description: "The type of button.",
+    }),
+    title: zod_1.z.string().meta({
+        title: "Title",
+        description: "The label shown to the user.",
+    }),
+    payload: zod_1.z.string().optional().meta({
+        title: "Payload",
+        description: "The value sent back when the button is clicked.",
+    }),
+    url: zod_1.z
+        .union([zod_1.z.url(), zod_1.z.literal("")])
+        .optional()
+        .meta({
+        title: "URL",
+        description: "The destination URL opened when the button is clicked.",
+    }),
+    messenger_extensions: zod_1.z.boolean().optional().meta({
+        title: "Messenger extensions",
+        description: "Whether to enable Messenger Extensions for the webview.",
+    }),
+    webview_height_ratio: zod_1.z.enum(["compact", "tall", "full"]).optional().meta({
+        title: "Webview height ratio",
+        description: "The height of the webview.",
+    }),
+})
+    .superRefine((button, ctx) => {
+    if (button.type === ButtonType.postback && !button.payload) {
+        ctx.addIssue({
+            code: zod_1.z.ZodIssueCode.custom,
+            path: ["payload"],
+            message: "Payload is required for postback buttons.",
+        });
+    }
+    if (button.type === ButtonType.web_url && !button.url) {
+        ctx.addIssue({
+            code: zod_1.z.ZodIssueCode.custom,
+            path: ["url"],
+            message: "URL is required for web_url buttons.",
+        });
+    }
+});
+var PayloadType;
+(function (PayloadType) {
+    PayloadType["location"] = "location";
+    PayloadType["attachment"] = "attachment";
+    PayloadType["quickReply"] = "quickReply";
+    PayloadType["button"] = "button";
+    PayloadType["outcome"] = "outcome";
+    PayloadType["menu"] = "menu";
+    PayloadType["content"] = "content";
+})(PayloadType || (exports.PayloadType = PayloadType = {}));