@headless-lms/server 0.1.0

package/dist/http/routes.js

@@ -0,0 +1,37 @@
+import { coursesRoutes } from "./routes/courses.js";
+import { downloadsRoutes } from "./routes/downloads.js";
+import { learnRoutes } from "./routes/learn/index.js";
+import { discussionRoutes } from "./routes/discussion.js";
+import { activitiesRoutes } from "./routes/activities.js";
+import { studentsRoutes } from "./routes/students.js";
+import { entitlementsRoutes } from "./routes/entitlements.js";
+import { automationsRoutes } from "./routes/automations.js";
+import { organizationsRoutes } from "./routes/organizations.js";
+import { dashboardRoutes } from "./routes/dashboard.js";
+import { assetsRoutes } from "./routes/assets.js";
+import { integrationsRoutes } from "./routes/integrations.js";
+//#region src/http/routes.ts
+function registerRoutes(app, container) {
+	app.get("/health", async () => ({ status: "ok" }));
+	app.register(async (instance) => {
+		await organizationsRoutes(instance, container);
+	});
+	app.register(async (instance) => {
+		instance.addHook("onRequest", instance.requireOrgSession);
+		await coursesRoutes(instance, container);
+		await downloadsRoutes(instance, container);
+		await learnRoutes(instance, container);
+		await discussionRoutes(instance, container);
+		await activitiesRoutes(instance, container);
+		await studentsRoutes(instance, container);
+		await entitlementsRoutes(instance, container);
+		await automationsRoutes(instance, container);
+		await dashboardRoutes(instance, container);
+		await assetsRoutes(instance, container);
+		await integrationsRoutes(instance, container);
+	});
+}
+//#endregion
+export { registerRoutes };
+
+//# sourceMappingURL=routes.js.map

package/dist/http/routes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"routes.js","names":[],"sources":["../../src/http/routes.ts"],"sourcesContent":["import type { FastifyInstance } from 'fastify';\nimport type { Container } from '../app/container.js';\nimport { coursesRoutes } from './routes/courses.js';\nimport { downloadsRoutes } from './routes/downloads.js';\nimport { learnRoutes } from './routes/learn/index.js';\nimport { discussionRoutes } from './routes/discussion.js';\nimport { activitiesRoutes } from './routes/activities.js';\nimport { studentsRoutes } from './routes/students.js';\nimport { entitlementsRoutes } from './routes/entitlements.js';\nimport { automationsRoutes } from './routes/automations.js';\nimport { organizationsRoutes } from './routes/organizations.js';\nimport { dashboardRoutes } from './routes/dashboard.js';\nimport { assetsRoutes } from './routes/assets.js';\nimport { integrationsRoutes } from './routes/integrations.js';\n\nexport function registerRoutes(\n  app: FastifyInstance,\n  container: Container,\n): void {\n  app.get('/health', async () => ({ status: 'ok' }));\n\n  app.register(async (instance) => {\n    // instance.addHook('onRequest', instance.requireSession);\n    await organizationsRoutes(instance, container);\n  });\n\n  app.register(async (instance) => {\n    instance.addHook('onRequest', instance.requireOrgSession);\n    await coursesRoutes(instance, container);\n    await downloadsRoutes(instance, container);\n    await learnRoutes(instance, container);\n    await discussionRoutes(instance, container);\n    await activitiesRoutes(instance, container);\n    await studentsRoutes(instance, container);\n    await entitlementsRoutes(instance, container);\n    await automationsRoutes(instance, container);\n    await dashboardRoutes(instance, container);\n    await assetsRoutes(instance, container);\n    await integrationsRoutes(instance, container);\n  });\n}\n"],"mappings":";;;;;;;;;;;;;AAeA,SAAgB,eACd,KACA,WACM;CACN,IAAI,IAAI,WAAW,aAAa,EAAE,QAAQ,KAAK,EAAE;CAEjD,IAAI,SAAS,OAAO,aAAa;EAE/B,MAAM,oBAAoB,UAAU,SAAS;CAC/C,CAAC;CAED,IAAI,SAAS,OAAO,aAAa;EAC/B,SAAS,QAAQ,aAAa,SAAS,iBAAiB;EACxD,MAAM,cAAc,UAAU,SAAS;EACvC,MAAM,gBAAgB,UAAU,SAAS;EACzC,MAAM,YAAY,UAAU,SAAS;EACrC,MAAM,iBAAiB,UAAU,SAAS;EAC1C,MAAM,iBAAiB,UAAU,SAAS;EAC1C,MAAM,eAAe,UAAU,SAAS;EACxC,MAAM,mBAAmB,UAAU,SAAS;EAC5C,MAAM,kBAAkB,UAAU,SAAS;EAC3C,MAAM,gBAAgB,UAAU,SAAS;EACzC,MAAM,aAAa,UAAU,SAAS;EACtC,MAAM,mBAAmB,UAAU,SAAS;CAC9C,CAAC;AACH"}

package/dist/http/schemas/activities.d.ts

