@hexabot-ai/types 3.0.0-alpha.0

package/src/index.ts

@@ -0,0 +1,27 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2026 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+
+export * from "./attachment";
+
+export * from "./analytics";
+
+export * from "./audit";
+
+export * from "./channel";
+
+export * from "./chat";
+
+export * from "./cms";
+
+export * from "./i18n";
+
+export * from "./setting";
+
+export * from "./user";
+
+export * from "./workflow";
+
+export * from "./dummy";

package/src/setting/index.ts

@@ -0,0 +1,25 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2026 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+
+export {
+  FieldType,
+  settingFullSchema,
+  settingSchema,
+  settingStubSchema,
+  settingValueSchema,
+  type Setting,
+  type SettingFull,
+  type SettingStub,
+} from "./setting";
+
+export {
+  metadataFullSchema,
+  metadataSchema,
+  metadataStubSchema,
+  type Metadata,
+  type MetadataFull,
+  type MetadataStub,
+} from "./metadata";

package/src/setting/metadata.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 metadataObjectSchema = baseStubSchema.extend({
+  name: z.string(),
+  value: z.any(),
+});
+
+export const metadataStubSchema = metadataObjectSchema;
+
+export const metadataSchema = metadataObjectSchema;
+
+export const metadataFullSchema = metadataObjectSchema;
+
+export type MetadataStub = z.infer<typeof metadataStubSchema>;
+
+export type Metadata = z.infer<typeof metadataSchema>;
+
+export type MetadataFull = z.infer<typeof metadataFullSchema>;

package/src/setting/setting.ts

