@hexabot-ai/types 3.0.0-alpha.0

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

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

package/dist/esm/analytics/stats.js

@@ -0,0 +1,29 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2026 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+import { z } from "zod";
+import { baseStubSchema } from "../shared/base";
+export 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 || (StatsType = {}));
+const statsTypeSchema = z.enum(StatsType);
+const statsObjectSchema = baseStubSchema.extend({
+    type: statsTypeSchema,
+    day: z.coerce.date(),
+    value: z.coerce.number(),
+    name: z.string(),
+});
+export const statsStubSchema = statsObjectSchema;
+export const statsSchema = statsObjectSchema;
+export const statsFullSchema = statsObjectSchema;

package/dist/esm/attachment/attachment.js

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

package/dist/esm/attachment/index.js

@@ -0,0 +1,6 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2026 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+export { AttachmentAccess, AttachmentCreatedByRef, AttachmentResourceRef, attachmentFullSchema, attachmentOwnerSchema, attachmentSchema, attachmentStubSchema, } from "./attachment";

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

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

package/dist/esm/audit/index.js

@@ -0,0 +1,6 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2026 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+export { auditLogFullSchema, auditLogSchema, } from "./audit-log";

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

@@ -0,0 +1,12 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2026 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+import { z } from "zod";
+const jsonObjectSchema = z.record(z.string(), z.unknown());
+const channelMetadataObjectSchema = z.object({
+    name: z.string(),
+    settingsSchema: jsonObjectSchema,
+});
+export const channelMetadataSchema = channelMetadataObjectSchema;

package/dist/esm/channel/index.js

@@ -0,0 +1,8 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2026 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+export { sourceSchema, sourceStubSchema, } from "./source";
+export { sourceFullSchema } from "./source-full";
+export { channelMetadataSchema, } from "./channel-metadata";

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

@@ -0,0 +1,13 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2026 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+import { z } from "zod";
+import { withAliases } from "../shared/aliases";
+import { preprocess } from "../shared/preprocess";
+import { workflowSchema } from "../workflow/workflow";
+import { sourceAliasMap, sourceObjectSchema } from "./source";
+export const sourceFullSchema = preprocess((value) => withAliases(value, sourceAliasMap), sourceObjectSchema.extend({
+    defaultWorkflow: preprocess((value) => (value == null ? null : value), z.lazy(() => workflowSchema).nullable()),
+}));

package/dist/esm/channel/source.js

@@ -0,0 +1,22 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2026 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+import { z } from "zod";
+import { asId, withAliases } from "../shared/aliases";
+import { baseStubSchema } from "../shared/base";
+import { preprocess } from "../shared/preprocess";
+export const sourceAliasMap = {
+    defaultWorkflowId: "defaultWorkflow",
+};
+export const sourceObjectSchema = baseStubSchema.extend({
+    name: z.string(),
+    channel: z.string(),
+    settings: preprocess((value) => value && typeof value === "object" && !Array.isArray(value) ? value : {}, z.record(z.string(), z.unknown())),
+    state: z.coerce.boolean(),
+});
+export const sourceStubSchema = sourceObjectSchema;
+export const sourceSchema = preprocess((value) => withAliases(value, sourceAliasMap), sourceObjectSchema.extend({
+    defaultWorkflow: preprocess((value) => (value == null ? null : asId(value)), z.string().nullable()),
+}));

package/dist/esm/chat/attachment.js

@@ -0,0 +1,29 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2026 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+import { z } from "zod";
+export var FileType;
+(function (FileType) {
+    FileType["image"] = "image";
+    FileType["video"] = "video";
+    FileType["audio"] = "audio";
+    FileType["file"] = "file";
+    FileType["unknown"] = "unknown";
+})(FileType || (FileType = {}));
+export const fileTypeSchema = z.enum(FileType);
+export const attachmentRefSchema = z.union([
+    z.object({
+        id: z.string().nullable(),
+        url: z.string().optional(),
+    }),
+    z.object({
+        id: z.string().nullable().optional(),
+        url: z.string(),
+    }),
+]);
+export const attachmentPayloadSchema = z.object({
+    type: fileTypeSchema,
+    payload: attachmentRefSchema,
+});

package/dist/esm/chat/button.js

