@hexabot-ai/types 3.0.0-alpha.0

package/src/chat/subscriber.ts

@@ -0,0 +1,73 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2026 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+
+import { z } from "zod";
+
+import { attachmentSchema } from "../attachment/attachment";
+import { sourceSchema } from "../channel/source";
+import { asId, asIdArray, withAliases } from "../shared/aliases";
+import { preprocess } from "../shared/preprocess";
+import { subscriberBaseSchema } from "../shared/profile";
+import { userProfileAssignedSchema } from "../user/user-profile-assigned";
+
+import { labelSchema } from "./label";
+
+const subscriberAliasMap = {
+  labelIds: "labels",
+  assignedToId: "assignedTo",
+  avatarId: "avatar",
+  sourceId: "source",
+} as const;
+const subscriberObjectSchema = subscriberBaseSchema.extend({
+  labels: preprocess(
+    (value) => (Array.isArray(value) ? asIdArray(value) : []),
+    z.array(z.string()),
+  ),
+  assignedTo: preprocess(
+    (value) => (value == null ? null : asId(value)),
+    z.string().nullable(),
+  ),
+  avatar: preprocess(
+    (value) => (value == null ? null : asId(value)),
+    z.string().nullable(),
+  ),
+  source: preprocess(
+    (value) => (value == null ? null : asId(value)),
+    z.string().nullable(),
+  ),
+});
+
+export const subscriberStubSchema = subscriberBaseSchema;
+
+export const subscriberSchema = preprocess(
+  (value) => withAliases(value, subscriberAliasMap),
+  subscriberObjectSchema,
+);
+
+export const subscriberFullSchema = subscriberBaseSchema.extend({
+  labels: preprocess(
+    (value) => (Array.isArray(value) ? value : []),
+    z.array(z.lazy(() => labelSchema)),
+  ),
+  assignedTo: preprocess(
+    (value) => (value == null ? null : value),
+    userProfileAssignedSchema.nullable(),
+  ),
+  avatar: preprocess(
+    (value) => (value == null ? null : value),
+    attachmentSchema.nullable(),
+  ),
+  source: preprocess(
+    (value) => (value == null ? null : value),
+    sourceSchema.nullable(),
+  ),
+});
+
+export type SubscriberStub = z.infer<typeof subscriberStubSchema>;
+
+export type Subscriber = z.infer<typeof subscriberSchema>;
+
+export type SubscriberFull = z.infer<typeof subscriberFullSchema>;

package/src/chat/thread.ts

@@ -0,0 +1,55 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2026 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+
+import { z } from "zod";
+
+import { sourceSchema } from "../channel/source";
+import { asId, withAliases } from "../shared/aliases";
+import { baseStubSchema } from "../shared/base";
+import { preprocess } from "../shared/preprocess";
+
+import { subscriberSchema } from "./subscriber";
+
+const nullableOptionalDateSchema = z.coerce.date().nullable().optional();
+const nullableOptionalStringSchema = z.string().nullable().optional();
+const threadAliasMap = {
+  subscriberId: "subscriber",
+  sourceId: "source",
+} as const;
+const threadStubObjectSchema = baseStubSchema.extend({
+  status: z.enum(["open", "closed"]),
+  lastMessageAt: nullableOptionalDateSchema,
+  closedAt: nullableOptionalDateSchema,
+  closeReason: z.enum(["manual", "inactivity"]).nullable().optional(),
+  title: nullableOptionalStringSchema,
+});
+
+export const threadStubSchema = threadStubObjectSchema;
+
+export const threadSchema = preprocess(
+  (value) => withAliases(value, threadAliasMap),
+  threadStubObjectSchema.extend({
+    subscriber: preprocess(
+      (value) => (value == null ? null : asId(value)),
+      z.string(),
+    ),
+    source: preprocess(
+      (value) => (value == null ? null : asId(value)),
+      z.string(),
+    ),
+  }),
+);
+
+export const threadFullSchema = threadStubObjectSchema.extend({
+  subscriber: subscriberSchema,
+  source: sourceSchema,
+});
+
+export type ThreadStub = z.infer<typeof threadStubSchema>;
+
+export type Thread = z.infer<typeof threadSchema>;
+
+export type ThreadFull = z.infer<typeof threadFullSchema>;

package/src/cms/content-type.ts

