@hexabot-ai/types 3.0.0-alpha.0

package/src/analytics/stats.ts

@@ -0,0 +1,41 @@
+/*
+ * 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 enum StatsType {
+  outgoing = "outgoing",
+  new_users = "new_users",
+  all_messages = "all_messages",
+  incoming = "incoming",
+  returning_users = "returning_users",
+  retention = "retention",
+  echo = "echo",
+  new_threads = "new_threads",
+  handoffs = "handoffs",
+}
+
+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;
+
+export type StatsStub = z.infer<typeof statsStubSchema>;
+
+export type Stats = z.infer<typeof statsSchema>;
+
+export type StatsFull = z.infer<typeof statsFullSchema>;

package/src/attachment/attachment.ts

@@ -0,0 +1,75 @@
+/*
+ * 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 enum AttachmentCreatedByRef {
+  User = "User",
+  Subscriber = "Subscriber",
+}
+
+export enum AttachmentResourceRef {
+  SettingAttachment = "Setting",
+  UserAvatar = "User",
+  SubscriberAvatar = "Subscriber",
+  ContentAttachment = "Content",
+  MessageAttachment = "Message",
+}
+
+export enum AttachmentAccess {
+  Public = "public",
+  Private = "private",
+}
+
+const attachmentAliasMap = {
+  createdById: "createdBy",
+} as const;
+
+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(),
+});
+
+export type AttachmentOwner = z.infer<typeof attachmentOwnerSchema>;
+
+export type AttachmentStub = z.infer<typeof attachmentStubSchema>;
+
+export type Attachment = z.infer<typeof attachmentSchema>;
+
+export type AttachmentFull = z.infer<typeof attachmentFullSchema>;

package/src/attachment/index.ts

@@ -0,0 +1,19 @@
+/*
+ * 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,
+  type Attachment,
+  type AttachmentFull,
+  type AttachmentOwner,
+  type AttachmentStub,
+} from "./attachment";

package/src/audit/audit-log.ts

@@ -0,0 +1,42 @@
+/*
+ * 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;
+
+export type AuditLog = z.infer<typeof auditLogSchema>;
+
+export type AuditLogFull = z.infer<typeof auditLogFullSchema>;

package/src/audit/index.ts

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

package/src/channel/channel-metadata.ts

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

package/src/channel/index.ts

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

package/src/channel/source-full.ts

@@ -0,0 +1,25 @@
+/*
+ * 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(),
+    ),
+  }),
+);
+
+export type SourceFull = z.infer<typeof sourceFullSchema>;

package/src/channel/source.ts

@@ -0,0 +1,42 @@
+/*
+ * 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",
+} as const;
+
+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(),
+    ),
+  }),
+);
+
+export type SourceStub = z.infer<typeof sourceStubSchema>;
+
+export type Source = z.infer<typeof sourceSchema>;

package/src/chat/attachment.ts

@@ -0,0 +1,44 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2026 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+
+import { z } from "zod";
+
+export enum FileType {
+  image = "image",
+  video = "video",
+  audio = "audio",
+  file = "file",
+  unknown = "unknown",
+}
+
+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 type AttachmentRef = z.infer<typeof attachmentRefSchema>;
+
+export const attachmentPayloadSchema = z.object({
+  type: fileTypeSchema,
+  payload: attachmentRefSchema,
+});
+
+export type AttachmentPayload = z.infer<typeof attachmentPayloadSchema>;
+
+export type TAttachmentForeignKey = AttachmentRef;
+
+export interface IAttachmentPayload {
+  type: FileType;
+  payload: AttachmentRef;
+}

package/src/chat/button.ts

@@ -0,0 +1,90 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2026 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+
+import { z } from "zod";
+
+export enum ButtonType {
+  postback = "postback",
+  web_url = "web_url",
+}
+
+export type PostBackButton = {
+  type: ButtonType.postback;
+  title: string;
+  payload: string;
+};
+
+export type WebviewHeightRatio = "compact" | "tall" | "full";
+
+export type WebUrlButton = {
+  type: ButtonType.web_url;
+  title: string;
+  url: string;
+  messenger_extensions?: boolean;
+  webview_height_ratio?: WebviewHeightRatio;
+};
+
+export type Button = PostBackButton | WebUrlButton;
+
+export type AnyButton = Button;
+
+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.",
+      });
+    }
+  }) as unknown as z.ZodType<Button>;
+
+export enum PayloadType {
+  location = "location",
+  attachment = "attachment",
+  quickReply = "quickReply",
+  button = "button",
+  outcome = "outcome",
+  menu = "menu",
+  content = "content",
+}

package/src/chat/index.ts

@@ -0,0 +1,173 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2026 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+
+export {
+  fileTypeSchema,
+  attachmentRefSchema,
+  attachmentPayloadSchema,
+  FileType,
+  type AttachmentRef,
+  type AttachmentPayload,
+  type IAttachmentPayload,
+  type TAttachmentForeignKey,
+} from "./attachment";
+
+export {
+  buttonSchema,
+  ButtonType,
+  PayloadType,
+  type AnyButton,
+  type Button,
+  type PostBackButton,
+  type WebUrlButton,
+  type WebviewHeightRatio,
+} from "./button";
+
+export {
+  contentOptionsSchema,
+  fallbackOptionsSchema,
+  ActionOptionsSchema,
+  type ActionOptions,
+  type ContentOptions,
+  type FallbackOptions,
+} from "./options";
+
+export {
+  coordinatesSchema,
+  payloadSchema,
+  stdQuickReplySchema,
+  type Payload,
+  type StdQuickReply,
+} 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,
+  type AnyMessage,
+  type ContentElement,
+  type ContentPagination,
+  type IncomingMessage,
+  type IncomingMessageTypeLiteral,
+  type OutgoingMessage,
+  type OutgoingMessageTypeLiteral,
+  type OutgoingPopulatedListMessage,
+  type PayloadTypeLiteral,
+  type StdIncomingAttachmentMessageData,
+  type StdIncomingAttachmentMessage,
+  type StdIncomingLocationMessageData,
+  type StdIncomingLocationMessage,
+  type StdIncomingPayloadMessageData,
+  type StdIncomingQuickReplyMessage,
+  type StdIncomingMessage,
+  type StdIncomingPostBackMessage,
+  type StdIncomingTextMessageData,
+  type StdIncomingTextMessage,
+  type StdOutgoingAttachmentMessageData,
+  type StdOutgoingAttachmentEnvelope,
+  type StdOutgoingAttachmentMessage,
+  type StdOutgoingButtonsMessageData,
+  type StdOutgoingButtonsEnvelope,
+  type StdOutgoingButtonsMessage,
+  type StdOutgoingCarouselMessage,
+  type StdOutgoingEnvelope,
+  type StdOutgoingListMessageData,
+  type StdOutgoingListEnvelope,
+  type StdOutgoingListMessage,
+  type StdOutgoingMessage,
+  type StdOutgoingQuickRepliesMessageData,
+  type StdOutgoingMessageEnvelope,
+  type StdOutgoingQuickRepliesEnvelope,
+  type StdOutgoingQuickRepliesMessage,
+  type StdOutgoingSystemMessageData,
+  type StdOutgoingSystemEnvelope,
+  type StdOutgoingSystemMessage,
+  type StdOutgoingTextMessageData,
+  type StdOutgoingTextEnvelope,
+  type StdOutgoingTextMessage,
+} from "./message-contract";
+
+export {
+  labelGroupFullSchema,
+  labelGroupSchema,
+  labelGroupStubSchema,
+  type LabelGroup,
+  type LabelGroupFull,
+  type LabelGroupStub,
+} from "./label-group";
+
+export {
+  labelFullSchema,
+  labelSchema,
+  labelStubSchema,
+  type Label,
+  type LabelFull,
+  type LabelStub,
+} from "./label";
+
+export {
+  subscriberFullSchema,
+  subscriberSchema,
+  subscriberStubSchema,
+  type Subscriber,
+  type SubscriberFull,
+  type SubscriberStub,
+} from "./subscriber";
+
+export {
+  threadFullSchema,
+  threadSchema,
+  threadStubSchema,
+  type Thread,
+  type ThreadFull,
+  type ThreadStub,
+} from "./thread";
+
+export {
+  messageFullSchema,
+  messageSchema,
+  messageStubSchema,
+  type Message,
+  type MessageFull,
+  type MessageStub,
+} from "./message";

package/src/chat/label-group.ts

@@ -0,0 +1,35 @@
+/*
+ * 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(),
+});
+
+export type LabelGroupStub = z.infer<typeof labelGroupStubSchema>;
+
+export type LabelGroup = z.infer<typeof labelGroupSchema>;
+
+export type LabelGroupFull = z.infer<typeof labelGroupFullSchema>;

package/src/chat/label.ts

@@ -0,0 +1,56 @@
+/*
+ * 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",
+} as const;
+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(),
+});
+
+export type LabelStub = z.infer<typeof labelStubSchema>;
+
+export type Label = z.infer<typeof labelSchema>;
+
+export type LabelFull = z.infer<typeof labelFullSchema>;