@bernierllc/content-management-suite 0.4.2 → 0.7.0

package/dist/index.mjs

@@ -1,45 +1,10 @@
-"use client";
+// src/content-management-suite.ts
+import { EventEmitter } from "events";
 
-// src/types.ts
+// src/config.ts
 import { z } from "zod";
 var ContentManagementConfigSchema = z.object({
-  // Server Configuration
-  server: z.object({
-    port: z.number().default(3e3),
-    host: z.string().default("localhost"),
-    cors: z.object({
-      origin: z.union([z.string(), z.array(z.string())]).default("*"),
-      credentials: z.boolean().default(true)
-    }).default({}),
-    security: z.object({
-      helmet: z.boolean().default(true),
-      rateLimit: z.object({
-        enabled: z.boolean().default(true),
-        windowMs: z.number().default(15 * 60 * 1e3),
-        // 15 minutes
-        max: z.number().default(100)
-        // limit each IP to 100 requests per windowMs
-      }).default({})
-    }).default({})
-  }).default({}),
-  // Database Configuration
-  database: z.object({
-    type: z.enum(["sqlite", "postgresql", "mysql", "mongodb"]).default("sqlite"),
-    url: z.string().optional(),
-    host: z.string().default("localhost"),
-    port: z.number().optional(),
-    name: z.string().default("content_management"),
-    username: z.string().optional(),
-    password: z.string().optional(),
-    ssl: z.boolean().default(false),
-    pool: z.object({
-      min: z.number().default(2),
-      max: z.number().default(10)
-    }).default({})
-  }).default({}),
-  // Content Configuration
   content: z.object({
-    // Default editorial workflow
     defaultWorkflow: z.object({
       id: z.string().default("standard"),
       name: z.string().default("Standard Workflow"),
@@ -53,24 +18,8 @@ var ContentManagementConfigSchema = z.object({
         description: z.string().optional(),
         permissions: z.array(z.string()).default([])
       })).default([
-        {
-          id: "write",
-          name: "Write",
-          order: 1,
-          isPublishStage: false,
-          allowsScheduling: false,
-          description: "Write content",
-          permissions: ["content.edit"]
-        },
-        {
-          id: "publish",
-          name: "Publish",
-          order: 2,
-          isPublishStage: true,
-          allowsScheduling: true,
-          description: "Publish content",
-          permissions: ["content.publish"]
-        }
+        { id: "write", name: "Write", order: 1, isPublishStage: false, allowsScheduling: false, description: "Write content", permissions: ["content.edit"] },
+        { id: "publish", name: "Publish", order: 2, isPublishStage: true, allowsScheduling: true, description: "Publish content", permissions: ["content.publish"] }
       ]),
       transitions: z.array(z.object({
         id: z.string(),
@@ -79,34 +28,23 @@ var ContentManagementConfigSchema = z.object({
         description: z.string().optional(),
         permissions: z.array(z.string()).default([])
       })).default([
-        {
-          id: "write-to-publish",
-          from: "write",
-          to: "publish",
-          description: "Move from write to publish",
-          permissions: ["content.publish"]
-        }
+        { id: "write-to-publish", from: "write", to: "publish", description: "Move from write to publish", permissions: ["content.publish"] }
       ])
     }).default({}),
-    // Content types
     contentTypes: z.array(z.string()).default(["text", "image", "audio", "video"]),
-    // Auto-save configuration
     autoSave: z.object({
       enabled: z.boolean().default(true),
       debounceMs: z.number().default(1e3),
       maxRetries: z.number().default(3),
       backoffMs: z.number().default(1e3)
     }).default({}),
-    // Soft delete configuration
     softDelete: z.object({
       enabled: z.boolean().default(true),
       showDeletedToUsers: z.boolean().default(false),
       retentionDays: z.number().default(30)
     }).default({}),
-    // File upload configuration
     upload: z.object({
       maxFileSize: z.number().default(104857600),
-      // 100MB
       allowedTypes: z.array(z.string()).default([
         "image/jpeg",
         "image/png",
@@ -120,902 +58,1280 @@ var ContentManagementConfigSchema = z.object({
         "video/ogg"
       ]),
       storage: z.object({
-        type: z.enum(["local", "s3", "gcs", "azure"]).default("local"),
+        type: z.enum(["local", "s3"]).default("local"),
         path: z.string().default("./uploads"),
         bucket: z.string().optional(),
-        region: z.string().optional(),
-        accessKey: z.string().optional(),
-        secretKey: z.string().optional()
-      }).default({})
+        region: z.string().optional()
+      }).default({}).optional()
     }).default({})
   }).default({}),
-  // UI Configuration
-  ui: z.object({
-    theme: z.object({
-      mode: z.enum(["light", "dark", "auto"]).default("auto"),
-      primaryColor: z.string().default("#007bff"),
-      secondaryColor: z.string().default("#6c757d"),
-      accentColor: z.string().default("#17a2b8")
-    }).default({}),
-    editor: z.object({
-      showToolbar: z.boolean().default(true),
-      showStatusBar: z.boolean().default(true),
-      showWordCount: z.boolean().default(true),
-      showCharacterCount: z.boolean().default(true),
-      autoSave: z.boolean().default(true),
-      placeholder: z.string().default("Start writing your content...")
-    }).default({}),
-    list: z.object({
-      defaultView: z.enum(["table", "list", "grid", "kanban"]).default("table"),
-      pageSize: z.number().default(20),
-      showSearch: z.boolean().default(true),
-      showFilters: z.boolean().default(true),
-      showSorting: z.boolean().default(true),
-      showPagination: z.boolean().default(true)
+  database: z.object({
+    type: z.enum(["sqlite", "postgresql", "mysql", "mongodb"]).default("sqlite"),
+    url: z.string().optional(),
+    host: z.string().default("localhost"),
+    port: z.number().optional(),
+    name: z.string().default("content_management"),
+    username: z.string().optional(),
+    password: z.string().optional(),
+    ssl: z.boolean().default(false),
+    pool: z.object({
+      min: z.number().default(2),
+      max: z.number().default(10),
+      idleTimeoutMs: z.number().optional()
     }).default({})
   }).default({}),
-  // Integration Configuration
   integrations: z.object({
     neverAdmin: z.object({
       enabled: z.boolean().default(false),
-      url: z.string().optional(),
-      apiKey: z.string().optional(),
-      syncInterval: z.number().default(3e5)
-      // 5 minutes
+      endpoint: z.string().optional()
     }).default({}),
     neverHub: z.object({
       enabled: z.boolean().default(false),
-      url: z.string().optional(),
-      apiKey: z.string().optional(),
-      packageDiscovery: z.boolean().default(true)
+      endpoint: z.string().optional()
     }).default({}),
     analytics: z.object({
       enabled: z.boolean().default(false),
-      provider: z.enum(["google", "mixpanel", "amplitude", "custom"]).optional(),
-      trackingId: z.string().optional(),
-      config: z.record(z.any()).default({})
+      provider: z.string().optional()
     }).default({})
   }).default({}),
-  // Security Configuration
   security: z.object({
-    jwt: z.object({
-      secret: z.string().default("your-secret-key"),
-      expiresIn: z.string().default("24h"),
-      issuer: z.string().default("content-management-suite")
-    }).default({}),
     permissions: z.object({
       enabled: z.boolean().default(true),
-      defaultRole: z.string().default("user"),
-      roles: z.array(z.object({
-        name: z.string(),
-        permissions: z.array(z.string()),
-        description: z.string().optional()
-      })).default([
-        {
-          name: "admin",
-          permissions: ["*"],
-          description: "Full administrative access"
-        },
-        {
-          name: "editor",
-          permissions: ["content.edit", "content.publish", "content.schedule"],
-          description: "Content editing and publishing"
-        },
-        {
-          name: "author",
-          permissions: ["content.edit"],
-          description: "Content creation and editing"
-        },
-        {
-          name: "user",
-          permissions: ["content.view"],
-          description: "Content viewing only"
-        }
-      ])
-    }).default({})
+      defaultRole: z.string().default("user")
+    }).default({}),
+    roles: z.array(z.object({
+      name: z.string(),
+      permissions: z.array(z.string()),
+      description: z.string().optional()
+    })).default([
+      { name: "admin", permissions: ["*"], description: "Full administrative access" },
+      { name: "editor", permissions: ["content.edit", "content.publish", "content.schedule"], description: "Content editing and publishing" },
+      { name: "author", permissions: ["content.edit"], description: "Content creation and editing" },
+      { name: "user", permissions: ["content.view"], description: "Content viewing only" }
+    ])
+  }).default({}),
+  workflows: z.object({
+    defaults: z.record(z.string(), z.string()).default({})
   }).default({}),
-  // Logging Configuration
   logging: z.object({
-    level: z.enum(["error", "warn", "info", "debug"]).default("info"),
-    format: z.enum(["json", "text"]).default("json"),
-    file: z.object({
-      enabled: z.boolean().default(true),
-      path: z.string().default("./logs"),
-      maxSize: z.string().default("10MB"),
-      maxFiles: z.number().default(5)
-    }).default({}),
-    console: z.object({
-      enabled: z.boolean().default(true),
-      colorize: z.boolean().default(true)
-    }).default({})
+    level: z.enum(["error", "warn", "info", "debug"]).default("info")
   }).default({}),
-  // Performance Configuration
   performance: z.object({
     cache: z.object({
       enabled: z.boolean().default(true),
       ttl: z.number().default(300),
-      // 5 minutes
       maxSize: z.number().default(1e3)
-    }).default({}),
-    compression: z.object({
-      enabled: z.boolean().default(true),
-      level: z.number().min(1).max(9).default(6)
-    }).default({}),
-    rateLimit: z.object({
-      enabled: z.boolean().default(true),
-      windowMs: z.number().default(15 * 60 * 1e3),
-      // 15 minutes
-      max: z.number().default(100)
     }).default({})
   }).default({})
 });
-var ContentManagementSuiteError = class extends Error {
-  constructor(message, code, statusCode = 500, details) {
+
+// src/errors.ts
+var ContentManagementError = class extends Error {
+  constructor(message, options) {
     super(message);
-    this.name = "ContentManagementSuiteError";
-    this.code = code;
-    this.statusCode = statusCode;
-    this.details = details;
+    if (options?.cause !== void 0) {
+      this.cause = options.cause;
+    }
+    this.name = this.constructor.name;
+    this.code = options?.code ?? "CONTENT_MANAGEMENT_ERROR";
+    if (options?.details !== void 0) {
+      this.details = options.details;
+    }
   }
 };
-var ContentManagementSuiteValidationError = class extends ContentManagementSuiteError {
-  constructor(message, details) {
-    super(message, "VALIDATION_ERROR", 400, details);
-    this.name = "ContentManagementSuiteValidationError";
+var ValidationError = class extends ContentManagementError {
+  constructor(message, options) {
+    super(message, { ...options, code: "VALIDATION_ERROR" });
   }
 };
-var ContentManagementSuiteNotFoundError = class extends ContentManagementSuiteError {
-  constructor(message, details) {
-    super(message, "NOT_FOUND", 404, details);
-    this.name = "ContentManagementSuiteNotFoundError";
+var NotFoundError = class extends ContentManagementError {
+  constructor(message, options) {
+    super(message, { ...options, code: "NOT_FOUND" });
   }
 };
-var ContentManagementSuiteUnauthorizedError = class extends ContentManagementSuiteError {
-  constructor(message, details) {
-    super(message, "UNAUTHORIZED", 401, details);
-    this.name = "ContentManagementSuiteUnauthorizedError";
+var UnauthorizedError = class extends ContentManagementError {
+  constructor(message, options) {
+    super(message, { ...options, code: "UNAUTHORIZED" });
   }
 };
-var ContentManagementSuiteForbiddenError = class extends ContentManagementSuiteError {
-  constructor(message, details) {
-    super(message, "FORBIDDEN", 403, details);
-    this.name = "ContentManagementSuiteForbiddenError";
+var ForbiddenError = class extends ContentManagementError {
+  constructor(message, options) {
+    super(message, { ...options, code: "FORBIDDEN" });
   }
 };
-var ContentManagementSuiteConflictError = class extends ContentManagementSuiteError {
-  constructor(message, details) {
-    super(message, "CONFLICT", 409, details);
-    this.name = "ContentManagementSuiteConflictError";
+var ConflictError = class extends ContentManagementError {
+  constructor(message, options) {
+    super(message, { ...options, code: "CONFLICT" });
   }
 };
-var ContentManagementSuiteInternalError = class extends ContentManagementSuiteError {
-  constructor(message, details) {
-    super(message, "INTERNAL_ERROR", 500, details);
-    this.name = "ContentManagementSuiteInternalError";
+var InternalError = class extends ContentManagementError {
+  constructor(message, options) {
+    super(message, { ...options, code: "INTERNAL_ERROR" });
   }
 };
 
-// src/index.ts
-import {
-  WorkflowStepper as WorkflowStepper2,
-  StageActionButtons as StageActionButtons2,
-  WorkflowTimeline as WorkflowTimeline2,
-  WorkflowAdminConfig as WorkflowAdminConfig2
-} from "@bernierllc/content-workflow-ui";
-import { TextContentType as TextContentType2 } from "@bernierllc/content-type-text";
-import { ImageContentType as ImageContentType2 } from "@bernierllc/content-type-image";
-import { AudioContentTypeManager as AudioContentTypeManager2 } from "@bernierllc/content-type-audio";
-import { VideoContentType as VideoContentType2 } from "@bernierllc/content-type-video";
-import { ContentTypeRegistry as ContentTypeRegistry2 } from "@bernierllc/content-type-registry";
-import { EditorialWorkflowEngine, WorkflowBuilder, WorkflowTemplates, WorkflowFactory } from "@bernierllc/content-editorial-workflow";
-import { AutosaveManager } from "@bernierllc/content-autosave-manager";
-import { ContentSoftDelete } from "@bernierllc/content-soft-delete";
-
-// src/content-management-suite.ts
-import { EventEmitter } from "events";
-import express from "express";
-import cors from "cors";
-import helmet from "helmet";
-import morgan from "morgan";
-import compression from "compression";
-import { v4 as uuidv4 } from "uuid";
-import { ContentTypeRegistry } from "@bernierllc/content-type-registry";
-import { TextContentType } from "@bernierllc/content-type-text";
-import { ImageContentType } from "@bernierllc/content-type-image";
-import { AudioContentTypeManager } from "@bernierllc/content-type-audio";
-import { VideoContentType } from "@bernierllc/content-type-video";
-import {
-  WorkflowStepper,
-  StageActionButtons,
-  WorkflowTimeline,
-  WorkflowAdminConfig
-} from "@bernierllc/content-workflow-ui";
-var ContentManagementSuiteImpl = class extends EventEmitter {
-  constructor(options = {}) {
-    super();
-    // Stub until @bernierllc/content-editor-service is published
-    this.autosaveManager = null;
-    this.softDelete = null;
-    this.workflowEngine = null;
-    // Content Types
-    this.contentTypes = /* @__PURE__ */ new Map();
-    // Plugins and Middleware
-    this.plugins = /* @__PURE__ */ new Map();
-    this.middleware = [];
-    this.hooks = /* @__PURE__ */ new Map();
-    // State
-    this.isStarted = false;
-    this.isStopped = false;
-    this.httpServer = null;
-    this.options = options;
-    this.config = this.loadConfiguration();
-    this.contentTypeRegistry = new ContentTypeRegistry();
-    this.configManager = this.createConfigManagerStub();
-    this.workflowService = this.createWorkflowServiceStub();
-    this.editorService = this.createEditorServiceStub();
-    this.workflow = {
-      stepper: WorkflowStepper,
-      actions: StageActionButtons,
-      timeline: WorkflowTimeline,
-      admin: WorkflowAdminConfig
-    };
-    this.server = express();
-    this.setupMiddleware();
-    this.setupRoutes();
-    this.editor = this.createEditorStub();
-    this.list = this.createListStub();
-    this.registerDefaultContentTypes();
-    if (options.plugins) {
-      options.plugins.forEach((plugin) => this.registerPlugin(plugin));
-    }
-  }
-  // Stub creators for services not yet published
-  createConfigManagerStub() {
-    return {
-      getConfig: () => this.config,
-      updateConfig: async (config) => {
-        this.config = { ...this.config, ...config };
-      },
-      start: async () => {
-      },
-      stop: async () => {
-      }
-    };
+// src/in-memory-adapter.ts
+var InMemoryContentStorage = class {
+  constructor() {
+    this.store = /* @__PURE__ */ new Map();
   }
-  createWorkflowServiceStub() {
-    return {
-      listWorkflows: async () => [],
-      getWorkflow: async (id) => ({ id, name: "Default Workflow" }),
-      createWorkflow: async (data) => ({ id: uuidv4(), ...data }),
-      updateWorkflow: async (id, data) => ({ id, ...data }),
-      deleteWorkflow: async (_id) => {
-      },
-      publishContent: async (id) => ({ id, status: "published" }),
-      scheduleContent: async (id, date) => ({ id, scheduledFor: date }),
-      unpublishContent: async (id) => ({ id, status: "draft" }),
-      start: async () => {
-      },
-      stop: async () => {
+  async list(filters) {
+    let items = Array.from(this.store.values());
+    if (filters?.type) {
+      items = items.filter((item) => item.type === filters.type);
+    }
+    if (filters?.status) {
+      items = items.filter((item) => item.status === filters.status);
+    }
+    const total = items.length;
+    const page = filters?.page ?? 1;
+    const limit = filters?.limit ?? items.length;
+    const start = (page - 1) * limit;
+    const paged = items.slice(start, start + limit);
+    return { items: paged, total, page, limit };
+  }
+  async get(id) {
+    return this.store.get(id) ?? null;
+  }
+  async create(item) {
+    this.store.set(item.id, item);
+    return item;
+  }
+  async update(id, partial) {
+    const existing = this.store.get(id);
+    if (!existing) {
+      throw new Error(`Content item not found: ${id}`);
+    }
+    const updated = { ...existing, ...partial };
+    this.store.set(id, updated);
+    return updated;
+  }
+  async delete(id) {
+    this.store.delete(id);
+  }
+  async findBySource(sourceType, sourceId) {
+    for (const item of this.store.values()) {
+      if (item.sourceType === sourceType && item.sourceId === sourceId) {
+        return item;
       }
-    };
+    }
+    return null;
   }
-  createEditorServiceStub() {
-    const contentStore = /* @__PURE__ */ new Map();
-    return {
-      listContent: async (_filters) => ({ items: Array.from(contentStore.values()), total: contentStore.size }),
-      getContent: async (id) => contentStore.get(id) || null,
-      createContent: async (type, data) => {
-        const content = { id: uuidv4(), type, ...data, createdAt: (/* @__PURE__ */ new Date()).toISOString() };
-        contentStore.set(content.id, content);
-        return content;
-      },
-      updateContent: async (id, data) => {
-        const existing = contentStore.get(id);
-        if (!existing)
-          throw new Error("Content not found");
-        const updated = { ...existing, ...data, updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
-        contentStore.set(id, updated);
-        return updated;
-      },
-      deleteContent: async (id, _soft) => {
-        contentStore.delete(id);
-      },
-      start: async () => {
-      },
-      stop: async () => {
+  async search(query, options) {
+    const lowerQuery = query.toLowerCase();
+    let items = Array.from(this.store.values()).filter((item) => {
+      const titleMatch = item.title && item.title.toLowerCase().includes(lowerQuery);
+      const bodyMatch = item.body && item.body.toLowerCase().includes(lowerQuery);
+      const dataMatch = item.data && Object.values(item.data).some(
+        (value) => typeof value === "string" && value.toLowerCase().includes(lowerQuery)
+      );
+      return titleMatch || bodyMatch || dataMatch;
+    });
+    if (options?.type) {
+      items = items.filter((item) => item.type === options.type);
+    }
+    if (options?.status) {
+      items = items.filter((item) => item.status === options.status);
+    }
+    const total = items.length;
+    const page = options?.page ?? 1;
+    const limit = options?.limit ?? items.length;
+    const start = (page - 1) * limit;
+    const paged = items.slice(start, start + limit);
+    return { items: paged, total, page, limit };
+  }
+};
+var InMemoryWorkflowStorage = class {
+  constructor() {
+    this.store = /* @__PURE__ */ new Map();
+    this.contentTypeMap = /* @__PURE__ */ new Map();
+  }
+  // contentType -> workflowId
+  async list() {
+    return Array.from(this.store.values());
+  }
+  async get(id) {
+    return this.store.get(id) ?? null;
+  }
+  async create(workflow) {
+    this.store.set(workflow.id, workflow);
+    return workflow;
+  }
+  async update(id, partial) {
+    const existing = this.store.get(id);
+    if (!existing) {
+      throw new Error(`Workflow not found: ${id}`);
+    }
+    const updated = { ...existing, ...partial };
+    this.store.set(id, updated);
+    return updated;
+  }
+  async delete(id) {
+    this.store.delete(id);
+    for (const [ct, wId] of this.contentTypeMap.entries()) {
+      if (wId === id) {
+        this.contentTypeMap.delete(ct);
       }
-    };
+    }
   }
-  // Stub for editor interface (until @bernierllc/content-editor-ui is published)
-  createEditorStub() {
-    return {
-      render: () => null,
-      getValue: () => "",
-      setValue: (_value) => {
-      },
-      focus: () => {
-      },
-      blur: () => {
-      },
-      on: (_event, _callback) => {
-      },
-      off: (_event, _callback) => {
+  async findByContentType(contentType) {
+    const workflowId = this.contentTypeMap.get(contentType);
+    if (!workflowId) {
+      return null;
+    }
+    return this.store.get(workflowId) ?? null;
+  }
+  setContentTypeMapping(contentType, workflowId) {
+    this.contentTypeMap.set(contentType, workflowId);
+  }
+};
+var InMemoryContentTypeStorage = class {
+  constructor() {
+    this.store = /* @__PURE__ */ new Map();
+  }
+  async list() {
+    return Array.from(this.store.values());
+  }
+  async get(id) {
+    return this.store.get(id) ?? null;
+  }
+  async create(def) {
+    this.store.set(def.id, def);
+    return def;
+  }
+  async update(id, partial) {
+    const existing = this.store.get(id);
+    if (!existing) {
+      throw new Error(`Content type not found: ${id}`);
+    }
+    const updated = { ...existing, ...partial };
+    this.store.set(id, updated);
+    return updated;
+  }
+  async delete(id) {
+    this.store.delete(id);
+  }
+};
+var InMemorySocialPostStorage = class {
+  constructor() {
+    this.store = /* @__PURE__ */ new Map();
+  }
+  async list(filters) {
+    let items = Array.from(this.store.values());
+    if (filters?.contentId) {
+      items = items.filter((p) => p.contentId === filters.contentId);
+    }
+    if (filters?.platform) {
+      items = items.filter((p) => p.platform === filters.platform);
+    }
+    if (filters?.status) {
+      items = items.filter((p) => p.status === filters.status);
+    }
+    return items;
+  }
+  async get(id) {
+    return this.store.get(id) ?? null;
+  }
+  async create(post) {
+    this.store.set(post.id, post);
+    return post;
+  }
+  async update(id, partial) {
+    const existing = this.store.get(id);
+    if (!existing) {
+      throw new Error(`Social post not found: ${id}`);
+    }
+    const updated = { ...existing, ...partial };
+    this.store.set(id, updated);
+    return updated;
+  }
+  async delete(id) {
+    this.store.delete(id);
+  }
+  async findByContent(contentId) {
+    return Array.from(this.store.values()).filter((p) => p.contentId === contentId);
+  }
+};
+var InMemoryAIReviewStorage = class {
+  constructor() {
+    this.store = /* @__PURE__ */ new Map();
+  }
+  async list(filters) {
+    let items = Array.from(this.store.values());
+    if (filters?.contentId) {
+      items = items.filter((r) => r.contentId === filters.contentId);
+    }
+    return items;
+  }
+  async get(id) {
+    return this.store.get(id) ?? null;
+  }
+  async create(review) {
+    this.store.set(review.id, review);
+    return review;
+  }
+  async findByContent(contentId) {
+    return Array.from(this.store.values()).filter((r) => r.contentId === contentId);
+  }
+  async getLatestForContent(contentId) {
+    const reviews = await this.findByContent(contentId);
+    if (reviews.length === 0) {
+      return null;
+    }
+    reviews.sort((a, b) => b.createdAt.localeCompare(a.createdAt));
+    return reviews[0] ?? null;
+  }
+};
+function createInMemoryAdapter() {
+  return {
+    content: new InMemoryContentStorage(),
+    workflows: new InMemoryWorkflowStorage(),
+    contentTypes: new InMemoryContentTypeStorage(),
+    socialPosts: new InMemorySocialPostStorage(),
+    aiReviews: new InMemoryAIReviewStorage()
+  };
+}
+
+// src/namespaces/content.ts
+import * as crypto from "crypto";
+var ContentNamespaceImpl = class {
+  constructor(emitter, storage, getContentTypes, getPublishers) {
+    this.emitter = emitter;
+    this.storage = storage;
+    this.getContentTypes = getContentTypes;
+    this.getPublishers = getPublishers;
+  }
+  async create(input) {
+    const contentTypes = this.getContentTypes();
+    const typeDef = contentTypes.get(input.type);
+    if (typeDef && typeDef.schema) {
+      const dataToValidate = {
+        ...input.title !== void 0 ? { title: input.title } : {},
+        ...input.body !== void 0 ? { body: input.body } : {},
+        ...input.data ?? {}
+      };
+      const result = contentTypes.validate(input.type, dataToValidate);
+      if (!result.valid) {
+        throw new ValidationError("Content type schema validation failed", {
+          details: { errors: result.errors }
+        });
       }
+    }
+    const item = {
+      id: crypto.randomUUID(),
+      type: input.type,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      status: "draft",
+      ...input.title !== void 0 ? { title: input.title } : {},
+      ...input.body !== void 0 ? { body: input.body } : {},
+      ...input.data !== void 0 ? { data: { ...input.data } } : {},
+      ...input.channels !== void 0 ? { channels: input.channels } : {},
+      ...input.metadata !== void 0 ? { metadata: input.metadata } : {}
     };
+    const created = await this.storage.content.create(item);
+    this.emitter.emit("content:created", created);
+    return created;
   }
-  // Stub for list interface (until @bernierllc/content-list-ui is published)
-  createListStub() {
-    return {
-      render: () => null,
-      getItems: () => [],
-      setItems: (_items) => {
-      },
-      getSelectedItems: () => [],
-      setSelectedItems: (_items) => {
-      },
-      on: (_event, _callback) => {
-      },
-      off: (_event, _callback) => {
-      }
+  async get(id) {
+    const item = await this.storage.content.get(id);
+    if (!item) {
+      throw new NotFoundError(`Content item not found: ${id}`);
+    }
+    return item;
+  }
+  async list(filters) {
+    return this.storage.content.list(filters);
+  }
+  async update(id, input) {
+    const existing = await this.storage.content.get(id);
+    if (!existing) {
+      throw new NotFoundError(`Content item not found: ${id}`);
+    }
+    const partial = {
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      ...input.title !== void 0 ? { title: input.title } : {},
+      ...input.body !== void 0 ? { body: input.body } : {},
+      ...input.status !== void 0 ? { status: input.status } : {},
+      ...input.channels !== void 0 ? { channels: input.channels } : {},
+      ...input.metadata !== void 0 ? { metadata: input.metadata } : {}
     };
+    if (input.data !== void 0) {
+      partial.data = { ...existing.data ?? {}, ...input.data };
+    }
+    const updated = await this.storage.content.update(id, partial);
+    this.emitter.emit("content:updated", updated);
+    return updated;
   }
-  loadConfiguration() {
-    try {
-      if (this.options.config) {
-        return ContentManagementConfigSchema.parse(this.options.config);
-      }
-      const config = this.configManager?.getConfig() || {};
-      return ContentManagementConfigSchema.parse(config);
-    } catch (error) {
-      console.error("Failed to load configuration:", error);
-      return ContentManagementConfigSchema.parse({});
+  async delete(id) {
+    const existing = await this.storage.content.get(id);
+    if (!existing) {
+      throw new NotFoundError(`Content item not found: ${id}`);
     }
+    await this.storage.content.delete(id);
+    this.emitter.emit("content:deleted", { id });
   }
-  setupMiddleware() {
-    if (this.config.server.security.helmet) {
-      this.server.use(helmet());
+  async publish(id, options) {
+    const existing = await this.storage.content.get(id);
+    if (!existing) {
+      throw new NotFoundError(`Content item not found: ${id}`);
     }
-    this.server.use(cors(this.config.server.cors));
-    if (this.config.performance.compression.enabled) {
-      this.server.use(compression({
-        level: this.config.performance.compression.level
-      }));
+    if (existing.workflowId) {
+      const workflow = await this.storage.workflows.get(existing.workflowId);
+      if (workflow && workflow.stages && workflow.stages.length > 0) {
+        const currentStage = workflow.stages.find((s) => s.id === existing.workflowStage);
+        const publishStage = workflow.stages.find((s) => s.isPublishStage);
+        if (publishStage && (!currentStage || !currentStage.isPublishStage)) {
+          throw new ValidationError(
+            `Content is not at a publish-eligible stage. Current stage: "${existing.workflowStage ?? "none"}", required publish stage: "${publishStage.id}"`,
+            {
+              details: {
+                currentStage: existing.workflowStage ?? null,
+                requiredStage: publishStage.id
+              }
+            }
+          );
+        }
+      }
     }
-    if (this.options.logger) {
-      this.server.use(morgan("combined", {
-        stream: {
-          write: (message) => {
-            this.options.logger?.info(message.trim());
-          }
+    const publishers = this.getPublishers();
+    const allPublishers = publishers.list();
+    const channelIds = options?.channels ?? existing.channels;
+    let targetPublishers;
+    if (channelIds && channelIds.length > 0) {
+      targetPublishers = allPublishers.filter((p) => channelIds.includes(p.id));
+    } else {
+      targetPublishers = allPublishers.filter((p) => p.acceptedTypes.includes(existing.type));
+    }
+    const results = [];
+    for (const publisher of targetPublishers) {
+      if (!publisher.acceptedTypes.includes(existing.type)) {
+        results.push({
+          channelId: publisher.id,
+          success: false,
+          error: `Content type "${existing.type}" not accepted by publisher "${publisher.id}". Accepted: ${publisher.acceptedTypes.join(", ")}`
+        });
+        continue;
+      }
+      if (publisher.validate) {
+        const validationErrors = await publisher.validate(existing);
+        if (validationErrors.length > 0) {
+          results.push({
+            channelId: publisher.id,
+            success: false,
+            error: `Validation failed: ${validationErrors.map((e) => e.message).join(", ")}`
+          });
+          continue;
         }
-      }));
+      }
+      try {
+        const result = await publisher.publish(existing);
+        results.push(result);
+      } catch (error) {
+        results.push({
+          channelId: publisher.id,
+          success: false,
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
     }
-    this.server.use(express.json({ limit: "10mb" }));
-    this.server.use(express.urlencoded({ extended: true, limit: "10mb" }));
-    this.middleware.sort((a, b) => (a.order || 0) - (b.order || 0)).forEach((middleware) => {
-      this.server.use(middleware.handler);
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const updated = await this.storage.content.update(id, {
+      status: "published",
+      publishedAt: now,
+      updatedAt: now
     });
+    const publishResult = { item: updated, results };
+    this.emitter.emit("content:published", publishResult);
+    return publishResult;
   }
-  setupRoutes() {
-    this.server.get("/health", (req, res) => {
-      res.json({
-        status: "healthy",
-        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-        version: "0.1.0",
-        uptime: process.uptime()
-      });
+  async unpublish(id) {
+    const existing = await this.storage.content.get(id);
+    if (!existing) {
+      throw new NotFoundError(`Content item not found: ${id}`);
+    }
+    const updated = await this.storage.content.update(id, {
+      status: "draft",
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
     });
-    this.server.use("/api", this.createAPIRoutes());
-    this.server.use("/admin", this.createAdminRoutes());
-    this.server.use("/static", express.static("public"));
-    this.server.use(this.errorHandler.bind(this));
-  }
-  createAPIRoutes() {
-    const router = express.Router();
-    router.get("/content", this.getContentList.bind(this));
-    router.get("/content/:id", this.getContent.bind(this));
-    router.post("/content", this.createContent.bind(this));
-    router.put("/content/:id", this.updateContent.bind(this));
-    router.delete("/content/:id", this.deleteContent.bind(this));
-    router.post("/content/:id/publish", this.publishContent.bind(this));
-    router.post("/content/:id/schedule", this.scheduleContent.bind(this));
-    router.post("/content/:id/unpublish", this.unpublishContent.bind(this));
-    router.get("/workflows", this.getWorkflows.bind(this));
-    router.get("/workflows/:id", this.getWorkflow.bind(this));
-    router.post("/workflows", this.createWorkflow.bind(this));
-    router.put("/workflows/:id", this.updateWorkflow.bind(this));
-    router.delete("/workflows/:id", this.deleteWorkflow.bind(this));
-    router.get("/content-types", this.getContentTypes.bind(this));
-    router.get("/content-types/:id", this.handleGetContentType.bind(this));
-    router.post("/content-types", this.createContentType.bind(this));
-    router.put("/content-types/:id", this.updateContentType.bind(this));
-    router.delete("/content-types/:id", this.deleteContentType.bind(this));
-    router.get("/config", this.handleGetConfig.bind(this));
-    router.put("/config", this.handleUpdateConfig.bind(this));
-    router.get("/users", this.getUsers.bind(this));
-    router.get("/users/:id", this.getUser.bind(this));
-    router.post("/users", this.createUser.bind(this));
-    router.put("/users/:id", this.updateUser.bind(this));
-    router.delete("/users/:id", this.deleteUser.bind(this));
-    return router;
-  }
-  createAdminRoutes() {
-    const router = express.Router();
-    router.get("/", (req, res) => {
-      res.json({
-        message: "Content Management Suite Admin",
-        version: "0.1.0",
-        endpoints: [
-          "/workflows",
-          "/content-types",
-          "/config",
-          "/users"
-        ]
-      });
+    this.emitter.emit("content:unpublished", updated);
+    return updated;
+  }
+  async schedule(id, date) {
+    const existing = await this.storage.content.get(id);
+    if (!existing) {
+      throw new NotFoundError(`Content item not found: ${id}`);
+    }
+    const updated = await this.storage.content.update(id, {
+      scheduledFor: date,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
     });
-    router.get("/workflows", this.getWorkflows.bind(this));
-    router.post("/workflows", this.createWorkflow.bind(this));
-    router.put("/workflows/:id", this.updateWorkflow.bind(this));
-    router.delete("/workflows/:id", this.deleteWorkflow.bind(this));
-    router.get("/content-types", this.getContentTypes.bind(this));
-    router.post("/content-types", this.createContentType.bind(this));
-    router.put("/content-types/:id", this.updateContentType.bind(this));
-    router.delete("/content-types/:id", this.deleteContentType.bind(this));
-    router.get("/config", this.handleGetConfig.bind(this));
-    router.put("/config", this.handleUpdateConfig.bind(this));
-    return router;
-  }
-  errorHandler(error, _req, res, _next) {
-    this.emit("error", error);
-    if (error instanceof ContentManagementSuiteError) {
-      res.status(error.statusCode).json({
-        error: {
-          code: error.code,
-          message: error.message,
-          details: error.details
-        }
-      });
+    this.emitter.emit("content:scheduled", { item: updated, date });
+    return updated;
+  }
+  async search(query, options) {
+    return this.storage.content.search(query, options);
+  }
+};
+
+// src/namespaces/content-types.ts
+import { z as z2 } from "zod";
+var ContentTypesNamespaceImpl = class {
+  constructor() {
+    this.store = /* @__PURE__ */ new Map();
+  }
+  register(definition) {
+    if ("schema" in definition && definition.schema) {
+      const def = definition;
+      this.store.set(def.id, def);
     } else {
-      res.status(500).json({
-        error: {
-          code: "INTERNAL_ERROR",
-          message: "An unexpected error occurred",
-          details: process.env.NODE_ENV === "development" ? error.message : void 0
-        }
+      const id = definition.id ?? definition.name;
+      if (!id) {
+        throw new Error("Content type must have an id or name");
+      }
+      const name = definition.name ?? definition.id ?? id;
+      this.store.set(id, {
+        id,
+        name,
+        schema: null
       });
     }
   }
-  registerDefaultContentTypes() {
-    this.contentTypes.set("text", TextContentType);
-    this.contentTypes.set("image", ImageContentType);
-    this.contentTypes.set("audio", AudioContentTypeManager);
-    this.contentTypes.set("video", VideoContentType);
+  unregister(id) {
+    if (!this.store.has(id)) {
+      throw new NotFoundError(`Content type not found: ${id}`);
+    }
+    this.store.delete(id);
+  }
+  get(id) {
+    return this.store.get(id);
+  }
+  list() {
+    return Array.from(this.store.values());
   }
-  // Public API Methods
-  async start() {
-    if (this.isStarted) {
-      throw new ContentManagementSuiteError("Suite is already started", "ALREADY_STARTED");
+  validate(type, data) {
+    const def = this.store.get(type);
+    if (!def || !def.schema) {
+      return { valid: true };
     }
     try {
-      await this.configManager.start();
-      await this.workflowService.start();
-      await this.editorService.start();
-      const port = this.config.server.port;
-      const host = this.config.server.host;
-      return new Promise((resolve, reject) => {
-        this.httpServer = this.server.listen(port, host, () => {
-          console.log(`Content Management Suite started on http://${host}:${port}`);
-          this.isStarted = true;
-          this.emit("started");
-          resolve();
-        });
-        this.httpServer.on("error", (err) => {
-          this.emit("error", err);
-          reject(new ContentManagementSuiteInternalError("Failed to start server", err));
-        });
-      });
+      const schema = def.schema;
+      schema.parse(data);
+      return { valid: true };
     } catch (error) {
-      this.emit("error", error);
-      throw new ContentManagementSuiteInternalError("Failed to start suite", error);
+      if (error instanceof z2.ZodError) {
+        return {
+          valid: false,
+          errors: error.issues.map((issue) => ({
+            message: issue.message,
+            path: issue.path.map(String)
+          }))
+        };
+      }
+      return {
+        valid: false,
+        errors: [{ message: error instanceof Error ? error.message : String(error) }]
+      };
     }
   }
-  async stop() {
-    if (this.isStopped) {
-      throw new ContentManagementSuiteError("Suite is already stopped", "ALREADY_STOPPED");
+};
+
+// src/namespaces/workflows.ts
+import * as crypto2 from "crypto";
+var WorkflowsNamespaceImpl = class {
+  constructor(storage) {
+    this.cache = /* @__PURE__ */ new Map();
+    this.storage = storage;
+  }
+  /** Load workflows from storage into cache. Called during suite initialization. */
+  async loadFromStorage() {
+    if (!this.storage) {
+      return;
     }
-    try {
-      await this.configManager.stop();
-      await this.workflowService.stop();
-      await this.editorService.stop();
-      if (this.httpServer) {
-        return new Promise((resolve) => {
-          this.httpServer.close(() => {
-            console.log("Content Management Suite stopped");
-            this.isStopped = true;
-            this.emit("stopped");
-            resolve();
-          });
-        });
-      }
-      this.isStopped = true;
-    } catch (error) {
-      this.emit("error", error);
-      throw new ContentManagementSuiteInternalError("Failed to stop suite", error);
+    const workflows = await this.storage.workflows.list();
+    for (const w of workflows) {
+      this.cache.set(w.id, w);
     }
   }
-  getConfig() {
-    return this.config;
+  async create(input) {
+    const workflow = {
+      id: crypto2.randomUUID(),
+      name: input.name,
+      ...input.description !== void 0 ? { description: input.description } : {},
+      ...input.stages !== void 0 ? { stages: input.stages } : {},
+      ...input.transitions !== void 0 ? { transitions: input.transitions } : {}
+    };
+    if (this.storage) {
+      await this.storage.workflows.create(workflow);
+    }
+    this.cache.set(workflow.id, workflow);
+    return workflow;
   }
-  async updateConfig(config) {
-    try {
-      const newConfig = ContentManagementConfigSchema.parse({
-        ...this.config,
-        ...config
-      });
-      this.config = newConfig;
-      await this.configManager.updateConfig(newConfig);
-      this.emit("config:updated", newConfig);
-    } catch (error) {
-      throw new ContentManagementSuiteValidationError("Invalid configuration", error);
+  async get(id) {
+    const workflow = this.cache.get(id);
+    if (!workflow) {
+      throw new NotFoundError(`Workflow not found: ${id}`);
     }
+    return workflow;
   }
-  registerContentType(contentType) {
-    const id = contentType?.id || contentType?.name || "unknown";
-    this.contentTypes.set(id, contentType);
-    this.emit("contentType:registered", contentType);
+  async list() {
+    return Array.from(this.cache.values());
   }
-  unregisterContentType(contentTypeId) {
-    if (!this.contentTypes.has(contentTypeId)) {
-      throw new ContentManagementSuiteNotFoundError("Content type not found");
+  async update(id, input) {
+    const existing = this.cache.get(id);
+    if (!existing) {
+      throw new NotFoundError(`Workflow not found: ${id}`);
     }
-    this.contentTypes.delete(contentTypeId);
-    this.emit("contentType:unregistered", contentTypeId);
+    const updated = {
+      ...existing,
+      ...input.name !== void 0 ? { name: input.name } : {},
+      ...input.description !== void 0 ? { description: input.description } : {},
+      ...input.stages !== void 0 ? { stages: input.stages } : {},
+      ...input.transitions !== void 0 ? { transitions: input.transitions } : {}
+    };
+    if (this.storage) {
+      await this.storage.workflows.update(id, updated);
+    }
+    this.cache.set(id, updated);
+    return updated;
   }
-  getContentType(contentTypeId) {
-    const contentType = this.contentTypes.get(contentTypeId);
-    if (!contentType) {
-      throw new ContentManagementSuiteNotFoundError("Content type not found");
+  async delete(id) {
+    if (!this.cache.has(id)) {
+      throw new NotFoundError(`Workflow not found: ${id}`);
+    }
+    if (this.storage) {
+      const contentResult = await this.storage.content.list();
+      const assignedContent = contentResult.items.filter((item) => item.workflowId === id);
+      if (assignedContent.length > 0) {
+        throw new ConflictError(
+          `Cannot delete workflow "${id}": ${assignedContent.length} content item(s) are assigned to it. Reassign or archive them first.`,
+          { details: { assignedCount: assignedContent.length } }
+        );
+      }
+      await this.storage.workflows.delete(id);
     }
-    return contentType;
+    this.cache.delete(id);
   }
-  listContentTypes() {
-    return Array.from(this.contentTypes.entries()).map(([id, contentType]) => ({
-      id,
-      contentType,
-      ...contentType
-    }));
+};
+
+// src/namespaces/users.ts
+import * as crypto3 from "crypto";
+var UsersNamespaceImpl = class {
+  constructor(emitter) {
+    this.store = /* @__PURE__ */ new Map();
+    this.emitter = emitter;
   }
-  // Plugin Management
-  registerPlugin(plugin) {
-    if (this.plugins.has(plugin.name)) {
-      throw new ContentManagementSuiteConflictError("Plugin already registered");
-    }
-    this.plugins.set(plugin.name, plugin);
-    plugin.install(this);
-    this.emit("plugin:registered", plugin);
+  async create(input) {
+    const user = {
+      id: crypto3.randomUUID(),
+      name: input.name,
+      ...input.email !== void 0 ? { email: input.email } : {},
+      ...input.role !== void 0 ? { role: input.role } : {},
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.store.set(user.id, user);
+    this.emitter.emit("user:created", user);
+    return user;
   }
-  unregisterPlugin(pluginName) {
-    const plugin = this.plugins.get(pluginName);
-    if (!plugin) {
-      throw new ContentManagementSuiteNotFoundError("Plugin not found");
-    }
-    plugin.uninstall(this);
-    this.plugins.delete(pluginName);
-    this.emit("plugin:unregistered", pluginName);
-  }
-  // Middleware Management
-  addMiddleware(middleware) {
-    this.middleware.push(middleware);
-    this.emit("middleware:added", middleware);
-  }
-  removeMiddleware(middlewareName) {
-    const index = this.middleware.findIndex((m) => m.name === middlewareName);
-    if (index === -1) {
-      throw new ContentManagementSuiteNotFoundError("Middleware not found");
-    }
-    this.middleware.splice(index, 1);
-    this.emit("middleware:removed", middlewareName);
-  }
-  // Hook Management
-  addHook(hook) {
-    if (!this.hooks.has(hook.name)) {
-      this.hooks.set(hook.name, []);
-    }
-    this.hooks.get(hook.name).push(hook);
-    this.hooks.get(hook.name).sort((a, b) => (a.priority || 0) - (b.priority || 0));
-    this.emit("hook:added", hook);
-  }
-  removeHook(hookName, handler) {
-    const hooks = this.hooks.get(hookName);
-    if (!hooks) {
-      throw new ContentManagementSuiteNotFoundError("Hook not found");
-    }
-    if (handler) {
-      const index = hooks.findIndex((h) => h.handler === handler);
-      if (index === -1) {
-        throw new ContentManagementSuiteNotFoundError("Hook handler not found");
-      }
-      hooks.splice(index, 1);
-    } else {
-      this.hooks.delete(hookName);
+  async get(id) {
+    const user = this.store.get(id);
+    if (!user) {
+      throw new NotFoundError(`User not found: ${id}`);
     }
-    this.emit("hook:removed", hookName);
+    return user;
   }
-  // API Route Handlers
-  async getContentList(req, res) {
-    try {
-      const { type, status, page = 1, limit = 20 } = req.query;
-      const filters = { type, status, page: parseInt(page), limit: parseInt(limit) };
-      const content = await this.editorService.listContent(filters);
-      res.json(content);
-    } catch (error) {
-      throw new ContentManagementSuiteInternalError("Failed to get content list", error);
+  async list() {
+    const items = Array.from(this.store.values());
+    return { items, total: items.length };
+  }
+  async update(id, input) {
+    const existing = this.store.get(id);
+    if (!existing) {
+      throw new NotFoundError(`User not found: ${id}`);
     }
+    const updated = {
+      ...existing,
+      ...input,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.store.set(id, updated);
+    this.emitter.emit("user:updated", updated);
+    return updated;
   }
-  async getContent(req, res) {
-    try {
-      const { id } = req.params;
-      const content = await this.editorService.getContent(id);
-      res.json(content);
-    } catch (error) {
-      throw new ContentManagementSuiteNotFoundError("Content not found", error);
+  async delete(id) {
+    if (!this.store.has(id)) {
+      throw new NotFoundError(`User not found: ${id}`);
     }
+    this.store.delete(id);
+    this.emitter.emit("user:deleted", { id });
   }
-  async createContent(req, res) {
-    try {
-      const { type, data } = req.body;
-      const content = await this.editorService.createContent(type, data);
-      this.emit("content:created", content);
-      res.status(201).json(content);
-    } catch (error) {
-      throw new ContentManagementSuiteInternalError("Failed to create content", error);
+};
+var PermissionsNamespaceImpl = class {
+  constructor() {
+    this.store = /* @__PURE__ */ new Map();
+  }
+  async check(userId, permission) {
+    const perms = this.store.get(userId);
+    return perms?.has(permission) ?? false;
+  }
+  async grant(userId, permission) {
+    let perms = this.store.get(userId);
+    if (!perms) {
+      perms = /* @__PURE__ */ new Set();
+      this.store.set(userId, perms);
     }
+    perms.add(permission);
   }
-  async updateContent(req, res) {
-    try {
-      const { id } = req.params;
-      const { data } = req.body;
-      const content = await this.editorService.updateContent(id, data);
-      this.emit("content:updated", content);
-      res.json(content);
-    } catch (error) {
-      throw new ContentManagementSuiteInternalError("Failed to update content", error);
+  async revoke(userId, permission) {
+    const perms = this.store.get(userId);
+    if (perms) {
+      perms.delete(permission);
     }
   }
-  async deleteContent(req, res) {
-    try {
-      const { id } = req.params;
-      const { soft = true } = req.query;
-      await this.editorService.deleteContent(id, soft === "true");
-      this.emit("content:deleted", { id });
-      res.status(204).send();
-    } catch (error) {
-      throw new ContentManagementSuiteInternalError("Failed to delete content", error);
+};
+
+// src/namespaces/config.ts
+function deepMerge(target, source) {
+  const result = { ...target };
+  for (const key of Object.keys(source)) {
+    const sourceVal = source[key];
+    const targetVal = result[key];
+    if (sourceVal !== null && sourceVal !== void 0 && typeof sourceVal === "object" && !Array.isArray(sourceVal) && targetVal !== null && targetVal !== void 0 && typeof targetVal === "object" && !Array.isArray(targetVal)) {
+      result[key] = deepMerge(
+        targetVal,
+        sourceVal
+      );
+    } else {
+      result[key] = sourceVal;
     }
   }
-  async publishContent(req, res) {
+  return result;
+}
+var ConfigNamespaceImpl = class {
+  constructor(initialConfig, emitter) {
+    this.config = initialConfig;
+    this.emitter = emitter;
+  }
+  get() {
+    return this.config;
+  }
+  update(partial) {
+    const merged = deepMerge(this.config, partial);
     try {
-      const { id } = req.params;
-      const content = await this.workflowService.publishContent(id);
-      this.emit("content:published", content);
-      res.json(content);
-    } catch (error) {
-      throw new ContentManagementSuiteInternalError("Failed to publish content", error);
+      this.config = ContentManagementConfigSchema.parse(merged);
+    } catch (err) {
+      throw new ValidationError(
+        "Invalid configuration",
+        err instanceof Error ? { cause: err } : void 0
+      );
     }
+    this.emitter.emit("config:updated", this.config);
+    return this.config;
   }
-  async scheduleContent(req, res) {
-    try {
-      const { id } = req.params;
-      const { date } = req.body;
-      const content = await this.workflowService.scheduleContent(id, new Date(date));
-      this.emit("content:scheduled", content, new Date(date));
-      res.json(content);
-    } catch (error) {
-      throw new ContentManagementSuiteInternalError("Failed to schedule content", error);
+};
+
+// src/namespaces/plugins.ts
+var PluginsNamespaceImpl = class {
+  constructor(suite) {
+    this.store = /* @__PURE__ */ new Map();
+    this.suite = suite;
+  }
+  async register(plugin) {
+    if (this.store.has(plugin.name)) {
+      throw new ConflictError(`Plugin already registered: ${plugin.name}`);
     }
+    await plugin.setup(this.suite);
+    this.store.set(plugin.name, plugin);
   }
-  async unpublishContent(req, res) {
-    try {
-      const { id } = req.params;
-      const content = await this.workflowService.unpublishContent(id);
-      res.json(content);
-    } catch (error) {
-      throw new ContentManagementSuiteInternalError("Failed to unpublish content", error);
+  async unregister(name) {
+    const plugin = this.store.get(name);
+    if (!plugin) {
+      throw new NotFoundError(`Plugin not found: ${name}`);
+    }
+    if (plugin.teardown) {
+      await plugin.teardown(this.suite);
     }
+    this.store.delete(name);
   }
-  async getWorkflows(req, res) {
-    try {
-      const workflows = await this.workflowService.listWorkflows();
-      res.json(workflows);
-    } catch (error) {
-      throw new ContentManagementSuiteInternalError("Failed to get workflows", error);
+};
+
+// src/namespaces/publishers.ts
+var WebsitePublisher = class {
+  constructor() {
+    this.id = "website";
+    this.name = "Website";
+    this.acceptedTypes = ["blog-post", "article", "page", "generic", "text"];
+  }
+  async publish(content) {
+    const slug = content.title ? content.title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "") : content.id;
+    return {
+      channelId: this.id,
+      success: true,
+      url: `/content/${slug}`
+    };
+  }
+};
+var RSSPublisher = class {
+  constructor() {
+    this.id = "rss";
+    this.name = "RSS Feed";
+    this.acceptedTypes = ["blog-post", "article", "rss-article", "generic", "text"];
+  }
+  async publish(content) {
+    return {
+      channelId: this.id,
+      success: true,
+      url: `/feed/rss/${content.id}`
+    };
+  }
+};
+var PublishersNamespaceImpl = class {
+  constructor(emitter) {
+    this.store = /* @__PURE__ */ new Map();
+    this.emitter = emitter;
+    this.store.set("website", new WebsitePublisher());
+    this.store.set("rss", new RSSPublisher());
+  }
+  register(publisher) {
+    this.store.set(publisher.id, publisher);
+    this.emitter.emit("publisher:registered", { publisher });
+  }
+  unregister(id) {
+    if (!this.store.has(id)) {
+      throw new NotFoundError(`Publisher not found: ${id}`);
     }
+    this.store.delete(id);
   }
-  async getWorkflow(req, res) {
-    try {
-      const { id } = req.params;
-      const workflow = await this.workflowService.getWorkflow(id);
-      res.json(workflow);
-    } catch (error) {
-      throw new ContentManagementSuiteNotFoundError("Workflow not found", error);
+  list() {
+    return Array.from(this.store.values());
+  }
+  get(id) {
+    return this.store.get(id);
+  }
+};
+
+// src/namespaces/sources.ts
+import * as crypto4 from "crypto";
+var SourcesNamespaceImpl = class {
+  constructor(emitter, storage, workflowDefaults) {
+    this.store = /* @__PURE__ */ new Map();
+    this.emitter = emitter;
+    this.storage = storage;
+    this.workflowDefaults = workflowDefaults;
+  }
+  register(source) {
+    this.store.set(source.id, source);
+    this.emitter.emit("source:registered", { source });
+  }
+  unregister(id) {
+    if (!this.store.has(id)) {
+      throw new NotFoundError(`Source not found: ${id}`);
     }
+    this.store.delete(id);
   }
-  async createWorkflow(req, res) {
-    try {
-      const { data } = req.body;
-      const workflow = await this.workflowService.createWorkflow(data);
-      res.status(201).json(workflow);
-    } catch (error) {
-      throw new ContentManagementSuiteInternalError("Failed to create workflow", error);
+  list() {
+    return Array.from(this.store.values());
+  }
+  get(id) {
+    return this.store.get(id);
+  }
+  async ingest(sourceId, rawPayload) {
+    const source = this.store.get(sourceId);
+    if (!source) {
+      throw new NotFoundError(`Source not found: ${sourceId}`);
     }
+    if (source.validate) {
+      const validationErrors = await source.validate(rawPayload);
+      if (validationErrors.length > 0) {
+        throw new ValidationError("Source validation failed", {
+          details: { errors: validationErrors }
+        });
+      }
+    }
+    const rawItem = await source.ingest(rawPayload);
+    if (rawItem.sourceId) {
+      const existing = await this.storage.content.findBySource(source.id, rawItem.sourceId);
+      if (existing) {
+        return { created: false, content: existing };
+      }
+    }
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const workflowId = this.workflowDefaults[rawItem.type] ?? this.workflowDefaults["generic"];
+    const item = {
+      id: crypto4.randomUUID(),
+      type: rawItem.type,
+      createdAt: now,
+      status: "review",
+      sourceType: source.id,
+      sourceId: rawItem.sourceId ?? null,
+      ...rawItem.title !== void 0 ? { title: rawItem.title } : {},
+      ...rawItem.body !== void 0 ? { body: rawItem.body } : {},
+      ...rawItem.data !== void 0 ? { data: rawItem.data } : {},
+      ...rawItem.metadata !== void 0 ? { metadata: rawItem.metadata } : {},
+      ...workflowId !== void 0 ? { workflowId } : {}
+    };
+    const created = await this.storage.content.create(item);
+    this.emitter.emit("content:ingested", { item: created, sourceType: source.id });
+    this.emitter.emit("content:created", created);
+    return { created: true, content: created };
   }
-  async updateWorkflow(req, res) {
-    try {
-      const { id } = req.params;
-      const { data } = req.body;
-      const workflow = await this.workflowService.updateWorkflow(id, data);
-      res.json(workflow);
-    } catch (error) {
-      throw new ContentManagementSuiteInternalError("Failed to update workflow", error);
+};
+
+// src/namespaces/ai.ts
+import * as crypto5 from "crypto";
+var AINamespaceImpl = class {
+  constructor(emitter, storage, options) {
+    this.emitter = emitter;
+    this.storage = storage;
+    this.reviewService = options.reviewService;
+    this.socialGeneratorService = options.socialGeneratorService;
+    this.enhanceService = options.enhanceService;
+    this.workflowDefaults = options.workflowDefaults ?? {};
+  }
+  async review(contentId) {
+    if (!this.reviewService) {
+      throw new InternalError("AI review service not configured");
+    }
+    const content = await this.storage.content.get(contentId);
+    if (!content) {
+      throw new NotFoundError(`Content item not found: ${contentId}`);
     }
+    const textToReview = [content.title, content.body].filter(Boolean).join("\n\n") || JSON.stringify(content.data ?? {});
+    const result = await this.reviewService.review(textToReview);
+    const suggestions = result.issues.map((issue) => ({
+      category: issue.category,
+      severity: issue.severity === "info" || issue.severity === "warning" || issue.severity === "error" ? issue.severity : "info",
+      message: issue.message,
+      ...issue.originalText !== void 0 ? { originalText: issue.originalText } : {},
+      ...issue.suggestedFix !== void 0 ? { suggestedFix: issue.suggestedFix } : {}
+    }));
+    const review = {
+      id: crypto5.randomUUID(),
+      contentId,
+      score: result.overallScore,
+      suggestions,
+      passesThreshold: result.passesThreshold,
+      rawResult: result.raw,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    await this.storage.aiReviews.create(review);
+    this.emitter.emit("ai:review:completed", { contentId, review });
+    return review;
   }
-  async deleteWorkflow(req, res) {
-    try {
-      const { id } = req.params;
-      await this.workflowService.deleteWorkflow(id);
-      res.status(204).send();
-    } catch (error) {
-      throw new ContentManagementSuiteInternalError("Failed to delete workflow", error);
+  async generateSocialPosts(contentId, platforms) {
+    if (!this.socialGeneratorService) {
+      throw new InternalError("AI social generator service not configured");
+    }
+    const content = await this.storage.content.get(contentId);
+    if (!content) {
+      throw new NotFoundError(`Content item not found: ${contentId}`);
+    }
+    const textContent = [content.title, content.body].filter(Boolean).join("\n\n") || JSON.stringify(content.data ?? {});
+    const generated = await this.socialGeneratorService.generate(textContent, platforms);
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const workflowId = this.workflowDefaults["social-post"] ?? this.workflowDefaults["generic"];
+    const posts = generated.map((g) => ({
+      id: crypto5.randomUUID(),
+      contentId,
+      platform: g.platform,
+      body: g.body,
+      status: "draft",
+      platformPostId: null,
+      publishedAt: null,
+      createdAt: now,
+      ...workflowId !== void 0 ? { workflowId } : {}
+    }));
+    for (const post of posts) {
+      await this.storage.socialPosts.create(post);
     }
+    this.emitter.emit("ai:social:generated", { contentId, posts });
+    return posts;
   }
-  async getContentTypes(req, res) {
-    try {
-      const contentTypes = this.listContentTypes();
-      res.json(contentTypes);
-    } catch (error) {
-      throw new ContentManagementSuiteInternalError("Failed to get content types", error);
+  async enhance(contentId, opts) {
+    if (!this.enhanceService) {
+      throw new InternalError("AI enhance service not configured");
     }
+    const content = await this.storage.content.get(contentId);
+    if (!content) {
+      throw new NotFoundError(`Content item not found: ${contentId}`);
+    }
+    const textContent = [content.title, content.body].filter(Boolean).join("\n\n") || JSON.stringify(content.data ?? {});
+    return this.enhanceService.enhance(textContent, opts);
   }
-  async handleGetContentType(req, res) {
-    try {
-      const id = req.params.id;
-      if (!id) {
-        throw new ContentManagementSuiteNotFoundError("Content type ID required");
-      }
-      const contentType = this.contentTypes.get(id);
-      if (!contentType) {
-        throw new ContentManagementSuiteNotFoundError("Content type not found");
-      }
-      res.json(contentType);
-    } catch (error) {
-      throw new ContentManagementSuiteNotFoundError("Content type not found", error);
+  async suggest(contentId) {
+    if (!this.enhanceService) {
+      throw new InternalError("AI enhance service not configured");
     }
+    const content = await this.storage.content.get(contentId);
+    if (!content) {
+      throw new NotFoundError(`Content item not found: ${contentId}`);
+    }
+    const textContent = [content.title, content.body].filter(Boolean).join("\n\n") || JSON.stringify(content.data ?? {});
+    return this.enhanceService.suggest(textContent);
   }
-  async createContentType(req, res) {
-    try {
-      const { data } = req.body;
-      this.registerContentType(data);
-      res.status(201).json(data);
-    } catch (error) {
-      throw new ContentManagementSuiteInternalError("Failed to create content type", error);
+};
+
+// src/namespaces/social.ts
+var SocialNamespaceImpl = class {
+  constructor(emitter, storage) {
+    this.store = /* @__PURE__ */ new Map();
+    this.emitter = emitter;
+    this.storage = storage;
+  }
+  registerPlatform(adapter) {
+    this.store.set(adapter.id, adapter);
+  }
+  unregisterPlatform(id) {
+    if (!this.store.has(id)) {
+      throw new NotFoundError(`Social platform not found: ${id}`);
     }
+    this.store.delete(id);
   }
-  async updateContentType(req, res) {
-    try {
-      const id = req.params.id;
-      if (!id) {
-        throw new ContentManagementSuiteNotFoundError("Content type ID required");
+  listPlatforms() {
+    return Array.from(this.store.values()).map((adapter) => ({
+      id: adapter.id,
+      name: adapter.name,
+      acceptedTypes: adapter.acceptedTypes,
+      hasPreview: typeof adapter.preview === "function",
+      hasMetrics: typeof adapter.getMetrics === "function"
+    }));
+  }
+  async publish(contentId, platforms) {
+    const missing = platforms.filter((p) => !this.store.has(p));
+    if (missing.length > 0) {
+      throw new ValidationError(
+        `Unregistered social platform(s): ${missing.join(", ")}`,
+        { details: { missingPlatforms: missing } }
+      );
+    }
+    const content = await this.storage.content.get(contentId);
+    if (!content) {
+      throw new NotFoundError(`Content item not found: ${contentId}`);
+    }
+    if (content.workflowId) {
+      const workflow = await this.storage.workflows.get(content.workflowId);
+      if (workflow && workflow.stages && workflow.stages.length > 0) {
+        const currentStage = workflow.stages.find((s) => s.id === content.workflowStage);
+        const publishStage = workflow.stages.find((s) => s.isPublishStage);
+        if (publishStage && (!currentStage || !currentStage.isPublishStage)) {
+          throw new ValidationError(
+            `Content is not at a publish-eligible stage. Current stage: "${content.workflowStage ?? "none"}", required publish stage: "${publishStage.id}"`,
+            {
+              details: {
+                currentStage: content.workflowStage ?? null,
+                requiredStage: publishStage.id
+              }
+            }
+          );
+        }
       }
-      const { data } = req.body;
-      this.unregisterContentType(id);
-      this.registerContentType(data);
-      res.json(data);
-    } catch (error) {
-      throw new ContentManagementSuiteInternalError("Failed to update content type", error);
     }
-  }
-  async deleteContentType(req, res) {
-    try {
-      const id = req.params.id;
-      if (!id) {
-        throw new ContentManagementSuiteNotFoundError("Content type ID required");
+    const socialPosts = await this.storage.socialPosts.findByContent(contentId);
+    const results = [];
+    for (const platformId of platforms) {
+      const adapter = this.store.get(platformId);
+      if (!adapter) {
+        continue;
+      }
+      if (!adapter.acceptedTypes.includes(content.type)) {
+        results.push({
+          platform: platformId,
+          success: false,
+          error: `Content type "${content.type}" not accepted by platform "${platformId}". Accepted: ${adapter.acceptedTypes.join(", ")}`
+        });
+        continue;
+      }
+      const post = socialPosts.find((p) => p.platform === platformId && p.status === "draft");
+      if (!post) {
+        results.push({
+          platform: platformId,
+          success: false,
+          error: `No draft social post found for platform "${platformId}"`
+        });
+        continue;
+      }
+      try {
+        const result = await adapter.publish(post);
+        results.push(result);
+        if (result.success) {
+          await this.storage.socialPosts.update(post.id, {
+            status: "published",
+            publishedAt: (/* @__PURE__ */ new Date()).toISOString(),
+            ...result.platformPostId !== void 0 ? { platformPostId: result.platformPostId } : {}
+          });
+          this.emitter.emit("social:published", { contentId, platform: platformId, result });
+        } else {
+          await this.storage.socialPosts.update(post.id, { status: "failed" });
+        }
+      } catch (error) {
+        await this.storage.socialPosts.update(post.id, { status: "failed" });
+        results.push({
+          platform: platformId,
+          success: false,
+          error: error instanceof Error ? error.message : String(error)
+        });
       }
-      this.unregisterContentType(id);
-      res.status(204).send();
-    } catch (error) {
-      throw new ContentManagementSuiteInternalError("Failed to delete content type", error);
     }
+    return results;
   }
-  async handleGetConfig(req, res) {
-    try {
-      res.json(this.config);
-    } catch (error) {
-      throw new ContentManagementSuiteInternalError("Failed to get config", error);
+  async preview(contentId, platform) {
+    const adapter = this.store.get(platform);
+    if (!adapter) {
+      throw new NotFoundError(`Social platform not found: ${platform}`);
     }
-  }
-  async handleUpdateConfig(req, res) {
-    try {
-      const { config } = req.body;
-      const newConfig = ContentManagementConfigSchema.parse({
-        ...this.config,
-        ...config
-      });
-      this.config = newConfig;
-      await this.configManager.updateConfig(newConfig);
-      this.emit("config:updated", newConfig);
-      res.json(this.config);
-    } catch (error) {
-      throw new ContentManagementSuiteValidationError("Invalid configuration", error);
+    if (!adapter.preview) {
+      throw new InternalError(`Platform "${platform}" does not support preview`);
     }
-  }
-  async getUsers(req, res) {
-    try {
-      res.json([]);
-    } catch (error) {
-      throw new ContentManagementSuiteInternalError("Failed to get users", error);
+    const posts = await this.storage.socialPosts.findByContent(contentId);
+    const post = posts.find((p) => p.platform === platform);
+    if (!post) {
+      throw new NotFoundError(`No social post found for content "${contentId}" on platform "${platform}"`);
     }
+    return adapter.preview(post);
   }
-  async getUser(req, res) {
-    try {
-      const { id } = req.params;
-      res.json({ id, name: "User" });
-    } catch (error) {
-      throw new ContentManagementSuiteNotFoundError("User not found", error);
+  async getMetrics(contentId, platform) {
+    const adapter = this.store.get(platform);
+    if (!adapter) {
+      throw new NotFoundError(`Social platform not found: ${platform}`);
     }
+    if (!adapter.getMetrics) {
+      throw new InternalError(`Platform "${platform}" does not support metrics`);
+    }
+    const posts = await this.storage.socialPosts.findByContent(contentId);
+    const post = posts.find((p) => p.platform === platform && p.platformPostId);
+    if (!post || !post.platformPostId) {
+      throw new NotFoundError(`No published social post found for content "${contentId}" on platform "${platform}"`);
+    }
+    return adapter.getMetrics(post.platformPostId);
   }
-  async createUser(req, res) {
-    try {
-      const { data } = req.body;
-      res.status(201).json({ id: uuidv4(), ...data });
-    } catch (error) {
-      throw new ContentManagementSuiteInternalError("Failed to create user", error);
+};
+
+// src/content-management-suite.ts
+var ContentManagementSuiteImpl = class extends EventEmitter {
+  constructor(options) {
+    super();
+    this._initialized = false;
+    this._options = options ?? {};
+    this._logger = this._options.logger;
+    this._storage = this._options.storage ?? createInMemoryAdapter();
+    const parsedConfig = ContentManagementConfigSchema.parse(
+      this._options.config ?? {}
+    );
+    const workflowDefaults = this._options.workflows?.defaults ?? {};
+    this.contentTypes = new ContentTypesNamespaceImpl();
+    this.publishers = new PublishersNamespaceImpl(this);
+    this.content = new ContentNamespaceImpl(
+      this,
+      this._storage,
+      () => this.contentTypes,
+      () => this.publishers
+    );
+    this.workflows = new WorkflowsNamespaceImpl(this._storage);
+    this.users = new UsersNamespaceImpl(this);
+    this.permissions = new PermissionsNamespaceImpl();
+    this.config = new ConfigNamespaceImpl(parsedConfig, this);
+    this.plugins = new PluginsNamespaceImpl(this);
+    this.sources = new SourcesNamespaceImpl(this, this._storage, workflowDefaults);
+    const aiOpts = {};
+    if (this._options.ai?.reviewService) {
+      aiOpts.reviewService = this._options.ai.reviewService;
+    }
+    if (this._options.ai?.socialGeneratorService) {
+      aiOpts.socialGeneratorService = this._options.ai.socialGeneratorService;
+    }
+    if (this._options.ai?.enhanceService) {
+      aiOpts.enhanceService = this._options.ai.enhanceService;
     }
+    if (Object.keys(workflowDefaults).length > 0) {
+      aiOpts.workflowDefaults = workflowDefaults;
+    }
+    this.ai = new AINamespaceImpl(this, this._storage, aiOpts);
+    this.social = new SocialNamespaceImpl(this, this._storage);
   }
-  async updateUser(req, res) {
-    try {
-      const { id } = req.params;
-      const { data } = req.body;
-      res.json({ id, ...data });
-    } catch (error) {
-      throw new ContentManagementSuiteInternalError("Failed to update user", error);
+  async initialize() {
+    if (this._initialized) {
+      throw new InternalError("Suite is already initialized");
     }
+    this.contentTypes.register({ id: "text", name: "text" });
+    this.contentTypes.register({ id: "image", name: "image" });
+    this.contentTypes.register({ id: "audio", name: "audio" });
+    this.contentTypes.register({ id: "video", name: "video" });
+    const workflowsImpl = this.workflows;
+    if (typeof workflowsImpl.loadFromStorage === "function") {
+      await workflowsImpl.loadFromStorage();
+    }
+    if (this._options.plugins) {
+      for (const plugin of this._options.plugins) {
+        await this.plugins.register(plugin);
+      }
+    }
+    this.on("ai:review:completed", async ({ contentId, review }) => {
+      try {
+        const content = await this._storage.content.get(contentId);
+        if (!content || !content.workflowId || !content.workflowStage) {
+          return;
+        }
+        const workflow = await this._storage.workflows.get(content.workflowId);
+        if (!workflow || !workflow.stages) {
+          return;
+        }
+        const currentStage = workflow.stages.find((s) => s.id === content.workflowStage);
+        if (!currentStage || !currentStage.conditions) {
+          return;
+        }
+        const { autoAdvance, minScore, requiresHumanReview } = currentStage.conditions;
+        if (requiresHumanReview) {
+          return;
+        }
+        if (autoAdvance && review.passesThreshold && (minScore === void 0 || review.score >= minScore)) {
+          const sortedStages = [...workflow.stages].sort((a, b) => a.order - b.order);
+          const currentIndex = sortedStages.findIndex((s) => s.id === currentStage.id);
+          const nextStage = sortedStages[currentIndex + 1];
+          if (nextStage) {
+            const fromStage = content.workflowStage;
+            await this._storage.content.update(contentId, {
+              workflowStage: nextStage.id
+            });
+            this.emit("workflow:stage:changed", {
+              contentId,
+              workflowId: content.workflowId,
+              from: fromStage,
+              to: nextStage.id
+            });
+          }
+        }
+      } catch {
+      }
+    });
+    this._initialized = true;
+    this.emit("initialized", void 0);
   }
-  async deleteUser(req, res) {
-    try {
-      const { id: _id } = req.params;
-      res.status(204).send();
-    } catch (error) {
-      throw new ContentManagementSuiteInternalError("Failed to delete user", error);
+  async dispose() {
+    if (!this._initialized) {
+      throw new InternalError("Suite is not initialized");
     }
+    this._initialized = false;
+    this.emit("disposed", void 0);
+  }
+  on(event, listener) {
+    return super.on(event, listener);
+  }
+  emit(event, ...args) {
+    return super.emit(event, ...args);
   }
 };
-function createContentManagementSuite(options = {}) {
+function createContentManagementSuite(options) {
   return new ContentManagementSuiteImpl(options);
 }
 export {
-  AudioContentTypeManager2 as AudioContentTypeManager,
-  AutosaveManager,
+  ConflictError,
   ContentManagementConfigSchema,
-  ContentManagementSuiteConflictError,
-  ContentManagementSuiteError,
-  ContentManagementSuiteForbiddenError,
-  ContentManagementSuiteInternalError,
-  ContentManagementSuiteNotFoundError,
-  ContentManagementSuiteUnauthorizedError,
-  ContentManagementSuiteValidationError,
-  ContentSoftDelete,
-  ContentTypeRegistry2 as ContentTypeRegistry,
-  EditorialWorkflowEngine,
-  ImageContentType2 as ImageContentType,
-  StageActionButtons2 as StageActionButtons,
-  TextContentType2 as TextContentType,
-  VideoContentType2 as VideoContentType,
-  WorkflowAdminConfig2 as WorkflowAdminConfig,
-  WorkflowBuilder,
-  WorkflowFactory,
-  WorkflowStepper2 as WorkflowStepper,
-  WorkflowTemplates,
-  WorkflowTimeline2 as WorkflowTimeline,
-  createContentManagementSuite
+  ContentManagementError,
+  ForbiddenError,
+  InternalError,
+  NotFoundError,
+  UnauthorizedError,
+  ValidationError,
+  createContentManagementSuite,
+  createInMemoryAdapter
 };
 //# sourceMappingURL=index.mjs.map