@hexabot-ai/types 3.0.0-alpha.0

package/dist/esm/chat/options.js

@@ -0,0 +1,119 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2026 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+import { z } from "zod";
+import { buttonSchema } from "./button";
+export const contentOptionsSchema = z.object({
+    display: z.enum(["list", "carousel"]).meta({
+        title: "Display",
+    }),
+    contentType: z
+        .string()
+        .optional()
+        .meta({
+        title: "Content Type",
+        "ui:widget": "AutoCompleteWidget",
+        "ui:options": {
+            entity: "ContentType",
+            valueKey: "id",
+            labelKey: "name",
+        },
+    }),
+    fields: z
+        .object({
+        title: z.string().meta({
+            title: "Title",
+            "ui:field": "AutoCompleteField",
+            "ui:options": {
+                entity: "ContentType",
+                idFormPath: "content.contentType",
+                nestedArrayField: "schema.properties",
+                nestedArrayItemField: "type",
+                nestedArrayItemValue: "string",
+            },
+        }),
+        subtitle: z
+            .string()
+            .optional()
+            .meta({
+            title: "Subtitle",
+            "ui:field": "AutoCompleteField",
+            "ui:options": {
+                entity: "ContentType",
+                idFormPath: "content.contentType",
+                nestedArrayField: "schema.properties",
+                nestedArrayItemField: "type",
+                nestedArrayItemValue: "string",
+            },
+        }),
+        image_url: z
+            .string()
+            .optional()
+            .meta({
+            title: "Image URL Field",
+            "ui:field": "AutoCompleteField",
+            "ui:options": {
+                entity: "ContentType",
+                idFormPath: "content.contentType",
+                nestedArrayField: "schema.properties",
+                nestedArrayItemField: "type",
+                nestedArrayItemValue: "file",
+            },
+        }),
+        url: z
+            .string()
+            .optional()
+            .meta({
+            title: "URL",
+            "ui:field": "AutoCompleteField",
+            "ui:options": {
+                showOnlyWhenWebUrlButton: true,
+                entity: "ContentType",
+                valueKey: "name",
+                idFormPath: "content.contentType",
+                nestedArrayField: "schema.properties",
+                nestedArrayItemField: "type",
+                nestedArrayItemValue: "uri",
+            },
+        }),
+        action_title: z
+            .string()
+            .optional()
+            .meta({
+            title: "Action Title",
+            "ui:options": {
+                showOnlyWhenPostbackButton: true,
+            },
+        }),
+        action_payload: z
+            .string()
+            .optional()
+            .meta({
+            title: "Action Payload",
+            "ui:options": {
+                showOnlyWhenPostbackButton: true,
+            },
+        }),
+    })
+        .meta({ title: "Fields" }),
+    buttons: z.array(buttonSchema).meta({ title: "Buttons" }),
+    limit: z.number().finite(),
+    query: z.any().optional(),
+    top_element_style: z.enum(["large", "compact"]).optional().meta({
+        title: "Top Element Style",
+    }),
+});
+export const fallbackOptionsSchema = z.object({
+    active: z.boolean(),
+    message: z.array(z.string()),
+    max_attempts: z.number().finite(),
+});
+export const ActionOptionsSchema = z.object({
+    typing: z.union([z.boolean(), z.int().nonnegative()]).optional(),
+    content: contentOptionsSchema.optional(),
+    fallback: fallbackOptionsSchema.optional(),
+    assignTo: z.string().optional(),
+    effects: z.array(z.string()).optional(),
+});

package/dist/esm/chat/quick-reply.js

