@hexabot-ai/types 3.0.0-alpha.0

package/dist/esm/user/model.js

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

package/dist/esm/user/permission.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 { 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",
+};
+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),
+});

package/dist/esm/user/role.js

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

package/dist/esm/user/user-profile-assigned.js

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

package/dist/esm/user/user-profile.js

@@ -0,0 +1,9 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2026 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+import { userProfileBaseSchema } from "../shared/profile";
+export const userProfileStubSchema = userProfileBaseSchema;
+export const userProfileSchema = userProfileBaseSchema;
+export const userProfileFullSchema = userProfileBaseSchema;

package/dist/esm/user/user.js

@@ -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 { attachmentSchema } from "../attachment/attachment";
+import { labelSchema } from "../chat/label";
+import { asId, asIdArray, withAliases } from "../shared/aliases";
+import { preprocess } from "../shared/preprocess";
+import { subscriberBaseSchema } from "../shared/profile";
+import { roleSchema } from "./role";
+import { userProfileAssignedSchema, userProviderSchema, } from "./user-profile-assigned";
+const userAliasMap = {
+    labelIds: "labels",
+    assignedToId: "assignedTo",
+    roleIds: "roles",
+    avatarId: "avatar",
+};
+const userStubObjectSchema = subscriberBaseSchema.extend({
+    username: z.string(),
+    email: z.string(),
+    sendEmail: z.coerce.boolean(),
+    state: z.coerce.boolean(),
+    resetCount: z.coerce.number(),
+    resetToken: preprocess((value) => (value == null ? null : value), z.string().nullable()),
+    provider: userProviderSchema.optional(),
+});
+export const userStubSchema = userStubObjectSchema;
+export const userSchema = preprocess((value) => withAliases(value, userAliasMap), userStubObjectSchema.extend({
+    labels: preprocess((value) => (Array.isArray(value) ? asIdArray(value) : []), z.array(z.string())),
+    assignedTo: preprocess((value) => (value == null ? null : asId(value)), z.string().nullable()),
+    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 userFullSchema = userStubObjectSchema.extend({
+    labels: preprocess((value) => (Array.isArray(value) ? value : []), z.array(z.lazy(() => labelSchema))),
+    assignedTo: preprocess((value) => (value == null ? null : value), userProfileAssignedSchema.nullable()),
+    roles: preprocess((value) => (Array.isArray(value) ? value : []), z.array(z.lazy(() => roleSchema))),
+    avatar: preprocess((value) => (value == null ? null : value), attachmentSchema.nullable()),
+});

package/dist/esm/workflow/domain.js

@@ -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";
+export var WorkflowType;
+(function (WorkflowType) {
+    WorkflowType["conversational"] = "conversational";
+    WorkflowType["manual"] = "manual";
+    WorkflowType["scheduled"] = "scheduled";
+})(WorkflowType || (WorkflowType = {}));
+export var WorkflowVersionAction;
+(function (WorkflowVersionAction) {
+    WorkflowVersionAction["create"] = "create";
+    WorkflowVersionAction["update"] = "update";
+    WorkflowVersionAction["restore"] = "restore";
+    WorkflowVersionAction["import"] = "import";
+})(WorkflowVersionAction || (WorkflowVersionAction = {}));
+export var MemoryScope;
+(function (MemoryScope) {
+    MemoryScope["global"] = "global";
+    MemoryScope["workflow"] = "workflow";
+    MemoryScope["thread"] = "thread";
+    MemoryScope["run"] = "run";
+})(MemoryScope || (MemoryScope = {}));
+export var McpServerTransport;
+(function (McpServerTransport) {
+    McpServerTransport["http"] = "http";
+    McpServerTransport["stdio"] = "stdio";
+})(McpServerTransport || (McpServerTransport = {}));
+export var DirectionType;
+(function (DirectionType) {
+    DirectionType["HORIZONTAL"] = "horizontal";
+    DirectionType["VERTICAL"] = "vertical";
+})(DirectionType || (DirectionType = {}));
+export const workflowTypeSchema = z.enum(WorkflowType);
+export const workflowVersionActionSchema = z.enum(WorkflowVersionAction);
+export const memoryScopeSchema = z.enum(MemoryScope);
+export const mcpServerTransportSchema = z.enum(McpServerTransport);
+export const directionTypeSchema = z.enum(DirectionType);

package/dist/esm/workflow/helpers.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 { subscriberSchema } from "../chat/subscriber";
+import { toRecord } from "../shared/object";
+import { userSchema } from "../user/user";
+export const nullishToNull = (value) => {
+    return value == null ? null : value;
+};
+export const userOrSubscriberSchema = z.union([
+    z.lazy(() => userSchema),
+    subscriberSchema,
+]);
+export const parseUserOrSubscriber = (value) => {
+    const record = toRecord(value);
+    if (record?.type === "UserOrmEntity") {
+        return userSchema.parse(value);
+    }
+    if (record?.type === "SubscriberOrmEntity") {
+        return subscriberSchema.parse(value);
+    }
+    const parsedUser = userSchema.safeParse(value);
+    if (parsedUser.success) {
+        return parsedUser.data;
+    }
+    return subscriberSchema.parse(value);
+};

package/dist/esm/workflow/index.js

@@ -0,0 +1,12 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2026 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+export { DirectionType, McpServerTransport, MemoryScope, WorkflowType, WorkflowVersionAction, } from "./domain";
+export { createWorkflowFullSchema, workflowFullSchema, workflowSchema, workflowStubSchema, } from "./workflow";
+export { workflowVersionFullSchema, workflowVersionSchema, workflowVersionStubSchema, } from "./workflow-version";
+export { resolveRunDurationMs, workflowRunFullSchema, workflowRunSchema, workflowRunStubSchema, } from "./workflow-run";
+export { memoryDefinitionFullSchema, memoryDefinitionSchema, memoryDefinitionStubSchema, } from "./memory-definition";
+export { memoryRecordFullSchema, memoryRecordSchema, memoryRecordStubSchema, } from "./memory-record";
+export { mcpServerFullSchema, mcpServerSchema, mcpServerStubSchema, } from "./mcp-server";

package/dist/esm/workflow/mcp-server.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 { asId, withAliases } from "../shared/aliases";
+import { baseStubSchema } from "../shared/base";
+import { preprocess } from "../shared/preprocess";
+import { credentialSchema } from "../user/credential";
+import { mcpServerTransportSchema } from "./domain";
+const mcpServerAliasMap = {
+    credentialId: "credential",
+};
+const mcpServerStubObjectSchema = baseStubSchema.extend({
+    name: z.string(),
+    enabled: z.coerce.boolean(),
+    transport: mcpServerTransportSchema,
+    url: preprocess((value) => (value == null ? null : value), z.string().nullable()),
+    command: preprocess((value) => (value == null ? null : value), z.string().nullable()),
+    args: preprocess((value) => (value == null ? null : value), z.array(z.string()).nullable()),
+    cwd: preprocess((value) => (value == null ? null : value), z.string().nullable()),
+});
+export const mcpServerStubSchema = mcpServerStubObjectSchema;
+export const mcpServerSchema = preprocess((value) => withAliases(value, mcpServerAliasMap), mcpServerStubObjectSchema.extend({
+    credential: preprocess((value) => (value == null ? null : asId(value)), z.string().nullable()),
+}));
+export const mcpServerFullSchema = mcpServerStubObjectSchema.extend({
+    credential: preprocess((value) => (value == null ? null : credentialSchema.parse(value)), credentialSchema.nullable()).optional(),
+});

package/dist/esm/workflow/memory-definition.js

@@ -0,0 +1,18 @@
+/*
+ * 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 { memoryScopeSchema } from "./domain";
+const memoryDefinitionObjectSchema = baseStubSchema.extend({
+    name: z.string(),
+    slug: z.string(),
+    scope: memoryScopeSchema,
+    schema: z.any(),
+    ttlSeconds: z.coerce.number().nullable().optional(),
+});
+export const memoryDefinitionStubSchema = memoryDefinitionObjectSchema;
+export const memoryDefinitionSchema = memoryDefinitionObjectSchema;
+export const memoryDefinitionFullSchema = memoryDefinitionObjectSchema;

package/dist/esm/workflow/memory-record.js

@@ -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 { threadSchema } from "../chat/thread";
+import { asId, withAliases } from "../shared/aliases";
+import { baseStubSchema } from "../shared/base";
+import { preprocess } from "../shared/preprocess";
+import { parseUserOrSubscriber, userOrSubscriberSchema } from "./helpers";
+import { memoryDefinitionSchema } from "./memory-definition";
+import { workflowSchema } from "./workflow";
+import { workflowRunSchema } from "./workflow-run";
+const memoryRecordAliasMap = {
+    definitionId: "definition",
+    ownerId: "owner",
+    workflowId: "workflow",
+    runId: "run",
+    threadId: "thread",
+};
+const memoryRecordStubObjectSchema = baseStubSchema.extend({
+    value: z.record(z.string(), z.unknown()),
+    ttlSeconds: z.coerce.number().nullable().optional(),
+    expiresAt: z.coerce.date().nullable().optional(),
+});
+export const memoryRecordStubSchema = memoryRecordStubObjectSchema;
+export const memoryRecordSchema = preprocess((value) => withAliases(value, memoryRecordAliasMap), memoryRecordStubObjectSchema.extend({
+    definition: preprocess((value) => (value == null ? null : asId(value)), z.string()),
+    owner: preprocess((value) => (value == null ? null : asId(value)), z.string()),
+    workflow: preprocess((value) => (value == null ? undefined : asId(value)), z.string().optional()).optional(),
+    run: preprocess((value) => (value == null ? undefined : asId(value)), z.string().optional()).optional(),
+    thread: preprocess((value) => (value == null ? undefined : asId(value)), z.string().optional()).optional(),
+}));
+export const memoryRecordFullSchema = memoryRecordStubObjectSchema.extend({
+    definition: memoryDefinitionSchema,
+    owner: preprocess(parseUserOrSubscriber, userOrSubscriberSchema),
+    workflow: workflowSchema.nullable().optional(),
+    run: workflowRunSchema.nullable().optional(),
+    thread: threadSchema.nullable().optional(),
+});

package/dist/esm/workflow/workflow-run.js

@@ -0,0 +1,96 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2026 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+import { z } from "zod";
+import { threadSchema } from "../chat/thread";
+import { asId, withAliases } from "../shared/aliases";
+import { baseStubSchema } from "../shared/base";
+import { cloneWithPrototype, toRecord } from "../shared/object";
+import { preprocess } from "../shared/preprocess";
+import { nullishToNull, parseUserOrSubscriber, userOrSubscriberSchema, } from "./helpers";
+import { workflowSchema } from "./workflow";
+import { workflowVersionSchema } from "./workflow-version";
+const workflowRunStatusSchema = z.enum([
+    "idle",
+    "running",
+    "suspended",
+    "finished",
+    "failed",
+]);
+const resolveTimestampMs = (value) => {
+    if (!value) {
+        return null;
+    }
+    const date = value instanceof Date ? value : new Date(value);
+    const timestamp = date.getTime();
+    return Number.isNaN(timestamp) ? null : timestamp;
+};
+export const resolveRunDurationMs = (run) => {
+    const createdAtMs = resolveTimestampMs(run.createdAt);
+    if (createdAtMs == null) {
+        return null;
+    }
+    const endAtMs = resolveTimestampMs(run.finishedAt) ??
+        resolveTimestampMs(run.failedAt) ??
+        resolveTimestampMs(run.suspendedAt) ??
+        (run.status === "running" ? Date.now() : null);
+    if (endAtMs == null) {
+        return null;
+    }
+    return Math.max(0, endAtMs - createdAtMs);
+};
+const workflowRunAliasMap = {
+    workflowId: "workflow",
+    workflowVersionId: "workflowVersion",
+    triggeredById: "triggeredBy",
+    threadId: "thread",
+};
+const workflowRunStubObjectSchema = baseStubSchema.extend({
+    status: workflowRunStatusSchema,
+    input: preprocess(nullishToNull, z.record(z.string(), z.any()).nullable()),
+    output: preprocess(nullishToNull, z.record(z.string(), z.any()).nullable()),
+    context: preprocess((value) => (value == null ? {} : value), z.record(z.string(), z.any())),
+    snapshot: preprocess(nullishToNull, z.any().nullable()),
+    stepLog: preprocess(nullishToNull, z.record(z.string(), z.any()).nullable()),
+    suspendedStep: preprocess(nullishToNull, z.string().nullable()),
+    suspensionReason: preprocess(nullishToNull, z.string().nullable()),
+    suspensionData: preprocess(nullishToNull, z.unknown().nullable()),
+    suspensionStepExecId: preprocess(nullishToNull, z.string().nullable()),
+    suspensionIndex: preprocess(nullishToNull, z.coerce.number().nullable()),
+    suspensionKey: preprocess(nullishToNull, z.string().nullable()),
+    suspensionAwaitResults: preprocess(nullishToNull, z.record(z.string(), z.any()).nullable()),
+    lastResumeData: preprocess(nullishToNull, z.unknown().nullable()),
+    error: preprocess(nullishToNull, z.string().nullable()),
+    suspendedAt: preprocess(nullishToNull, z.coerce.date().nullable()),
+    finishedAt: preprocess(nullishToNull, z.coerce.date().nullable()),
+    failedAt: preprocess(nullishToNull, z.coerce.date().nullable()),
+    duration: preprocess(nullishToNull, z.coerce.number().nullable()),
+    metadata: preprocess(nullishToNull, z.record(z.string(), z.any()).nullable()),
+});
+const withWorkflowRunDuration = (value) => {
+    const record = toRecord(value);
+    if (!record) {
+        return value;
+    }
+    const next = cloneWithPrototype(record);
+    next.duration = resolveRunDurationMs(next);
+    return next;
+};
+const nullableUserOrSubscriberSchema = preprocess((value) => (value == null ? null : parseUserOrSubscriber(value)), userOrSubscriberSchema.nullable());
+export const workflowRunStubSchema = preprocess(withWorkflowRunDuration, workflowRunStubObjectSchema);
+export const workflowRunSchema = preprocess((value) => withAliases(withWorkflowRunDuration(value), workflowRunAliasMap), workflowRunStubObjectSchema.extend({
+    workflow: preprocess((value) => (value == null ? null : asId(value)), z.string()),
+    workflowVersion: preprocess((value) => (value == null ? null : asId(value)), z.string().nullable()),
+    triggeredBy: preprocess((value) => (value == null ? null : asId(value)), z.string().nullable()),
+}));
+export const workflowRunFullSchema = preprocess((value) => withWorkflowRunDuration(value), workflowRunStubObjectSchema.extend({
+    workflow: workflowSchema,
+    workflowVersion: z
+        .lazy(() => workflowVersionSchema)
+        .nullable()
+        .optional(),
+    triggeredBy: nullableUserOrSubscriberSchema,
+    thread: threadSchema.nullable().optional(),
+}));

package/dist/esm/workflow/workflow-version.js

@@ -0,0 +1,36 @@
+/*
+ * 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 { workflowVersionActionSchema } from "./domain";
+import { nullishToNull } from "./helpers";
+import { workflowSchema } from "./workflow";
+const workflowVersionAliasMap = {
+    parentVersionId: "parentVersion",
+    workflowId: "workflow",
+    createdById: "createdBy",
+};
+const workflowVersionStubObjectSchema = baseStubSchema.extend({
+    version: z.coerce.number(),
+    definitionYml: z.string(),
+    checksum: z.string(),
+    message: preprocess(nullishToNull, z.string().nullable()),
+    action: preprocess(nullishToNull, workflowVersionActionSchema.nullable()),
+});
+export const workflowVersionStubSchema = workflowVersionStubObjectSchema;
+export const workflowVersionSchema = preprocess((value) => withAliases(value, workflowVersionAliasMap), workflowVersionStubObjectSchema.extend({
+    parentVersion: preprocess((value) => (value == null ? null : asId(value)), z.string().nullable()),
+    workflow: preprocess((value) => (value == null ? null : asId(value)), z.string()),
+    createdBy: preprocess((value) => (value == null ? null : asId(value)), z.string().nullable()),
+}));
+export const workflowVersionFullSchema = workflowVersionStubObjectSchema.extend({
+    parentVersion: preprocess(nullishToNull, z.lazy(() => workflowVersionSchema).nullable()),
+    workflow: z.lazy(() => workflowSchema),
+    createdBy: preprocess((value) => (value == null ? null : value), z.lazy(() => userSchema).nullable()),
+});

package/dist/esm/workflow/workflow.js

@@ -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";
+import { asId, withAliases } from "../shared/aliases";
+import { baseStubSchema } from "../shared/base";
+import { cloneWithPrototype, toRecord } from "../shared/object";
+import { preprocess } from "../shared/preprocess";
+import { userSchema } from "../user/user";
+import { directionTypeSchema, workflowTypeSchema } from "./domain";
+import { nullishToNull } from "./helpers";
+import { workflowVersionSchema } from "./workflow-version";
+const workflowAliasMap = {
+    currentVersionId: "currentVersion",
+    publishedVersionId: "publishedVersion",
+    createdById: "createdBy",
+};
+const workflowStubObjectSchema = baseStubSchema.extend({
+    name: z.string(),
+    description: preprocess(nullishToNull, z.string().nullable()),
+    type: workflowTypeSchema,
+    schedule: preprocess(nullishToNull, z.string().nullable()),
+    inputSchema: z.any(),
+    builtin: z.coerce.boolean(),
+    x: z.coerce.number(),
+    y: z.coerce.number(),
+    zoom: z.coerce.number(),
+    direction: directionTypeSchema,
+});
+const withWorkflowAliases = (value) => {
+    const original = toRecord(value);
+    const aliased = withAliases(value, workflowAliasMap);
+    const record = toRecord(aliased);
+    if (!record) {
+        return aliased;
+    }
+    const next = cloneWithPrototype(record);
+    const hasExplicitCurrentVersion = !!original && "currentVersion" in original;
+    const hasExplicitPublishedVersion = !!original && "publishedVersion" in original;
+    const hasCurrentVersion = next.currentVersion != null;
+    if (!hasExplicitCurrentVersion && next.currentVersion == null) {
+        delete next.currentVersion;
+    }
+    if (!hasExplicitPublishedVersion &&
+        next.publishedVersion == null &&
+        !hasCurrentVersion) {
+        delete next.publishedVersion;
+    }
+    return next;
+};
+const workflowDefinitionSchema = z.any();
+const withWorkflowDerivedFields = (value, parseDefinition) => {
+    const record = toRecord(value);
+    if (!record) {
+        return value;
+    }
+    const next = cloneWithPrototype(record);
+    const currentVersion = toRecord(next.currentVersion);
+    const currentDefinitionYml = typeof next.definitionYml === "string"
+        ? next.definitionYml
+        : typeof currentVersion?.definitionYml === "string"
+            ? currentVersion.definitionYml
+            : undefined;
+    if (next.definitionYml === undefined && currentDefinitionYml !== undefined) {
+        next.definitionYml = currentDefinitionYml;
+    }
+    if (next.definition === undefined &&
+        typeof currentDefinitionYml === "string" &&
+        currentDefinitionYml.trim() !== "" &&
+        parseDefinition) {
+        next.definition = parseDefinition(currentDefinitionYml);
+    }
+    return next;
+};
+const workflowFullObjectSchema = workflowStubObjectSchema.extend({
+    currentVersion: preprocess((value) => (value == null ? null : value), z.lazy(() => workflowVersionSchema).nullable()),
+    publishedVersion: preprocess((value) => (value == null ? null : value), z.lazy(() => workflowVersionSchema).nullable()),
+    createdBy: preprocess((value) => (value == null ? null : value), z.lazy(() => userSchema).nullable()),
+    definitionYml: preprocess((value) => (value == null ? undefined : value), z.string().optional()).optional(),
+    definition: preprocess((value) => (value == null ? undefined : value), workflowDefinitionSchema.optional()).optional(),
+});
+export const workflowStubSchema = workflowStubObjectSchema;
+export const workflowSchema = preprocess(withWorkflowAliases, workflowStubObjectSchema.extend({
+    currentVersion: preprocess((value) => value === undefined ? undefined : value == null ? null : asId(value), z.string().nullable().optional()).optional(),
+    publishedVersion: preprocess((value) => value === undefined ? undefined : value == null ? null : asId(value), z.string().nullable().optional()).optional(),
+    createdBy: preprocess((value) => (value == null ? null : asId(value)), z.string().nullable()),
+    runAfterMs: preprocess((value) => (value == null ? 0 : value), z.coerce.number()),
+}));
+export const createWorkflowFullSchema = (options) => {
+    return preprocess((value) => withWorkflowDerivedFields(value, options?.parseDefinition), workflowFullObjectSchema);
+};
+export const workflowFullSchema = createWorkflowFullSchema();

package/dist/types/analytics/index.d.ts

@@ -0,0 +1,3 @@
+export { integrationHealthItemSchema, integrationHealthKindSchema, integrationHealthResponseSchema, integrationHealthStatusSchema, type IntegrationHealthItem, type IntegrationHealthKind, type IntegrationHealthResponse, type IntegrationHealthStatus, } from "./integration-health";
+export { StatsType, statsFullSchema, statsSchema, statsStubSchema, type Stats, type StatsFull, type StatsStub, } from "./stats";
+//# sourceMappingURL=index.d.ts.map

package/dist/types/analytics/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/analytics/index.ts"],"names":[],"mappings":"AAMA,OAAO,EACL,2BAA2B,EAC3B,2BAA2B,EAC3B,+BAA+B,EAC/B,6BAA6B,EAC7B,KAAK,qBAAqB,EAC1B,KAAK,qBAAqB,EAC1B,KAAK,yBAAyB,EAC9B,KAAK,uBAAuB,GAC7B,MAAM,sBAAsB,CAAC;AAE9B,OAAO,EACL,SAAS,EACT,eAAe,EACf,WAAW,EACX,eAAe,EACf,KAAK,KAAK,EACV,KAAK,SAAS,EACd,KAAK,SAAS,GACf,MAAM,SAAS,CAAC"}

package/dist/types/analytics/integration-health.d.ts

@@ -0,0 +1,55 @@
+import { z } from "zod";
+export declare const integrationHealthStatusSchema: z.ZodEnum<{
+    healthy: "healthy";
+    warning: "warning";
+    unhealthy: "unhealthy";
+    disabled: "disabled";
+}>;
+export declare const integrationHealthKindSchema: z.ZodEnum<{
+    channel: "channel";
+    service: "service";
+}>;
+export declare const integrationHealthItemSchema: z.ZodObject<{
+    id: z.ZodString;
+    kind: z.ZodEnum<{
+        channel: "channel";
+        service: "service";
+    }>;
+    name: z.ZodString;
+    status: z.ZodEnum<{
+        healthy: "healthy";
+        warning: "warning";
+        unhealthy: "unhealthy";
+        disabled: "disabled";
+    }>;
+    checkedAt: z.ZodString;
+    reason: z.ZodOptional<z.ZodString>;
+    message: z.ZodOptional<z.ZodString>;
+    details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+export declare const integrationHealthResponseSchema: z.ZodObject<{
+    checkedAt: z.ZodString;
+    integrations: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodEnum<{
+            channel: "channel";
+            service: "service";
+        }>;
+        name: z.ZodString;
+        status: z.ZodEnum<{
+            healthy: "healthy";
+            warning: "warning";
+            unhealthy: "unhealthy";
+            disabled: "disabled";
+        }>;
+        checkedAt: z.ZodString;
+        reason: z.ZodOptional<z.ZodString>;
+        message: z.ZodOptional<z.ZodString>;
+        details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type IntegrationHealthStatus = z.infer<typeof integrationHealthStatusSchema>;
+export type IntegrationHealthKind = z.infer<typeof integrationHealthKindSchema>;
+export type IntegrationHealthItem = z.infer<typeof integrationHealthItemSchema>;
+export type IntegrationHealthResponse = z.infer<typeof integrationHealthResponseSchema>;
+//# sourceMappingURL=integration-health.d.ts.map

package/dist/types/analytics/integration-health.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"integration-health.d.ts","sourceRoot":"","sources":["../../../src/analytics/integration-health.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,6BAA6B;;;;;EAKxC,CAAC;AAEH,eAAO,MAAM,2BAA2B;;;EAAiC,CAAC;AAE1E,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;iBAStC,CAAC;AAEH,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;iBAG1C,CAAC;AAEH,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAC3C,OAAO,6BAA6B,CACrC,CAAC;AAEF,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAEhF,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAEhF,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAC7C,OAAO,+BAA+B,CACvC,CAAC"}