@@ -0,0 +1,67 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2026 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+import { z } from "zod";
+export var ButtonType;
+(function (ButtonType) {
+    ButtonType["postback"] = "postback";
+    ButtonType["web_url"] = "web_url";
+})(ButtonType || (ButtonType = {}));
+export const buttonSchema = z
+    .object({
+    type: z.enum([ButtonType.postback, ButtonType.web_url]).meta({
+        title: "Type",
+        description: "The type of button.",
+    }),
+    title: z.string().meta({
+        title: "Title",
+        description: "The label shown to the user.",
+    }),
+    payload: z.string().optional().meta({
+        title: "Payload",
+        description: "The value sent back when the button is clicked.",
+    }),
+    url: z
+        .union([z.url(), z.literal("")])
+        .optional()
+        .meta({
+        title: "URL",
+        description: "The destination URL opened when the button is clicked.",
+    }),
+    messenger_extensions: z.boolean().optional().meta({
+        title: "Messenger extensions",
+        description: "Whether to enable Messenger Extensions for the webview.",
+    }),
+    webview_height_ratio: 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: z.ZodIssueCode.custom,
+            path: ["payload"],
+            message: "Payload is required for postback buttons.",
+        });
+    }
+    if (button.type === ButtonType.web_url && !button.url) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ["url"],
+            message: "URL is required for web_url buttons.",
+        });
+    }
+});
+export 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 || (PayloadType = {}));

package/dist/esm/chat/index.js

@@ -0,0 +1,15 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2026 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+export { fileTypeSchema, attachmentRefSchema, attachmentPayloadSchema, FileType, } from "./attachment";
+export { buttonSchema, ButtonType, PayloadType, } from "./button";
+export { contentOptionsSchema, fallbackOptionsSchema, ActionOptionsSchema, } from "./options";
+export { coordinatesSchema, payloadSchema, stdQuickReplySchema, } from "./quick-reply";
+export { incomingMessageType, outgoingMessageTypeSchema, payloadTypeSchema, stdOutgoingTextMessageDataSchema, stdOutgoingQuickRepliesMessageDataSchema, stdOutgoingButtonsMessageDataSchema, stdOutgoingListMessageDataSchema, stdOutgoingAttachmentMessageDataSchema, stdOutgoingSystemMessageDataSchema, stdOutgoingTextMessageSchema, stdOutgoingQuickRepliesMessageSchema, stdOutgoingButtonsMessageSchema, contentElementSchema, contentPaginationSchema, stdOutgoingListMessageSchema, stdOutgoingCarouselMessageSchema, stdOutgoingAttachmentMessageSchema, stdOutgoingSystemMessageSchema, stdOutgoingMessageSchema, stdIncomingTextMessageDataSchema, stdIncomingPayloadMessageDataSchema, stdIncomingLocationMessageDataSchema, stdIncomingAttachmentMessageDataSchema, stdIncomingTextMessageSchema, stdIncomingPostBackMessageSchema, stdIncomingQuickReplyMessageSchema, stdIncomingLocationMessageSchema, stdIncomingAttachmentMessageSchema, stdIncomingMessageSchema, stdOutgoingTextEnvelopeSchema, stdOutgoingQuickRepliesEnvelopeSchema, stdOutgoingButtonsEnvelopeSchema, stdOutgoingListEnvelopeSchema, stdOutgoingAttachmentEnvelopeSchema, stdOutgoingSystemEnvelopeSchema, stdOutgoingMessageEnvelopeSchema, stdOutgoingEnvelopeSchema, IncomingMessageType, OutgoingMessageType, StdEventType, } from "./message-contract";
+export { labelGroupFullSchema, labelGroupSchema, labelGroupStubSchema, } from "./label-group";
+export { labelFullSchema, labelSchema, labelStubSchema, } from "./label";
+export { subscriberFullSchema, subscriberSchema, subscriberStubSchema, } from "./subscriber";
+export { threadFullSchema, threadSchema, threadStubSchema, } from "./thread";
+export { messageFullSchema, messageSchema, messageStubSchema, } from "./message";

package/dist/esm/chat/label-group.js

@@ -0,0 +1,19 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2026 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+import { z } from "zod";
+import { baseStubSchema } from "../shared/base";
+import { preprocess } from "../shared/preprocess";
+import { labelSchema } from "./label";
+const labelGroupObjectSchema = baseStubSchema.extend({
+    name: z.string(),
+});
+export const labelGroupStubSchema = labelGroupObjectSchema;
+export const labelGroupSchema = labelGroupObjectSchema.extend({
+    labels: preprocess(() => undefined, z.undefined().optional()).optional(),
+});
+export const labelGroupFullSchema = labelGroupObjectSchema.extend({
+    labels: preprocess((value) => (Array.isArray(value) ? value : []), z.array(z.lazy(() => labelSchema))).optional(),
+});

package/dist/esm/chat/label.js