@@ -0,0 +1,46 @@
+/*
+ * 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 const settingValueSchema = z.union([
+  z.null(),
+  z.string(),
+  z.number(),
+  z.boolean(),
+  z.array(z.string()),
+  z.record(z.string(), z.unknown()),
+]);
+
+const settingObjectSchema = baseStubSchema.extend({
+  group: z.string(),
+  subgroup: z.string().nullable().optional(),
+  label: z.string(),
+  value: settingValueSchema,
+});
+
+export const settingStubSchema = settingObjectSchema;
+
+export const settingSchema = settingObjectSchema;
+
+export const settingFullSchema = settingObjectSchema;
+
+export type SettingStub = z.infer<typeof settingStubSchema>;
+
+export type Setting = z.infer<typeof settingSchema>;
+
+export type SettingFull = z.infer<typeof settingFullSchema>;
+
+export enum FieldType {
+  text = "text",
+  url = "url",
+  textarea = "textarea",
+  checkbox = "checkbox",
+  file = "file",
+  html = "html",
+}

package/src/shared/aliases.ts

@@ -0,0 +1,48 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2026 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+
+import { cloneWithPrototype, toRecord } from "./object";
+
+export const withAliases = (
+  value: unknown,
+  aliases: Record<string, string>,
+): unknown => {
+  const record = toRecord(value);
+  if (!record) {
+    return value;
+  }
+
+  const next = cloneWithPrototype(record);
+
+  for (const [from, to] of Object.entries(aliases)) {
+    if (next[to] === undefined && next[from] !== undefined) {
+      next[to] = next[from];
+    }
+  }
+
+  return next;
+};
+
+export const asId = (value: unknown): unknown => {
+  if (value == null || typeof value === "string") {
+    return value;
+  }
+
+  const record = toRecord(value);
+  if (!record) {
+    return value;
+  }
+
+  return typeof record.id === "string" ? record.id : value;
+};
+
+export const asIdArray = (value: unknown): unknown => {
+  if (!Array.isArray(value)) {
+    return value;
+  }
+
+  return value.map((entry) => asId(entry));
+};

package/src/shared/base.ts

@@ -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";
+
+export const baseStubSchema = z.object({
+  id: z.string(),
+  createdAt: z.coerce.date(),
+  updatedAt: z.coerce.date(),
+});

package/src/shared/object.ts

@@ -0,0 +1,19 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2026 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+
+export const toRecord = (value: unknown): Record<string, unknown> | null => {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return null;
+  }
+
+  return value as Record<string, unknown>;
+};
+
+export const cloneWithPrototype = (
+  value: Record<string, unknown>,
+): Record<string, unknown> => {
+  return Object.assign(Object.create(Object.getPrototypeOf(value)), value);
+};

package/src/shared/preprocess.ts

@@ -0,0 +1,14 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2026 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+
+import { z } from "zod";
+
+export const preprocess = <T>(
+  transformer: (value: unknown) => unknown,
+  schema: z.ZodType<T>,
+): z.ZodType<T> => {
+  return z.preprocess(transformer, schema) as z.ZodType<T>;
+};

package/src/shared/profile.ts

@@ -0,0 +1,49 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2026 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+
+import { z } from "zod";
+
+import { baseStubSchema } from "./base";
+import { preprocess } from "./preprocess";
+
+export const nullableStringSchema = preprocess(
+  (value) => (value == null ? null : value),
+  z.string().nullable(),
+);
+
+export const nullableDateSchema = preprocess(
+  (value) => (value == null ? null : value),
+  z.coerce.date().nullable(),
+);
+
+export const userProfileBaseSchema = baseStubSchema.extend({
+  firstName: z.string(),
+  lastName: z.string(),
+  language: nullableStringSchema,
+  timezone: z.coerce.number().default(0),
+});
+
+export const subscriberChannelSchema = z.object({
+  name: nullableStringSchema,
+  data: preprocess(
+    (value) => (value == null ? null : value),
+    z.record(z.string(), z.any()).nullable(),
+  ).optional(),
+});
+
+export const subscriberBaseSchema = userProfileBaseSchema.extend({
+  locale: nullableStringSchema,
+  gender: nullableStringSchema,
+  country: nullableStringSchema,
+  foreignId: nullableStringSchema,
+  assignedAt: nullableDateSchema,
+  lastvisit: nullableDateSchema,
+  retainedFrom: nullableDateSchema,
+  channel: preprocess(
+    (value) => value ?? { name: null, data: null },
+    subscriberChannelSchema,
+  ),
+});

package/src/user/credential.ts

@@ -0,0 +1,45 @@
+/*
+ * 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";
+
+const credentialAliasMap = {
+  ownerId: "owner",
+} as const;
+const credentialStubObjectSchema = baseStubSchema.extend({
+  name: z.string(),
+});
+
+export const credentialStubSchema = credentialStubObjectSchema;
+
+export const credentialSchema = preprocess(
+  (value) => withAliases(value, credentialAliasMap),
+  credentialStubObjectSchema.extend({
+    owner: preprocess(
+      (value) => (value == null ? null : asId(value)),
+      z.string(),
+    ),
+  }),
+);
+
+export const credentialFullSchema = credentialStubObjectSchema.extend({
+  owner: preprocess(
+    (value) => (value == null ? null : value),
+    z.lazy(() => userSchema).nullable(),
+  ),
+});
+
+export type CredentialStub = z.infer<typeof credentialStubSchema>;
+
+export type Credential = z.infer<typeof credentialSchema>;
+
+export type CredentialFull = z.infer<typeof credentialFullSchema>;

package/src/user/domain.ts

@@ -0,0 +1,94 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2026 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+
+import { z } from "zod";
+
+export enum Action {
+  CREATE = "create",
+  READ = "read",
+  UPDATE = "update",
+  DELETE = "delete",
+}
+
+export enum MethodToAction {
+  POST = "create",
+  GET = "read",
+  PATCH = "update",
+  DELETE = "delete",
+}
+
+export type TRelation = "role" | "createdBy";
+
+export type TModel =
+  | "contenttype"
+  | "content"
+  | "nlpentity"
+  | "nlpsampleentity"
+  | "nlpsample"
+  | "nlpvalue"
+  | "setting"
+  | "attachment"
+  | "auditlog"
+  | "user"
+  | "role"
+  | "permission"
+  | "label"
+  | "labelgroup"
+  | "message"
+  | "thread"
+  | "subscriber"
+  | "source"
+  | "language"
+  | "translation"
+  | "stats"
+  | "menu"
+  | "workflow"
+  | "workflowversion"
+  | "workflowrun"
+  | "memorydefinition"
+  | "memoryrecord"
+  | "mcpserver"
+  | "model"
+  | "credential";
+
+export type ModelPermissionsPerRole = Record<TModel, Action[]>;
+
+export type PermissionsTree = Record<string, ModelPermissionsPerRole>;
+
+export const relationSchema = z.enum(["role", "createdBy"]);
+
+export const modelIdentitySchema = z.enum([
+  "contenttype",
+  "content",
+  "nlpentity",
+  "nlpsampleentity",
+  "nlpsample",
+  "nlpvalue",
+  "setting",
+  "attachment",
+  "auditlog",
+  "user",
+  "role",
+  "permission",
+  "label",
+  "labelgroup",
+  "message",
+  "thread",
+  "subscriber",
+  "source",
+  "language",
+  "translation",
+  "stats",
+  "menu",
+  "workflow",
+  "workflowversion",
+  "workflowrun",
+  "memorydefinition",
+  "memoryrecord",
+  "mcpserver",
+  "model",
+  "credential",
+]);

package/src/user/index.ts

@@ -0,0 +1,78 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2026 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+
+export {
+  Action,
+  MethodToAction,
+  type ModelPermissionsPerRole,
+  type PermissionsTree,
+  type TModel,
+  type TRelation,
+} from "./domain";
+
+export {
+  userProfileFullSchema,
+  userProfileSchema,
+  userProfileStubSchema,
+  type UserProfile,
+  type UserProfileFull,
+  type UserProfileStub,
+} from "./user-profile";
+
+export {
+  userProfileAssignedFullSchema,
+  userProfileAssignedSchema,
+  userProfileAssignedStubSchema,
+  type UserProfileAssigned,
+  type UserProfileAssignedFull,
+  type UserProfileAssignedStub,
+  type UserProvider,
+} from "./user-profile-assigned";
+
+export {
+  userFullSchema,
+  userSchema,
+  userStubSchema,
+  type User,
+  type UserFull,
+  type UserStub,
+} from "./user";
+
+export {
+  roleFullSchema,
+  roleSchema,
+  roleStubSchema,
+  type Role,
+  type RoleFull,
+  type RoleStub,
+} from "./role";
+
+export {
+  modelFullSchema,
+  modelSchema,
+  modelStubSchema,
+  type Model,
+  type ModelFull,
+  type ModelStub,
+} from "./model";
+
+export {
+  permissionFullSchema,
+  permissionSchema,
+  permissionStubSchema,
+  type Permission,
+  type PermissionFull,
+  type PermissionStub,
+} from "./permission";
+
+export {
+  credentialFullSchema,
+  credentialSchema,
+  credentialStubSchema,
+  type Credential,
+  type CredentialFull,
+  type CredentialStub,
+} from "./credential";

package/src/user/model.ts

@@ -0,0 +1,40 @@
+/*
+ * 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 { modelIdentitySchema, relationSchema } from "./domain";
+import { permissionSchema } from "./permission";
+
+const modelStubObjectSchema = baseStubSchema.extend({
+  name: z.string(),
+  identity: modelIdentitySchema,
+  attributes: z.record(z.string(), z.unknown()),
+  relation: preprocess(
+    (value) => (value == null ? undefined : value),
+    relationSchema.optional(),
+  ).optional(),
+});
+
+export const modelStubSchema = modelStubObjectSchema;
+
+export const modelSchema = modelStubObjectSchema;
+
+export const modelFullSchema = modelStubObjectSchema.extend({
+  permissions: preprocess(
+    (value) => (Array.isArray(value) ? value : []),
+    z.array(z.lazy(() => permissionSchema)),
+  ).optional(),
+});
+
+export type ModelStub = z.infer<typeof modelStubSchema>;
+
+export type Model = z.infer<typeof modelSchema>;
+
+export type ModelFull = z.infer<typeof modelFullSchema>;

package/src/user/permission.ts

@@ -0,0 +1,51 @@
+/*
+ * 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 { Action, relationSchema } from "./domain";
+import { modelSchema } from "./model";
+import { roleSchema } from "./role";
+
+const permissionAliasMap = {
+  modelId: "model",
+  roleId: "role",
+} as const;
+const permissionStubObjectSchema = baseStubSchema.extend({
+  action: z.enum(Action),
+  relation: relationSchema,
+});
+
+export const permissionStubSchema = permissionStubObjectSchema;
+
+export const permissionSchema = preprocess(
+  (value) => withAliases(value, permissionAliasMap),
+  permissionStubObjectSchema.extend({
+    model: preprocess(
+      (value) => (value == null ? null : asId(value)),
+      z.string(),
+    ),
+    role: preprocess(
+      (value) => (value == null ? null : asId(value)),
+      z.string(),
+    ),
+  }),
+);
+
+export const permissionFullSchema = permissionStubObjectSchema.extend({
+  model: z.lazy(() => modelSchema),
+  role: z.lazy(() => roleSchema),
+});
+
+export type PermissionStub = z.infer<typeof permissionStubSchema>;
+
+export type Permission = z.infer<typeof permissionSchema>;
+
+export type PermissionFull = z.infer<typeof permissionFullSchema>;

package/src/user/role.ts

@@ -0,0 +1,43 @@
+/*
+ * 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 { permissionSchema } from "./permission";
+import { userSchema } from "./user";
+
+const roleBaseSchema = baseStubSchema.extend({
+  name: z.string(),
+  active: z.coerce.boolean(),
+});
+const roleFullObjectSchema = z.object({
+  permissions: preprocess(
+    (value) => (Array.isArray(value) ? value : []),
+    z.array(z.lazy(() => permissionSchema)),
+  ).optional(),
+  users: preprocess(
+    (value) => (Array.isArray(value) ? value : []),
+    z.array(z.lazy(() => userSchema)),
+  ),
+});
+
+export const roleStubSchema = roleBaseSchema;
+
+export const roleSchema = roleBaseSchema;
+
+export const roleFullSchema = z.intersection(
+  roleBaseSchema,
+  roleFullObjectSchema,
+);
+
+export type RoleStub = z.infer<typeof roleStubSchema>;
+
+export type Role = z.infer<typeof roleSchema>;
+
+export type RoleFull = z.infer<typeof roleFullSchema>;

package/src/user/user-profile-assigned.ts

@@ -0,0 +1,70 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2026 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+
+import { z } from "zod";
+
+import { asId, asIdArray, withAliases } from "../shared/aliases";
+import { preprocess } from "../shared/preprocess";
+import { nullableStringSchema, subscriberBaseSchema } from "../shared/profile";
+
+const userProfileAssignedAliasMap = {
+  labelIds: "labels",
+  assignedToId: "assignedTo",
+  roleIds: "roles",
+  avatarId: "avatar",
+} as const;
+
+export const userProviderSchema = z.object({
+  strategy: z.literal("local"),
+  sub: z.string().optional(),
+});
+
+const userProfileAssignedObjectSchema = 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(),
+  ),
+  username: z.string(),
+  email: z.string(),
+  sendEmail: z.coerce.boolean(),
+  state: z.coerce.boolean(),
+  resetCount: z.coerce.number(),
+  resetToken: nullableStringSchema,
+  provider: userProviderSchema.optional(),
+  roles: preprocess(
+    (value) => (Array.isArray(value) ? asIdArray(value) : []),
+    z.array(z.string()),
+  ),
+  avatar: preprocess(
+    (value) => (value == null ? null : asId(value)),
+    z.string().nullable(),
+  ),
+});
+
+export const userProfileAssignedStubSchema = userProfileAssignedObjectSchema;
+
+export const userProfileAssignedSchema = preprocess(
+  (value) => withAliases(value, userProfileAssignedAliasMap),
+  userProfileAssignedObjectSchema,
+);
+
+export const userProfileAssignedFullSchema = userProfileAssignedSchema;
+
+export type UserProvider = z.infer<typeof userProviderSchema>;
+
+export type UserProfileAssignedStub = z.infer<
+  typeof userProfileAssignedStubSchema
+>;
+
+export type UserProfileAssigned = z.infer<typeof userProfileAssignedSchema>;
+
+export type UserProfileAssignedFull = z.infer<
+  typeof userProfileAssignedFullSchema
+>;