@@ -0,0 +1,26 @@
+/*
+ * 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";
+
+const contentTypeObjectSchema = baseStubSchema.extend({
+  name: z.string(),
+  schema: z.any(),
+});
+
+export const contentTypeStubSchema = contentTypeObjectSchema;
+
+export const contentTypeSchema = contentTypeObjectSchema;
+
+export const contentTypeFullSchema = contentTypeObjectSchema;
+
+export type ContentTypeStub = z.infer<typeof contentTypeStubSchema>;
+
+export type ContentType = z.infer<typeof contentTypeSchema>;
+
+export type ContentTypeFull = z.infer<typeof contentTypeFullSchema>;

package/src/cms/content.ts

@@ -0,0 +1,48 @@
+/*
+ * 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 { contentTypeSchema } from "./content-type";
+
+const contentAliasMap = {
+  contentTypeId: "contentType",
+} as const;
+const contentStubObjectSchema = baseStubSchema.extend({
+  title: z.string(),
+  status: z.coerce.boolean(),
+  properties: preprocess(
+    (value) => (value == null ? null : value),
+    z.record(z.string(), z.unknown()).nullable(),
+  ),
+  searchText: z.string(),
+});
+
+export const contentStubSchema = contentStubObjectSchema;
+
+export const contentSchema = preprocess(
+  (value) => withAliases(value, contentAliasMap),
+  contentStubObjectSchema.extend({
+    contentType: preprocess(
+      (value) => (value == null ? null : asId(value)),
+      z.string(),
+    ),
+  }),
+);
+
+export const contentFullSchema = contentStubObjectSchema.extend({
+  contentType: contentTypeSchema,
+});
+
+export type ContentStub = z.infer<typeof contentStubSchema>;
+
+export type Content = z.infer<typeof contentSchema>;
+
+export type ContentFull = z.infer<typeof contentFullSchema>;

package/src/cms/index.ts

@@ -0,0 +1,33 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2026 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+
+export {
+  contentTypeFullSchema,
+  contentTypeSchema,
+  contentTypeStubSchema,
+  type ContentType,
+  type ContentTypeFull,
+  type ContentTypeStub,
+} from "./content-type";
+
+export {
+  contentFullSchema,
+  contentSchema,
+  contentStubSchema,
+  type Content,
+  type ContentFull,
+  type ContentStub,
+} from "./content";
+
+export {
+  MenuType,
+  menuFullSchema,
+  menuSchema,
+  menuStubSchema,
+  type Menu,
+  type MenuFull,
+  type MenuStub,
+} from "./menu";

package/src/cms/menu.ts

@@ -0,0 +1,54 @@
+/*
+ * 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 enum MenuType {
+  web_url = "web_url",
+  postback = "postback",
+  nested = "nested",
+}
+
+const menuTypeSchema = z.enum(MenuType);
+const menuAliasMap = {
+  parentId: "parent",
+} as const;
+const menuStubObjectSchema = baseStubSchema.extend({
+  title: z.string(),
+  type: menuTypeSchema,
+  payload: z.string().nullable().optional(),
+  url: z.string().nullable().optional(),
+});
+
+export const menuStubSchema = menuStubObjectSchema;
+
+export const menuSchema = preprocess(
+  (value) => withAliases(value, menuAliasMap),
+  menuStubObjectSchema.extend({
+    parent: preprocess(
+      (value) => (value == null ? null : asId(value)),
+      z.string().nullable(),
+    ).optional(),
+  }),
+);
+
+export const menuFullSchema = menuStubObjectSchema.extend({
+  parent: menuSchema.nullable().optional(),
+  children: preprocess(
+    (value) => (Array.isArray(value) ? value : []),
+    z.array(menuSchema),
+  ).optional(),
+});
+
+export type MenuStub = z.infer<typeof menuStubSchema>;
+
+export type Menu = z.infer<typeof menuSchema>;
+
+export type MenuFull = z.infer<typeof menuFullSchema>;

package/src/dummy/dummy.ts

@@ -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 dummyObjectSchema = baseStubSchema.extend({
+  dummy: z.string(),
+  dynamicField: preprocess(
+    (value) => (value == null ? undefined : value),
+    z.record(z.string(), z.unknown()).optional(),
+  ).optional(),
+});
+
+export const dummyStubSchema = dummyObjectSchema;
+
+export const dummySchema = dummyObjectSchema;
+
+export const dummyFullSchema = dummyObjectSchema;
+
+export type DummyStub = z.infer<typeof dummyStubSchema>;
+
+export type Dummy = z.infer<typeof dummySchema>;
+
+export type DummyFull = z.infer<typeof dummyFullSchema>;

package/src/dummy/index.ts

@@ -0,0 +1,14 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2026 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+
+export {
+  dummyFullSchema,
+  dummySchema,
+  dummyStubSchema,
+  type Dummy,
+  type DummyFull,
+  type DummyStub,
+} from "./dummy";

package/src/i18n/index.ts

@@ -0,0 +1,23 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2026 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+
+export {
+  languageFullSchema,
+  languageSchema,
+  languageStubSchema,
+  type Language,
+  type LanguageFull,
+  type LanguageStub,
+} from "./language";
+
+export {
+  translationFullSchema,
+  translationSchema,
+  translationStubSchema,
+  type Translation,
+  type TranslationFull,
+  type TranslationStub,
+} from "./translation";

package/src/i18n/language.ts

@@ -0,0 +1,28 @@
+/*
+ * 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";
+
+const languageObjectSchema = baseStubSchema.extend({
+  title: z.string(),
+  code: z.string(),
+  isDefault: z.coerce.boolean(),
+  isRTL: z.coerce.boolean(),
+});
+
+export const languageStubSchema = languageObjectSchema;
+
+export const languageSchema = languageObjectSchema;
+
+export const languageFullSchema = languageObjectSchema;
+
+export type LanguageStub = z.infer<typeof languageStubSchema>;
+
+export type Language = z.infer<typeof languageSchema>;
+
+export type LanguageFull = z.infer<typeof languageFullSchema>;

package/src/i18n/translation.ts

@@ -0,0 +1,26 @@
+/*
+ * 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";
+
+const translationObjectSchema = baseStubSchema.extend({
+  str: z.string(),
+  translations: z.record(z.string(), z.string()),
+});
+
+export const translationStubSchema = translationObjectSchema;
+
+export const translationSchema = translationObjectSchema;
+
+export const translationFullSchema = translationObjectSchema;
+
+export type TranslationStub = z.infer<typeof translationStubSchema>;
+
+export type Translation = z.infer<typeof translationSchema>;
+
+export type TranslationFull = z.infer<typeof translationFullSchema>;