@@ -0,0 +1,34 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2026 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+import { z } from "zod";
+import { asId, withAliases } from "../shared/aliases";
+import { baseStubSchema } from "../shared/base";
+import { preprocess } from "../shared/preprocess";
+import { labelGroupSchema } from "./label-group";
+import { subscriberSchema } from "./subscriber";
+const nullableOptionalStringSchema = z.string().nullable().optional();
+const labelAliasMap = {
+    groupId: "group",
+};
+const labelStubObjectSchema = baseStubSchema.extend({
+    title: z.string(),
+    name: z.string(),
+    label_id: z.record(z.string(), z.unknown()).nullable().optional(),
+    description: nullableOptionalStringSchema,
+    builtin: z.coerce.boolean(),
+});
+export const labelStubSchema = labelStubObjectSchema;
+export const labelSchema = preprocess((value) => withAliases(value, labelAliasMap), labelStubObjectSchema.extend({
+    group: preprocess((value) => (value == null ? null : asId(value)), z.string().nullable()).optional(),
+    users: preprocess(() => undefined, z.undefined().optional()).optional(),
+}));
+export const labelFullSchema = labelStubObjectSchema.extend({
+    users: preprocess((value) => (Array.isArray(value) ? value : []), z.array(z.lazy(() => subscriberSchema))).optional(),
+    group: z
+        .lazy(() => labelGroupSchema)
+        .nullable()
+        .optional(),
+});

package/dist/esm/chat/message-contract.js