@@ -0,0 +1,32 @@
+/*
+ * 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 } from "./button";
+export const coordinatesSchema = z.object({
+    lat: z.number(),
+    lon: z.number(),
+});
+export const payloadSchema = z.discriminatedUnion("type", [
+    z.object({
+        type: z.literal(PayloadType.location),
+        coordinates: coordinatesSchema,
+    }),
+    z.object({
+        type: z.literal(PayloadType.attachment),
+        attachment: attachmentPayloadSchema,
+    }),
+]);
+export const stdQuickReplySchema = z.object({
+    title: z.string().meta({
+        title: "Title",
+        description: "The label shown to the user.",
+    }),
+    payload: z.string().meta({
+        title: "Payload",
+        description: "The value sent back when the quick reply is selected.",
+    }),
+});

package/dist/esm/chat/subscriber.js

@@ -0,0 +1,33 @@
+/*
+ * 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",
+};
+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()),
+});

package/dist/esm/chat/thread.js

@@ -0,0 +1,33 @@
+/*
+ * 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",
+};
+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,
+});

package/dist/esm/cms/content-type.js

@@ -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";
+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;

package/dist/esm/cms/content.js

@@ -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 { asId, withAliases } from "../shared/aliases";
+import { baseStubSchema } from "../shared/base";
+import { preprocess } from "../shared/preprocess";
+import { contentTypeSchema } from "./content-type";
+const contentAliasMap = {
+    contentTypeId: "contentType",
+};
+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,
+});

package/dist/esm/cms/index.js

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

package/dist/esm/cms/menu.js

@@ -0,0 +1,33 @@
+/*
+ * 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 var MenuType;
+(function (MenuType) {
+    MenuType["web_url"] = "web_url";
+    MenuType["postback"] = "postback";
+    MenuType["nested"] = "nested";
+})(MenuType || (MenuType = {}));
+const menuTypeSchema = z.enum(MenuType);
+const menuAliasMap = {
+    parentId: "parent",
+};
+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(),
+});

package/dist/esm/dummy/dummy.js

@@ -0,0 +1,15 @@
+/*
+ * 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;

package/dist/esm/dummy/index.js

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

package/dist/esm/i18n/index.js

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

package/dist/esm/i18n/language.js

@@ -0,0 +1,16 @@
+/*
+ * 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;

package/dist/esm/i18n/translation.js

@@ -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";
+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;

package/dist/esm/index.js

@@ -0,0 +1,16 @@
+/*
+ * 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/dist/esm/setting/index.js

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

package/dist/esm/setting/metadata.js

@@ -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";
+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;

package/dist/esm/setting/setting.js

@@ -0,0 +1,33 @@
+/*
+ * 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 var FieldType;
+(function (FieldType) {
+    FieldType["text"] = "text";
+    FieldType["url"] = "url";
+    FieldType["textarea"] = "textarea";
+    FieldType["checkbox"] = "checkbox";
+    FieldType["file"] = "file";
+    FieldType["html"] = "html";
+})(FieldType || (FieldType = {}));

package/dist/esm/shared/aliases.js

@@ -0,0 +1,35 @@
+/*
+ * 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, aliases) => {
+    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) => {
+    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) => {
+    if (!Array.isArray(value)) {
+        return value;
+    }
+    return value.map((entry) => asId(entry));
+};

package/dist/esm/shared/base.js

@@ -0,0 +1,11 @@
+/*
+ * 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/dist/esm/shared/object.js

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

package/dist/esm/shared/preprocess.js

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

package/dist/esm/shared/profile.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 "./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/dist/esm/user/credential.js

@@ -0,0 +1,23 @@
+/*
+ * 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",
+};
+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()),
+});

package/dist/esm/user/domain.js

@@ -0,0 +1,53 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2026 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+import { z } from "zod";
+export var Action;
+(function (Action) {
+    Action["CREATE"] = "create";
+    Action["READ"] = "read";
+    Action["UPDATE"] = "update";
+    Action["DELETE"] = "delete";
+})(Action || (Action = {}));
+export var MethodToAction;
+(function (MethodToAction) {
+    MethodToAction["POST"] = "create";
+    MethodToAction["GET"] = "read";
+    MethodToAction["PATCH"] = "update";
+    MethodToAction["DELETE"] = "delete";
+})(MethodToAction || (MethodToAction = {}));
+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/dist/esm/user/index.js

@@ -0,0 +1,13 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2026 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+export { Action, MethodToAction, } from "./domain";
+export { userProfileFullSchema, userProfileSchema, userProfileStubSchema, } from "./user-profile";
+export { userProfileAssignedFullSchema, userProfileAssignedSchema, userProfileAssignedStubSchema, } from "./user-profile-assigned";
+export { userFullSchema, userSchema, userStubSchema, } from "./user";
+export { roleFullSchema, roleSchema, roleStubSchema, } from "./role";
+export { modelFullSchema, modelSchema, modelStubSchema, } from "./model";
+export { permissionFullSchema, permissionSchema, permissionStubSchema, } from "./permission";
+export { credentialFullSchema, credentialSchema, credentialStubSchema, } from "./credential";