@@ -0,0 +1,69 @@
+import { z } from "zod";
+//#region src/http/schemas/activities.d.ts
+declare const Activity: z.ZodObject<{
+  orgId: z.ZodString;
+  id: z.ZodString;
+  moduleId: z.ZodString;
+  courseId: z.ZodString;
+  seq: z.ZodNumber;
+  settings: z.ZodNullable<z.ZodType<import("@headless-lms/core/types").JsonValue, unknown, z.core.$ZodTypeInternals<import("@headless-lms/core/types").JsonValue, unknown>>>;
+  createdAt: z.ZodCoercedDate<unknown>;
+  updatedAt: z.ZodCoercedDate<unknown>;
+}, z.core.$strict>;
+type Activity = z.infer<typeof Activity>;
+declare const Module: z.ZodObject<{
+  orgId: z.ZodString;
+  id: z.ZodString;
+  courseId: z.ZodString;
+  title: z.ZodString;
+  seq: z.ZodNumber;
+  createdAt: z.ZodCoercedDate<unknown>;
+  updatedAt: z.ZodCoercedDate<unknown>;
+}, z.core.$strict>;
+type Module = z.infer<typeof Module>;
+/** Module/activity-write endpoints return the full, reordered module list. */
+declare const ModuleList: z.ZodArray<z.ZodObject<{
+  orgId: z.ZodString;
+  id: z.ZodString;
+  courseId: z.ZodString;
+  title: z.ZodString;
+  seq: z.ZodNumber;
+  createdAt: z.ZodCoercedDate<unknown>;
+  updatedAt: z.ZodCoercedDate<unknown>;
+}, z.core.$strict>>;
+type ModuleList = z.infer<typeof ModuleList>;
+declare const CourseIdPathParam: z.ZodObject<{
+  courseId: z.ZodString;
+}, z.core.$strip>;
+type CourseIdPathParam = z.infer<typeof CourseIdPathParam>;
+declare const ModulePathParam: z.ZodObject<{
+  courseId: z.ZodString;
+  moduleId: z.ZodString;
+}, z.core.$strip>;
+type ModulePathParam = z.infer<typeof ModulePathParam>;
+declare const ActivityPathParam: z.ZodObject<{
+  courseId: z.ZodString;
+  moduleId: z.ZodString;
+  activityId: z.ZodString;
+}, z.core.$strip>;
+type ActivityPathParam = z.infer<typeof ActivityPathParam>;
+declare const CreateModule: z.ZodObject<{
+  title: z.ZodString;
+}, z.core.$strip>;
+type CreateModule = z.infer<typeof CreateModule>;
+declare const UpdateModule: z.ZodObject<{
+  title: z.ZodString;
+}, z.core.$strip>;
+type UpdateModule = z.infer<typeof UpdateModule>;
+declare const ReorderInput: z.ZodObject<{
+  orderedIds: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+type ReorderInput = z.infer<typeof ReorderInput>;
+declare const SaveActivity: z.ZodObject<{
+  settings: z.ZodOptional<z.ZodType<import("@headless-lms/core/types").JsonValue, unknown, z.core.$ZodTypeInternals<import("@headless-lms/core/types").JsonValue, unknown>>>;
+  assetIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+type SaveActivity = z.infer<typeof SaveActivity>;
+//#endregion
+export { Activity, ActivityPathParam, CourseIdPathParam, CreateModule, Module, ModuleList, ModulePathParam, ReorderInput, SaveActivity, UpdateModule };
+//# sourceMappingURL=activities.d.ts.map

package/dist/http/schemas/activities.js

@@ -0,0 +1,25 @@
+import { z } from "zod";
+import { activitySchema, moduleSchema, saveActivityInputSchema } from "@headless-lms/core/schemas";
+//#region src/http/schemas/activities.ts
+const Activity = activitySchema;
+const Module = moduleSchema;
+/** Module/activity-write endpoints return the full, reordered module list. */
+const ModuleList = z.array(Module);
+const CourseIdPathParam = z.object({ courseId: z.string() });
+const ModulePathParam = z.object({
+	courseId: z.string(),
+	moduleId: z.string()
+});
+const ActivityPathParam = z.object({
+	courseId: z.string(),
+	moduleId: z.string(),
+	activityId: z.string()
+});
+const CreateModule = z.object({ title: z.string().min(1) });
+const UpdateModule = z.object({ title: z.string().min(1) });
+const ReorderInput = z.object({ orderedIds: z.array(z.string()) });
+const SaveActivity = saveActivityInputSchema;
+//#endregion
+export { Activity, ActivityPathParam, CourseIdPathParam, CreateModule, Module, ModuleList, ModulePathParam, ReorderInput, SaveActivity, UpdateModule };
+
+//# sourceMappingURL=activities.js.map

package/dist/http/schemas/activities.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"activities.js","names":[],"sources":["../../../src/http/schemas/activities.ts"],"sourcesContent":["// Course modules + activities resource schemas. A module holds an ordered list\n// of activities directly; each activity is a uniform, orderable unit placing an\n// opaque settings blob at a position (`seq`) with a set of linked assets.\nimport { z } from \"zod\";\nimport {\n  activitySchema,\n  moduleSchema,\n  saveActivityInputSchema,\n} from \"@headless-lms/core/schemas\";\n\nexport const Activity = activitySchema;\nexport type Activity = z.infer<typeof Activity>;\n\nexport const Module = moduleSchema;\nexport type Module = z.infer<typeof Module>;\n\n/** Module/activity-write endpoints return the full, reordered module list. */\nexport const ModuleList = z.array(Module);\nexport type ModuleList = z.infer<typeof ModuleList>;\n\nexport const CourseIdPathParam = z.object({ courseId: z.string() });\nexport type CourseIdPathParam = z.infer<typeof CourseIdPathParam>;\n\nexport const ModulePathParam = z.object({ courseId: z.string(), moduleId: z.string() });\nexport type ModulePathParam = z.infer<typeof ModulePathParam>;\n\nexport const ActivityPathParam = z.object({\n  courseId: z.string(),\n  moduleId: z.string(),\n  activityId: z.string(),\n});\nexport type ActivityPathParam = z.infer<typeof ActivityPathParam>;\n\nexport const CreateModule = z.object({ title: z.string().min(1) });\nexport type CreateModule = z.infer<typeof CreateModule>;\n\nexport const UpdateModule = z.object({ title: z.string().min(1) });\nexport type UpdateModule = z.infer<typeof UpdateModule>;\n\nexport const ReorderInput = z.object({ orderedIds: z.array(z.string()) });\nexport type ReorderInput = z.infer<typeof ReorderInput>;\n\nexport const SaveActivity = saveActivityInputSchema;\nexport type SaveActivity = z.infer<typeof SaveActivity>;\n"],"mappings":";;;AAUA,MAAa,WAAW;AAGxB,MAAa,SAAS;;AAItB,MAAa,aAAa,EAAE,MAAM,MAAM;AAGxC,MAAa,oBAAoB,EAAE,OAAO,EAAE,UAAU,EAAE,OAAO,EAAE,CAAC;AAGlE,MAAa,kBAAkB,EAAE,OAAO;CAAE,UAAU,EAAE,OAAO;CAAG,UAAU,EAAE,OAAO;AAAE,CAAC;AAGtF,MAAa,oBAAoB,EAAE,OAAO;CACxC,UAAU,EAAE,OAAO;CACnB,UAAU,EAAE,OAAO;CACnB,YAAY,EAAE,OAAO;AACvB,CAAC;AAGD,MAAa,eAAe,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,EAAE,CAAC;AAGjE,MAAa,eAAe,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,EAAE,CAAC;AAGjE,MAAa,eAAe,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC;AAGxE,MAAa,eAAe"}

package/dist/http/schemas/assets.d.ts

@@ -0,0 +1,142 @@
+import { z } from "zod";
+//#region src/http/schemas/assets.d.ts
+declare const AssetKind: z.ZodEnum<{
+  download: "download";
+  video: "video";
+  content: "content";
+}>;
+type AssetKind = z.infer<typeof AssetKind>;
+declare const AssetStatus: z.ZodEnum<{
+  pending: "pending";
+  ready: "ready";
+}>;
+type AssetStatus = z.infer<typeof AssetStatus>;
+declare const Asset: z.ZodObject<{
+  orgId: z.ZodString;
+  id: z.ZodString;
+  key: z.ZodString;
+  kind: z.ZodEnum<{
+    download: "download";
+    video: "video";
+    content: "content";
+  }>;
+  filename: z.ZodString;
+  contentType: z.ZodString;
+  size: z.ZodNumber;
+  status: z.ZodEnum<{
+    pending: "pending";
+    ready: "ready";
+  }>;
+  uploadedBy: z.ZodString;
+  createdAt: z.ZodCoercedDate<unknown>;
+}, z.core.$strict>;
+type Asset = z.infer<typeof Asset>;
+declare const AssetsQuery: z.ZodObject<{
+  page: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+  pageSize: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+  search: z.ZodOptional<z.ZodString>;
+  sort: z.ZodOptional<z.ZodString>;
+  kind: z.ZodOptional<z.ZodEnum<{
+    download: "download";
+    video: "video";
+    content: "content";
+  }>>;
+}, z.core.$strip>;
+type AssetsQuery = z.infer<typeof AssetsQuery>;
+declare const AssetsPage: z.ZodObject<{
+  rows: z.ZodArray<z.ZodObject<{
+    orgId: z.ZodString;
+    id: z.ZodString;
+    key: z.ZodString;
+    kind: z.ZodEnum<{
+      download: "download";
+      video: "video";
+      content: "content";
+    }>;
+    filename: z.ZodString;
+    contentType: z.ZodString;
+    size: z.ZodNumber;
+    status: z.ZodEnum<{
+      pending: "pending";
+      ready: "ready";
+    }>;
+    uploadedBy: z.ZodString;
+    createdAt: z.ZodCoercedDate<unknown>;
+  }, z.core.$strict>>;
+  total: z.ZodNumber;
+  page: z.ZodNumber;
+  pageSize: z.ZodNumber;
+}, z.core.$strip>;
+type AssetsPage = z.infer<typeof AssetsPage>;
+declare const AssetIdParam: z.ZodObject<{
+  id: z.ZodString;
+}, z.core.$strip>;
+type AssetIdParam = z.infer<typeof AssetIdParam>;
+/** Register an asset and get a presigned upload URL. */
+declare const RequestUpload: z.ZodObject<{
+  filename: z.ZodString;
+  contentType: z.ZodString;
+  kind: z.ZodEnum<{
+    download: "download";
+    video: "video";
+    content: "content";
+  }>;
+}, z.core.$strip>;
+type RequestUpload = z.infer<typeof RequestUpload>;
+declare const UploadTicket: z.ZodObject<{
+  asset: z.ZodObject<{
+    orgId: z.ZodString;
+    id: z.ZodString;
+    key: z.ZodString;
+    kind: z.ZodEnum<{
+      download: "download";
+      video: "video";
+      content: "content";
+    }>;
+    filename: z.ZodString;
+    contentType: z.ZodString;
+    size: z.ZodNumber;
+    status: z.ZodEnum<{
+      pending: "pending";
+      ready: "ready";
+    }>;
+    uploadedBy: z.ZodString;
+    createdAt: z.ZodCoercedDate<unknown>;
+  }, z.core.$strict>;
+  uploadUrl: z.ZodString;
+  method: z.ZodLiteral<"PUT">;
+  expiresInSeconds: z.ZodNumber;
+  headers: z.ZodRecord<z.ZodString, z.ZodString>;
+}, z.core.$strict>;
+type UploadTicket = z.infer<typeof UploadTicket>;
+/** Optional override of the download filename (Content-Disposition). */
+declare const RequestDownload: z.ZodObject<{
+  filename: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type RequestDownload = z.infer<typeof RequestDownload>;
+declare const DownloadTicket: z.ZodObject<{
+  url: z.ZodString;
+  asset: z.ZodObject<{
+    orgId: z.ZodString;
+    id: z.ZodString;
+    key: z.ZodString;
+    kind: z.ZodEnum<{
+      download: "download";
+      video: "video";
+      content: "content";
+    }>;
+    filename: z.ZodString;
+    contentType: z.ZodString;
+    size: z.ZodNumber;
+    status: z.ZodEnum<{
+      pending: "pending";
+      ready: "ready";
+    }>;
+    uploadedBy: z.ZodString;
+    createdAt: z.ZodCoercedDate<unknown>;
+  }, z.core.$strict>;
+}, z.core.$strict>;
+type DownloadTicket = z.infer<typeof DownloadTicket>;
+//#endregion
+export { Asset, AssetIdParam, AssetKind, AssetStatus, AssetsPage, AssetsQuery, DownloadTicket, RequestDownload, RequestUpload, UploadTicket };
+//# sourceMappingURL=assets.d.ts.map

package/dist/http/schemas/assets.js

@@ -0,0 +1,24 @@
+import { ListQuery, paginated } from "./shared.js";
+import { z } from "zod";
+import { assetKindSchema, assetSchema, assetStatusSchema, downloadTicketSchema, uploadTicketSchema } from "@headless-lms/core/schemas";
+//#region src/http/schemas/assets.ts
+const AssetKind = assetKindSchema;
+const AssetStatus = assetStatusSchema;
+const Asset = assetSchema;
+const AssetsQuery = ListQuery.extend({ kind: AssetKind.optional() });
+const AssetsPage = paginated(Asset);
+const AssetIdParam = z.object({ id: z.string() });
+/** Register an asset and get a presigned upload URL. */
+const RequestUpload = z.object({
+	filename: z.string().min(1),
+	contentType: z.string().min(1),
+	kind: AssetKind
+});
+const UploadTicket = uploadTicketSchema;
+/** Optional override of the download filename (Content-Disposition). */
+const RequestDownload = z.object({ filename: z.string().optional() });
+const DownloadTicket = downloadTicketSchema;
+//#endregion
+export { Asset, AssetIdParam, AssetKind, AssetStatus, AssetsPage, AssetsQuery, DownloadTicket, RequestDownload, RequestUpload, UploadTicket };
+
+//# sourceMappingURL=assets.js.map

package/dist/http/schemas/assets.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"assets.js","names":[],"sources":["../../../src/http/schemas/assets.ts"],"sourcesContent":["// Assets (media library) resource schemas. An Asset is a tracked object in\n// private storage; files are uploaded via a presigned PUT and served via a\n// presigned GET. Domain objects (e.g. a lesson) reference an asset by id.\n// The Asset payload shape is owned by @headless-lms/core/schemas; route-local\n// schemas define endpoint-only concerns such as params and pagination.\nimport { z } from \"zod\";\nimport {\n  assetKindSchema,\n  assetSchema,\n  assetStatusSchema,\n  downloadTicketSchema,\n  uploadTicketSchema,\n} from \"@headless-lms/core/schemas\";\nimport { ListQuery, paginated } from \"./shared.js\";\n\nexport const AssetKind = assetKindSchema;\nexport type AssetKind = z.infer<typeof AssetKind>;\n\nexport const AssetStatus = assetStatusSchema;\nexport type AssetStatus = z.infer<typeof AssetStatus>;\n\nexport const Asset = assetSchema;\nexport type Asset = z.infer<typeof Asset>;\n\nexport const AssetsQuery = ListQuery.extend({ kind: AssetKind.optional() });\nexport type AssetsQuery = z.infer<typeof AssetsQuery>;\n\nexport const AssetsPage = paginated(Asset);\nexport type AssetsPage = z.infer<typeof AssetsPage>;\n\nexport const AssetIdParam = z.object({ id: z.string() });\nexport type AssetIdParam = z.infer<typeof AssetIdParam>;\n\n/** Register an asset and get a presigned upload URL. */\nexport const RequestUpload = z.object({\n  filename: z.string().min(1),\n  contentType: z.string().min(1),\n  kind: AssetKind,\n});\nexport type RequestUpload = z.infer<typeof RequestUpload>;\n\nexport const UploadTicket = uploadTicketSchema;\nexport type UploadTicket = z.infer<typeof UploadTicket>;\n\n/** Optional override of the download filename (Content-Disposition). */\nexport const RequestDownload = z.object({ filename: z.string().optional() });\nexport type RequestDownload = z.infer<typeof RequestDownload>;\n\nexport const DownloadTicket = downloadTicketSchema;\nexport type DownloadTicket = z.infer<typeof DownloadTicket>;\n"],"mappings":";;;;AAeA,MAAa,YAAY;AAGzB,MAAa,cAAc;AAG3B,MAAa,QAAQ;AAGrB,MAAa,cAAc,UAAU,OAAO,EAAE,MAAM,UAAU,SAAS,EAAE,CAAC;AAG1E,MAAa,aAAa,UAAU,KAAK;AAGzC,MAAa,eAAe,EAAE,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,CAAC;;AAIvD,MAAa,gBAAgB,EAAE,OAAO;CACpC,UAAU,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC;CAC1B,aAAa,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC;CAC7B,MAAM;AACR,CAAC;AAGD,MAAa,eAAe;;AAI5B,MAAa,kBAAkB,EAAE,OAAO,EAAE,UAAU,EAAE,OAAO,CAAC,CAAC,SAAS,EAAE,CAAC;AAG3E,MAAa,iBAAiB"}

package/dist/http/schemas/automations.d.ts

@@ -0,0 +1,154 @@
+import { z } from "zod";
+//#region src/http/schemas/automations.d.ts
+/** One step of an automation: which action, and its input per that action's inputSchema. */
+declare const AutomationAction: z.ZodObject<{
+  type: z.ZodString;
+  input: z.ZodRecord<z.ZodString, z.ZodType<import("@headless-lms/core/types").JsonValue, unknown, z.core.$ZodTypeInternals<import("@headless-lms/core/types").JsonValue, unknown>>>;
+}, z.core.$strict>;
+type AutomationAction = z.infer<typeof AutomationAction>;
+/** A domain event type, e.g. `entitlement.created`. */
+declare const AutomationTrigger: z.ZodString;
+type AutomationTrigger = z.infer<typeof AutomationTrigger>;
+declare const Automation: z.ZodObject<{
+  orgId: z.ZodString;
+  id: z.ZodString;
+  name: z.ZodString;
+  description: z.ZodNullable<z.ZodString>;
+  trigger: z.ZodString;
+  actions: z.ZodArray<z.ZodObject<{
+    type: z.ZodString;
+    input: z.ZodRecord<z.ZodString, z.ZodType<import("@headless-lms/core/types").JsonValue, unknown, z.core.$ZodTypeInternals<import("@headless-lms/core/types").JsonValue, unknown>>>;
+  }, z.core.$strict>>;
+  enabled: z.ZodBoolean;
+  createdAt: z.ZodCoercedDate<unknown>;
+  updatedAt: z.ZodCoercedDate<unknown>;
+}, z.core.$strict>;
+type Automation = z.infer<typeof Automation>;
+declare const CreateAutomationBody: z.ZodObject<{
+  name: z.ZodString;
+  description: z.ZodOptional<z.ZodString>;
+  trigger: z.ZodString;
+  actions: z.ZodArray<z.ZodObject<{
+    type: z.ZodString;
+    input: z.ZodRecord<z.ZodString, z.ZodType<import("@headless-lms/core/types").JsonValue, unknown, z.core.$ZodTypeInternals<import("@headless-lms/core/types").JsonValue, unknown>>>;
+  }, z.core.$strict>>;
+}, z.core.$strict>;
+type CreateAutomationBody = z.infer<typeof CreateAutomationBody>;
+declare const UpdateAutomationBody: z.ZodObject<{
+  name: z.ZodOptional<z.ZodString>;
+  description: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+  trigger: z.ZodOptional<z.ZodString>;
+  actions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+    type: z.ZodString;
+    input: z.ZodRecord<z.ZodString, z.ZodType<import("@headless-lms/core/types").JsonValue, unknown, z.core.$ZodTypeInternals<import("@headless-lms/core/types").JsonValue, unknown>>>;
+  }, z.core.$strict>>>;
+  enabled: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>;
+type UpdateAutomationBody = z.infer<typeof UpdateAutomationBody>;
+declare const AutomationIdParam: z.ZodObject<{
+  id: z.ZodString;
+}, z.core.$strip>;
+type AutomationIdParam = z.infer<typeof AutomationIdParam>;
+/** An action an automation can use: a built-in type (`sendEmail`) or a loaded
+ *  integration's own (`<integrationId>.<actionId>`). */
+declare const AvailableAction: z.ZodObject<{
+  type: z.ZodString;
+  description: z.ZodString;
+  inputSchema: z.ZodRecord<z.ZodString, z.ZodType<import("@headless-lms/core/types").JsonValue, unknown, z.core.$ZodTypeInternals<import("@headless-lms/core/types").JsonValue, unknown>>>;
+  source: z.ZodString;
+}, z.core.$strict>;
+type AvailableAction = z.infer<typeof AvailableAction>;
+/** Which domain events an automation can react to. */
+declare const AvailableTriggers: z.ZodObject<{
+  triggers: z.ZodArray<z.ZodObject<{
+    type: z.ZodString;
+    description: z.ZodString;
+  }, z.core.$strict>>;
+}, z.core.$strict>;
+type AvailableTriggers = z.infer<typeof AvailableTriggers>;
+declare const AutomationRunStatus: z.ZodEnum<{
+  completed: "completed";
+  running: "running";
+  failed: "failed";
+}>;
+type AutomationRunStatus = z.infer<typeof AutomationRunStatus>;
+declare const AutomationActionResult: z.ZodObject<{
+  index: z.ZodNumber;
+  type: z.ZodString;
+  status: z.ZodEnum<{
+    completed: "completed";
+    failed: "failed";
+  }>;
+  error: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+type AutomationActionResult = z.infer<typeof AutomationActionResult>;
+declare const AutomationRun: z.ZodObject<{
+  orgId: z.ZodString;
+  id: z.ZodString;
+  automationId: z.ZodString;
+  trigger: z.ZodString;
+  eventId: z.ZodString;
+  event: z.ZodType<import("@headless-lms/core/types").DomainEvent<unknown, string, number>, unknown, z.core.$ZodTypeInternals<import("@headless-lms/core/types").DomainEvent<unknown, string, number>, unknown>>;
+  status: z.ZodEnum<{
+    completed: "completed";
+    running: "running";
+    failed: "failed";
+  }>;
+  actionResults: z.ZodArray<z.ZodObject<{
+    index: z.ZodNumber;
+    type: z.ZodString;
+    status: z.ZodEnum<{
+      completed: "completed";
+      failed: "failed";
+    }>;
+    error: z.ZodOptional<z.ZodString>;
+  }, z.core.$strict>>;
+  startedAt: z.ZodCoercedDate<unknown>;
+  finishedAt: z.ZodNullable<z.ZodCoercedDate<unknown>>;
+}, z.core.$strict>;
+type AutomationRun = z.infer<typeof AutomationRun>;
+declare const AutomationRunsQuery: z.ZodObject<{
+  page: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+  pageSize: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+  search: z.ZodOptional<z.ZodString>;
+  sort: z.ZodOptional<z.ZodString>;
+  status: z.ZodOptional<z.ZodEnum<{
+    completed: "completed";
+    running: "running";
+    failed: "failed";
+  }>>;
+}, z.core.$strip>;
+type AutomationRunsQuery = z.infer<typeof AutomationRunsQuery>;
+declare const AutomationRunsPage: z.ZodObject<{
+  rows: z.ZodArray<z.ZodObject<{
+    orgId: z.ZodString;
+    id: z.ZodString;
+    automationId: z.ZodString;
+    trigger: z.ZodString;
+    eventId: z.ZodString;
+    event: z.ZodType<import("@headless-lms/core/types").DomainEvent<unknown, string, number>, unknown, z.core.$ZodTypeInternals<import("@headless-lms/core/types").DomainEvent<unknown, string, number>, unknown>>;
+    status: z.ZodEnum<{
+      completed: "completed";
+      running: "running";
+      failed: "failed";
+    }>;
+    actionResults: z.ZodArray<z.ZodObject<{
+      index: z.ZodNumber;
+      type: z.ZodString;
+      status: z.ZodEnum<{
+        completed: "completed";
+        failed: "failed";
+      }>;
+      error: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    startedAt: z.ZodCoercedDate<unknown>;
+    finishedAt: z.ZodNullable<z.ZodCoercedDate<unknown>>;
+  }, z.core.$strict>>;
+  total: z.ZodNumber;
+  page: z.ZodNumber;
+  pageSize: z.ZodNumber;
+}, z.core.$strip>;
+type AutomationRunsPage = z.infer<typeof AutomationRunsPage>;
+//#endregion
+export { Automation, AutomationAction, AutomationActionResult, AutomationIdParam, AutomationRun, AutomationRunStatus, AutomationRunsPage, AutomationRunsQuery, AutomationTrigger, AvailableAction, AvailableTriggers, CreateAutomationBody, UpdateAutomationBody };
+//# sourceMappingURL=automations.d.ts.map

package/dist/http/schemas/automations.js

@@ -0,0 +1,26 @@
+import { ListQuery, paginated } from "./shared.js";
+import { z } from "zod";
+import { automationActionResultSchema, automationActionSchema, automationRunSchema, automationRunStatusSchema, automationSchema, automationTriggerSchema, availableActionSchema, availableTriggersSchema, createAutomationInputSchema, updateAutomationInputSchema } from "@headless-lms/core/schemas";
+//#region src/http/schemas/automations.ts
+/** One step of an automation: which action, and its input per that action's inputSchema. */
+const AutomationAction = automationActionSchema;
+/** A domain event type, e.g. `entitlement.created`. */
+const AutomationTrigger = automationTriggerSchema;
+const Automation = automationSchema;
+const CreateAutomationBody = createAutomationInputSchema;
+const UpdateAutomationBody = updateAutomationInputSchema;
+const AutomationIdParam = z.object({ id: z.string() });
+/** An action an automation can use: a built-in type (`sendEmail`) or a loaded
+*  integration's own (`<integrationId>.<actionId>`). */
+const AvailableAction = availableActionSchema;
+/** Which domain events an automation can react to. */
+const AvailableTriggers = availableTriggersSchema;
+const AutomationRunStatus = automationRunStatusSchema;
+const AutomationActionResult = automationActionResultSchema;
+const AutomationRun = automationRunSchema;
+const AutomationRunsQuery = ListQuery.extend({ status: AutomationRunStatus.optional() });
+const AutomationRunsPage = paginated(AutomationRun);
+//#endregion
+export { Automation, AutomationAction, AutomationActionResult, AutomationIdParam, AutomationRun, AutomationRunStatus, AutomationRunsPage, AutomationRunsQuery, AutomationTrigger, AvailableAction, AvailableTriggers, CreateAutomationBody, UpdateAutomationBody };
+
+//# sourceMappingURL=automations.js.map

package/dist/http/schemas/automations.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"automations.js","names":[],"sources":["../../../src/http/schemas/automations.ts"],"sourcesContent":["// Automations resource schemas. An automation matches a trigger (a domain\n// event type) against enabled rules and runs an ordered list of actions;\n// every run is recorded. Payload shapes are owned by\n// @headless-lms/core/schemas; route-local schemas define endpoint-only\n// concerns such as params and pagination envelopes.\nimport { z } from \"zod\";\nimport {\n  automationActionResultSchema,\n  automationActionSchema,\n  automationRunSchema,\n  automationRunStatusSchema,\n  automationSchema,\n  automationTriggerSchema,\n  availableActionSchema,\n  availableTriggersSchema,\n  createAutomationInputSchema,\n  updateAutomationInputSchema,\n} from \"@headless-lms/core/schemas\";\nimport { ListQuery, paginated } from \"./shared.js\";\n\n/** One step of an automation: which action, and its input per that action's inputSchema. */\nexport const AutomationAction = automationActionSchema;\nexport type AutomationAction = z.infer<typeof AutomationAction>;\n\n/** A domain event type, e.g. `entitlement.created`. */\nexport const AutomationTrigger = automationTriggerSchema;\nexport type AutomationTrigger = z.infer<typeof AutomationTrigger>;\n\nexport const Automation = automationSchema;\nexport type Automation = z.infer<typeof Automation>;\n\nexport const CreateAutomationBody = createAutomationInputSchema;\nexport type CreateAutomationBody = z.infer<typeof CreateAutomationBody>;\n\nexport const UpdateAutomationBody = updateAutomationInputSchema;\nexport type UpdateAutomationBody = z.infer<typeof UpdateAutomationBody>;\n\nexport const AutomationIdParam = z.object({ id: z.string() });\nexport type AutomationIdParam = z.infer<typeof AutomationIdParam>;\n\n/** An action an automation can use: a built-in type (`sendEmail`) or a loaded\n *  integration's own (`<integrationId>.<actionId>`). */\nexport const AvailableAction = availableActionSchema;\nexport type AvailableAction = z.infer<typeof AvailableAction>;\n\n/** Which domain events an automation can react to. */\nexport const AvailableTriggers = availableTriggersSchema;\nexport type AvailableTriggers = z.infer<typeof AvailableTriggers>;\n\nexport const AutomationRunStatus = automationRunStatusSchema;\nexport type AutomationRunStatus = z.infer<typeof AutomationRunStatus>;\n\nexport const AutomationActionResult = automationActionResultSchema;\nexport type AutomationActionResult = z.infer<typeof AutomationActionResult>;\n\nexport const AutomationRun = automationRunSchema;\nexport type AutomationRun = z.infer<typeof AutomationRun>;\n\nexport const AutomationRunsQuery = ListQuery.extend({\n  status: AutomationRunStatus.optional(),\n});\nexport type AutomationRunsQuery = z.infer<typeof AutomationRunsQuery>;\n\nexport const AutomationRunsPage = paginated(AutomationRun);\nexport type AutomationRunsPage = z.infer<typeof AutomationRunsPage>;\n"],"mappings":";;;;;AAqBA,MAAa,mBAAmB;;AAIhC,MAAa,oBAAoB;AAGjC,MAAa,aAAa;AAG1B,MAAa,uBAAuB;AAGpC,MAAa,uBAAuB;AAGpC,MAAa,oBAAoB,EAAE,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,CAAC;;;AAK5D,MAAa,kBAAkB;;AAI/B,MAAa,oBAAoB;AAGjC,MAAa,sBAAsB;AAGnC,MAAa,yBAAyB;AAGtC,MAAa,gBAAgB;AAG7B,MAAa,sBAAsB,UAAU,OAAO,EAClD,QAAQ,oBAAoB,SAAS,EACvC,CAAC;AAGD,MAAa,qBAAqB,UAAU,aAAa"}

package/dist/http/schemas/content.d.ts

@@ -0,0 +1,113 @@
+import { z } from "zod";
+//#region src/http/schemas/content.d.ts
+declare const CourseStatus: z.ZodEnum<{
+  draft: "draft";
+  published: "published";
+}>;
+type CourseStatus = z.infer<typeof CourseStatus>;
+declare const CourseSettings: z.ZodObject<{
+  transcriptDownloads: z.ZodBoolean;
+  comments: z.ZodOptional<z.ZodObject<{
+    enabled: z.ZodBoolean;
+    threaded: z.ZodBoolean;
+    requireReview: z.ZodBoolean;
+    reactions: z.ZodBoolean;
+  }, z.core.$strict>>;
+}, z.core.$strict>;
+type CourseSettings = z.infer<typeof CourseSettings>;
+declare const PatchCourseSettings: z.ZodObject<{
+  transcriptDownloads: z.ZodOptional<z.ZodBoolean>;
+  comments: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+    enabled: z.ZodBoolean;
+    threaded: z.ZodBoolean;
+    requireReview: z.ZodBoolean;
+    reactions: z.ZodBoolean;
+  }, z.core.$strict>>>;
+}, z.core.$strict>;
+type PatchCourseSettings = z.infer<typeof PatchCourseSettings>;
+declare const Course: z.ZodObject<{
+  orgId: z.ZodString;
+  id: z.ZodString;
+  type: z.ZodLiteral<"course">;
+  title: z.ZodString;
+  slug: z.ZodString;
+  description: z.ZodString;
+  status: z.ZodEnum<{
+    draft: "draft";
+    published: "published";
+  }>;
+  category: z.ZodString;
+  thumbnailAssetId: z.ZodNullable<z.ZodString>;
+  settings: z.ZodType<import("@headless-lms/core/types").JsonValue, unknown, z.core.$ZodTypeInternals<import("@headless-lms/core/types").JsonValue, unknown>>;
+  createdAt: z.ZodCoercedDate<unknown>;
+  updatedAt: z.ZodCoercedDate<unknown>;
+}, z.core.$strict>;
+type Course = z.infer<typeof Course>;
+declare const CreateCourse: z.ZodObject<{
+  title: z.ZodString;
+  description: z.ZodDefault<z.ZodString>;
+  category: z.ZodDefault<z.ZodString>;
+}, z.core.$strip>;
+type CreateCourse = z.infer<typeof CreateCourse>;
+declare const UpdateCourse: z.ZodObject<{
+  title: z.ZodOptional<z.ZodString>;
+  description: z.ZodOptional<z.ZodDefault<z.ZodString>>;
+  category: z.ZodOptional<z.ZodDefault<z.ZodString>>;
+  status: z.ZodOptional<z.ZodEnum<{
+    draft: "draft";
+    published: "published";
+  }>>;
+  thumbnailAssetId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+  settings: z.ZodOptional<z.ZodObject<{
+    transcriptDownloads: z.ZodOptional<z.ZodBoolean>;
+    comments: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+      enabled: z.ZodBoolean;
+      threaded: z.ZodBoolean;
+      requireReview: z.ZodBoolean;
+      reactions: z.ZodBoolean;
+    }, z.core.$strict>>>;
+  }, z.core.$strict>>;
+}, z.core.$strip>;
+type UpdateCourse = z.infer<typeof UpdateCourse>;
+declare const CoursesQuery: z.ZodObject<{
+  page: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+  pageSize: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+  search: z.ZodOptional<z.ZodString>;
+  sort: z.ZodOptional<z.ZodString>;
+  status: z.ZodOptional<z.ZodEnum<{
+    draft: "draft";
+    published: "published";
+  }>>;
+  category: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type CoursesQuery = z.infer<typeof CoursesQuery>;
+declare const CoursesPage: z.ZodObject<{
+  rows: z.ZodArray<z.ZodObject<{
+    orgId: z.ZodString;
+    id: z.ZodString;
+    type: z.ZodLiteral<"course">;
+    title: z.ZodString;
+    slug: z.ZodString;
+    description: z.ZodString;
+    status: z.ZodEnum<{
+      draft: "draft";
+      published: "published";
+    }>;
+    category: z.ZodString;
+    thumbnailAssetId: z.ZodNullable<z.ZodString>;
+    settings: z.ZodType<import("@headless-lms/core/types").JsonValue, unknown, z.core.$ZodTypeInternals<import("@headless-lms/core/types").JsonValue, unknown>>;
+    createdAt: z.ZodCoercedDate<unknown>;
+    updatedAt: z.ZodCoercedDate<unknown>;
+  }, z.core.$strict>>;
+  total: z.ZodNumber;
+  page: z.ZodNumber;
+  pageSize: z.ZodNumber;
+}, z.core.$strip>;
+type CoursesPage = z.infer<typeof CoursesPage>;
+declare const CourseIdParam: z.ZodObject<{
+  id: z.ZodString;
+}, z.core.$strip>;
+type CourseIdParam = z.infer<typeof CourseIdParam>;
+//#endregion
+export { Course, CourseIdParam, CourseSettings, CourseStatus, CoursesPage, CoursesQuery, CreateCourse, PatchCourseSettings, UpdateCourse };
+//# sourceMappingURL=content.d.ts.map

package/dist/http/schemas/content.js

@@ -0,0 +1,29 @@
+import { ListQuery, paginated } from "./shared.js";
+import { z } from "zod";
+import { courseSchema, courseSettingsSchema, courseStatusSchema } from "@headless-lms/core/schemas";
+//#region src/http/schemas/content.ts
+const CourseStatus = courseStatusSchema;
+const CourseSettings = courseSettingsSchema;
+const PatchCourseSettings = CourseSettings.partial();
+const Course = courseSchema;
+const CreateCourse = z.object({
+	title: z.string().min(1),
+	description: z.string().default(""),
+	category: z.string().default("")
+});
+const UpdateCourse = CreateCourse.partial().extend({
+	status: CourseStatus.optional(),
+	/** null clears the cover. */
+	thumbnailAssetId: z.string().nullable().optional(),
+	settings: CourseSettings.partial().optional()
+});
+const CoursesQuery = ListQuery.extend({
+	status: CourseStatus.optional(),
+	category: z.string().optional()
+});
+const CoursesPage = paginated(Course);
+const CourseIdParam = z.object({ id: z.string() });
+//#endregion
+export { Course, CourseIdParam, CourseSettings, CourseStatus, CoursesPage, CoursesQuery, CreateCourse, PatchCourseSettings, UpdateCourse };
+
+//# sourceMappingURL=content.js.map

package/dist/http/schemas/content.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"content.js","names":[],"sources":["../../../src/http/schemas/content.ts"],"sourcesContent":["// Content resource schemas (courses). The Course payload shape is owned by\n// @headless-lms/core/schemas; route-local schemas define endpoint-only\n// concerns such as defaults, params, and pagination envelopes.\nimport { z } from \"zod\";\nimport {\n  courseSchema,\n  courseSettingsSchema,\n  courseStatusSchema,\n} from \"@headless-lms/core/schemas\";\nimport { ListQuery, paginated } from \"./shared.js\";\n\nexport const CourseStatus = courseStatusSchema;\nexport type CourseStatus = z.infer<typeof CourseStatus>;\n\nexport const CourseSettings = courseSettingsSchema;\nexport type CourseSettings = z.infer<typeof CourseSettings>;\n\nexport const PatchCourseSettings = CourseSettings.partial();\nexport type PatchCourseSettings = z.infer<typeof PatchCourseSettings>;\n\nexport const Course = courseSchema;\nexport type Course = z.infer<typeof Course>;\n\nexport const CreateCourse = z.object({\n  title: z.string().min(1),\n  description: z.string().default(\"\"),\n  category: z.string().default(\"\"),\n});\nexport type CreateCourse = z.infer<typeof CreateCourse>;\n\nexport const UpdateCourse = CreateCourse.partial().extend({\n  status: CourseStatus.optional(),\n  /** null clears the cover. */\n  thumbnailAssetId: z.string().nullable().optional(),\n  settings: CourseSettings.partial().optional(),\n});\nexport type UpdateCourse = z.infer<typeof UpdateCourse>;\n\nexport const CoursesQuery = ListQuery.extend({\n  status: CourseStatus.optional(),\n  category: z.string().optional(),\n});\nexport type CoursesQuery = z.infer<typeof CoursesQuery>;\n\nexport const CoursesPage = paginated(Course);\nexport type CoursesPage = z.infer<typeof CoursesPage>;\n\nexport const CourseIdParam = z.object({ id: z.string() });\nexport type CourseIdParam = z.infer<typeof CourseIdParam>;\n"],"mappings":";;;;AAWA,MAAa,eAAe;AAG5B,MAAa,iBAAiB;AAG9B,MAAa,sBAAsB,eAAe,QAAQ;AAG1D,MAAa,SAAS;AAGtB,MAAa,eAAe,EAAE,OAAO;CACnC,OAAO,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC;CACvB,aAAa,EAAE,OAAO,CAAC,CAAC,QAAQ,EAAE;CAClC,UAAU,EAAE,OAAO,CAAC,CAAC,QAAQ,EAAE;AACjC,CAAC;AAGD,MAAa,eAAe,aAAa,QAAQ,CAAC,CAAC,OAAO;CACxD,QAAQ,aAAa,SAAS;;CAE9B,kBAAkB,EAAE,OAAO,CAAC,CAAC,SAAS,CAAC,CAAC,SAAS;CACjD,UAAU,eAAe,QAAQ,CAAC,CAAC,SAAS;AAC9C,CAAC;AAGD,MAAa,eAAe,UAAU,OAAO;CAC3C,QAAQ,aAAa,SAAS;CAC9B,UAAU,EAAE,OAAO,CAAC,CAAC,SAAS;AAChC,CAAC;AAGD,MAAa,cAAc,UAAU,MAAM;AAG3C,MAAa,gBAAgB,EAAE,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,CAAC"}