@@ -0,0 +1,180 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2026 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+import { z } from "zod";
+import { attachmentPayloadSchema } from "./attachment";
+import { PayloadType, buttonSchema } from "./button";
+import { contentOptionsSchema } from "./options";
+import { stdQuickReplySchema } from "./quick-reply";
+export var StdEventType;
+(function (StdEventType) {
+    StdEventType["message"] = "message";
+    StdEventType["delivery"] = "delivery";
+    StdEventType["read"] = "read";
+    StdEventType["typing"] = "typing";
+    StdEventType["follow"] = "follow";
+    StdEventType["echo"] = "echo";
+    StdEventType["error"] = "error";
+    StdEventType["unknown"] = "";
+})(StdEventType || (StdEventType = {}));
+export var IncomingMessageType;
+(function (IncomingMessageType) {
+    IncomingMessageType["text"] = "text";
+    IncomingMessageType["postback"] = "postback";
+    IncomingMessageType["quickReply"] = "quickReply";
+    IncomingMessageType["location"] = "location";
+    IncomingMessageType["attachment"] = "attachment";
+    IncomingMessageType["unknown"] = "";
+})(IncomingMessageType || (IncomingMessageType = {}));
+export const incomingMessageType = z.enum(IncomingMessageType);
+export var OutgoingMessageType;
+(function (OutgoingMessageType) {
+    OutgoingMessageType["text"] = "text";
+    OutgoingMessageType["quickReply"] = "quickReply";
+    OutgoingMessageType["buttons"] = "buttons";
+    OutgoingMessageType["attachment"] = "attachment";
+    OutgoingMessageType["list"] = "list";
+    OutgoingMessageType["carousel"] = "carousel";
+    OutgoingMessageType["system"] = "system";
+})(OutgoingMessageType || (OutgoingMessageType = {}));
+export const outgoingMessageTypeSchema = z.enum(OutgoingMessageType);
+export const payloadTypeSchema = z.enum(PayloadType);
+export const stdOutgoingTextMessageDataSchema = z.object({
+    text: z.string(),
+});
+export const stdOutgoingQuickRepliesMessageDataSchema = z.object({
+    text: z.string(),
+    quickReplies: z.array(stdQuickReplySchema),
+});
+export const stdOutgoingButtonsMessageDataSchema = z.object({
+    text: z.string(),
+    buttons: z.array(buttonSchema),
+});
+export const contentElementSchema = z
+    .object({
+    id: z.string(),
+    title: z.string(),
+})
+    .catchall(z.any());
+export const contentPaginationSchema = z.object({
+    total: z.number(),
+    skip: z.number(),
+    limit: z.number(),
+});
+export const stdOutgoingListMessageDataSchema = z.object({
+    options: contentOptionsSchema,
+    elements: z.array(contentElementSchema),
+    pagination: contentPaginationSchema,
+});
+export const stdOutgoingAttachmentMessageDataSchema = z.object({
+    attachment: attachmentPayloadSchema,
+    quickReplies: z.array(stdQuickReplySchema).optional(),
+});
+export const stdOutgoingSystemMessageDataSchema = z.object({
+    outcome: z.string().optional(),
+    data: z.any().optional(),
+});
+export const stdOutgoingTextMessageSchema = z.object({
+    type: z.literal(OutgoingMessageType.text),
+    data: stdOutgoingTextMessageDataSchema,
+});
+export const stdOutgoingQuickRepliesMessageSchema = z.object({
+    type: z.literal(OutgoingMessageType.quickReply),
+    data: stdOutgoingQuickRepliesMessageDataSchema,
+});
+export const stdOutgoingButtonsMessageSchema = z.object({
+    type: z.literal(OutgoingMessageType.buttons),
+    data: stdOutgoingButtonsMessageDataSchema,
+});
+export const stdOutgoingListMessageSchema = z.object({
+    type: z.literal(OutgoingMessageType.list),
+    data: stdOutgoingListMessageDataSchema,
+});
+export const stdOutgoingCarouselMessageSchema = z.object({
+    type: z.literal(OutgoingMessageType.carousel),
+    data: stdOutgoingListMessageDataSchema,
+});
+export const stdOutgoingAttachmentMessageSchema = z.object({
+    type: z.literal(OutgoingMessageType.attachment),
+    data: stdOutgoingAttachmentMessageDataSchema,
+});
+export const stdOutgoingMessageSchema = z.discriminatedUnion("type", [
+    stdOutgoingTextMessageSchema,
+    stdOutgoingQuickRepliesMessageSchema,
+    stdOutgoingButtonsMessageSchema,
+    stdOutgoingListMessageSchema,
+    stdOutgoingCarouselMessageSchema,
+    stdOutgoingAttachmentMessageSchema,
+]);
+export const stdIncomingTextMessageDataSchema = z.object({
+    text: z.string(),
+});
+export const stdIncomingPayloadMessageDataSchema = z.object({
+    text: z.string(),
+    payload: z.string(),
+});
+export const stdIncomingLocationMessageDataSchema = z.object({
+    coordinates: z.object({
+        lat: z.number(),
+        lon: z.number(),
+    }),
+});
+export const stdIncomingAttachmentMessageDataSchema = z.object({
+    serializedText: z.string(),
+    attachment: z.union([
+        attachmentPayloadSchema,
+        z.array(attachmentPayloadSchema),
+    ]),
+});
+export const stdIncomingTextMessageSchema = z.object({
+    type: z.literal(IncomingMessageType.text),
+    data: stdIncomingTextMessageDataSchema,
+});
+export const stdIncomingPostBackMessageSchema = z.object({
+    type: z.literal(IncomingMessageType.postback),
+    data: stdIncomingPayloadMessageDataSchema,
+});
+export const stdIncomingQuickReplyMessageSchema = z.object({
+    type: z.literal(IncomingMessageType.quickReply),
+    data: stdIncomingPayloadMessageDataSchema,
+});
+export const stdIncomingLocationMessageSchema = z.object({
+    type: z.literal(IncomingMessageType.location),
+    data: stdIncomingLocationMessageDataSchema,
+});
+export const stdIncomingAttachmentMessageSchema = z.object({
+    type: z.literal(IncomingMessageType.attachment),
+    data: stdIncomingAttachmentMessageDataSchema,
+});
+export const stdIncomingMessageSchema = z.discriminatedUnion("type", [
+    stdIncomingTextMessageSchema,
+    stdIncomingPostBackMessageSchema,
+    stdIncomingQuickReplyMessageSchema,
+    stdIncomingLocationMessageSchema,
+    stdIncomingAttachmentMessageSchema,
+]);
+export const stdOutgoingTextEnvelopeSchema = stdOutgoingTextMessageSchema;
+export const stdOutgoingQuickRepliesEnvelopeSchema = stdOutgoingQuickRepliesMessageSchema;
+export const stdOutgoingButtonsEnvelopeSchema = stdOutgoingButtonsMessageSchema;
+export const stdOutgoingListEnvelopeSchema = z.discriminatedUnion("type", [
+    stdOutgoingListMessageSchema,
+    stdOutgoingCarouselMessageSchema,
+]);
+export const stdOutgoingAttachmentEnvelopeSchema = stdOutgoingAttachmentMessageSchema;
+export const stdOutgoingSystemMessageSchema = z.object({
+    type: z.literal(OutgoingMessageType.system),
+    data: stdOutgoingSystemMessageDataSchema,
+});
+export const stdOutgoingSystemEnvelopeSchema = stdOutgoingSystemMessageSchema;
+export const stdOutgoingMessageEnvelopeSchema = stdOutgoingMessageSchema;
+export const stdOutgoingEnvelopeSchema = z.discriminatedUnion("type", [
+    stdOutgoingTextMessageSchema,
+    stdOutgoingQuickRepliesMessageSchema,
+    stdOutgoingButtonsMessageSchema,
+    stdOutgoingListMessageSchema,
+    stdOutgoingCarouselMessageSchema,
+    stdOutgoingAttachmentMessageSchema,
+    stdOutgoingSystemMessageSchema,
+]);

package/dist/esm/chat/message.js

@@ -0,0 +1,104 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2026 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+import { z } from "zod";
+import { asId, withAliases } from "../shared/aliases";
+import { baseStubSchema } from "../shared/base";
+import { preprocess } from "../shared/preprocess";
+import { userSchema } from "../user/user";
+import { IncomingMessageType, OutgoingMessageType, stdOutgoingMessageSchema, stdIncomingMessageSchema, } from "./message-contract";
+import { subscriberSchema } from "./subscriber";
+import { threadSchema } from "./thread";
+const messageAliasMap = {
+    senderId: "sender",
+    recipientId: "recipient",
+    sentById: "sentBy",
+    threadId: "thread",
+};
+const incomingOnlyTypes = new Set([
+    IncomingMessageType.postback,
+    IncomingMessageType.location,
+]);
+const outgoingOnlyTypes = new Set([
+    OutgoingMessageType.buttons,
+    OutgoingMessageType.list,
+    OutgoingMessageType.carousel,
+    OutgoingMessageType.system,
+]);
+const invalidDirectionMessage = {
+    type: "__invalidDirection__",
+    data: null,
+};
+const parseByDirection = (message, record) => {
+    const hasSender = record.sender != null;
+    const hasRecipient = record.recipient != null;
+    const hasSentBy = record.sentBy != null;
+    const shouldUseOutgoingSchema = hasRecipient || hasSentBy;
+    const shouldUseIncomingSchema = hasSender && !shouldUseOutgoingSchema;
+    if (shouldUseOutgoingSchema) {
+        const parsed = stdOutgoingMessageSchema.safeParse(message);
+        return parsed.success ? parsed.data : invalidDirectionMessage;
+    }
+    if (shouldUseIncomingSchema) {
+        const parsed = stdIncomingMessageSchema.safeParse(message);
+        return parsed.success ? parsed.data : invalidDirectionMessage;
+    }
+    const type = typeof message === "object" && message !== null
+        ? message.type
+        : undefined;
+    if (typeof type !== "string") {
+        const parsed = messagePayloadSchema.safeParse(message);
+        return parsed.success ? parsed.data : message;
+    }
+    if (incomingOnlyTypes.has(type)) {
+        const parsed = stdIncomingMessageSchema.safeParse(message);
+        return parsed.success ? parsed.data : message;
+    }
+    if (outgoingOnlyTypes.has(type)) {
+        const parsed = stdOutgoingMessageSchema.safeParse(message);
+        return parsed.success ? parsed.data : message;
+    }
+    const parsed = messagePayloadSchema.safeParse(message);
+    return parsed.success ? parsed.data : message;
+};
+const normalizeMessageRecord = (value) => {
+    const normalized = withAliases(value, messageAliasMap);
+    if (typeof normalized !== "object" ||
+        normalized === null ||
+        !("message" in normalized)) {
+        return normalized;
+    }
+    const record = normalized;
+    record.message = parseByDirection(record.message, record);
+    return record;
+};
+const messagePayloadSchema = z.union([
+    stdIncomingMessageSchema,
+    stdOutgoingMessageSchema,
+]);
+const messageStubObjectSchema = baseStubSchema.extend({
+    mid: z.string().optional(),
+    message: messagePayloadSchema,
+    read: z.coerce.boolean(),
+    delivery: z.coerce.boolean(),
+    handover: z.coerce.boolean(),
+});
+export const messageStubSchema = messageStubObjectSchema;
+export const messageSchema = preprocess(normalizeMessageRecord, messageStubObjectSchema.extend({
+    sender: preprocess((value) => (value == null ? null : asId(value)), z.string().nullable()).optional(),
+    recipient: preprocess((value) => (value == null ? null : asId(value)), z.string().nullable()).optional(),
+    sentBy: preprocess((value) => (value == null ? null : asId(value)), z.string().nullable()).optional(),
+    thread: preprocess((value) => (value == null ? null : asId(value)), z.string()),
+}));
+const messageFullObjectSchema = messageStubObjectSchema.extend({
+    sender: subscriberSchema.nullable().optional(),
+    recipient: subscriberSchema.nullable().optional(),
+    sentBy: z
+        .lazy(() => userSchema)
+        .nullable()
+        .optional(),
+    thread: threadSchema,
+});
+export const messageFullSchema = preprocess(normalizeMessageRecord, messageFullObjectSchema);