@bernierllc/content-management-suite 0.4.2 → 0.6.0

package/dist/index.js

@@ -1,4 +1,3 @@
-"use client";
 "use strict";
 var __create = Object.create;
 var __defProp = Object.defineProperty;
@@ -31,73 +30,36 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
-  AudioContentTypeManager: () => import_content_type_audio2.AudioContentTypeManager,
+  AudioContentTypeManager: () => import_content_type_audio.AudioContentTypeManager,
   AutosaveManager: () => import_content_autosave_manager.AutosaveManager,
+  ConflictError: () => ConflictError,
   ContentManagementConfigSchema: () => ContentManagementConfigSchema,
-  ContentManagementSuiteConflictError: () => ContentManagementSuiteConflictError,
-  ContentManagementSuiteError: () => ContentManagementSuiteError,
-  ContentManagementSuiteForbiddenError: () => ContentManagementSuiteForbiddenError,
-  ContentManagementSuiteInternalError: () => ContentManagementSuiteInternalError,
-  ContentManagementSuiteNotFoundError: () => ContentManagementSuiteNotFoundError,
-  ContentManagementSuiteUnauthorizedError: () => ContentManagementSuiteUnauthorizedError,
-  ContentManagementSuiteValidationError: () => ContentManagementSuiteValidationError,
+  ContentManagementError: () => ContentManagementError,
   ContentSoftDelete: () => import_content_soft_delete.ContentSoftDelete,
-  ContentTypeRegistry: () => import_content_type_registry2.ContentTypeRegistry,
+  ContentTypeRegistry: () => import_content_type_registry.ContentTypeRegistry,
   EditorialWorkflowEngine: () => import_content_editorial_workflow.EditorialWorkflowEngine,
-  ImageContentType: () => import_content_type_image2.ImageContentType,
-  StageActionButtons: () => import_content_workflow_ui2.StageActionButtons,
-  TextContentType: () => import_content_type_text2.TextContentType,
-  VideoContentType: () => import_content_type_video2.VideoContentType,
-  WorkflowAdminConfig: () => import_content_workflow_ui2.WorkflowAdminConfig,
+  ForbiddenError: () => ForbiddenError,
+  ImageContentType: () => import_content_type_image.ImageContentType,
+  InternalError: () => InternalError,
+  NotFoundError: () => NotFoundError,
+  TextContentType: () => import_content_type_text.TextContentType,
+  UnauthorizedError: () => UnauthorizedError,
+  ValidationError: () => ValidationError,
+  VideoContentType: () => import_content_type_video.VideoContentType,
   WorkflowBuilder: () => import_content_editorial_workflow.WorkflowBuilder,
   WorkflowFactory: () => import_content_editorial_workflow.WorkflowFactory,
-  WorkflowStepper: () => import_content_workflow_ui2.WorkflowStepper,
   WorkflowTemplates: () => import_content_editorial_workflow.WorkflowTemplates,
-  WorkflowTimeline: () => import_content_workflow_ui2.WorkflowTimeline,
   createContentManagementSuite: () => createContentManagementSuite
 });
 module.exports = __toCommonJS(src_exports);
 
-// src/types.ts
+// src/content-management-suite.ts
+var import_events = require("events");
+
+// src/config.ts
 var import_zod = require("zod");
 var ContentManagementConfigSchema = import_zod.z.object({
-  // Server Configuration
-  server: import_zod.z.object({
-    port: import_zod.z.number().default(3e3),
-    host: import_zod.z.string().default("localhost"),
-    cors: import_zod.z.object({
-      origin: import_zod.z.union([import_zod.z.string(), import_zod.z.array(import_zod.z.string())]).default("*"),
-      credentials: import_zod.z.boolean().default(true)
-    }).default({}),
-    security: import_zod.z.object({
-      helmet: import_zod.z.boolean().default(true),
-      rateLimit: import_zod.z.object({
-        enabled: import_zod.z.boolean().default(true),
-        windowMs: import_zod.z.number().default(15 * 60 * 1e3),
-        // 15 minutes
-        max: import_zod.z.number().default(100)
-        // limit each IP to 100 requests per windowMs
-      }).default({})
-    }).default({})
-  }).default({}),
-  // Database Configuration
-  database: import_zod.z.object({
-    type: import_zod.z.enum(["sqlite", "postgresql", "mysql", "mongodb"]).default("sqlite"),
-    url: import_zod.z.string().optional(),
-    host: import_zod.z.string().default("localhost"),
-    port: import_zod.z.number().optional(),
-    name: import_zod.z.string().default("content_management"),
-    username: import_zod.z.string().optional(),
-    password: import_zod.z.string().optional(),
-    ssl: import_zod.z.boolean().default(false),
-    pool: import_zod.z.object({
-      min: import_zod.z.number().default(2),
-      max: import_zod.z.number().default(10)
-    }).default({})
-  }).default({}),
-  // Content Configuration
   content: import_zod.z.object({
-    // Default editorial workflow
     defaultWorkflow: import_zod.z.object({
       id: import_zod.z.string().default("standard"),
       name: import_zod.z.string().default("Standard Workflow"),
@@ -111,24 +73,8 @@ var ContentManagementConfigSchema = import_zod.z.object({
         description: import_zod.z.string().optional(),
         permissions: import_zod.z.array(import_zod.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: import_zod.z.array(import_zod.z.object({
         id: import_zod.z.string(),
@@ -137,34 +83,23 @@ var ContentManagementConfigSchema = import_zod.z.object({
         description: import_zod.z.string().optional(),
         permissions: import_zod.z.array(import_zod.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: import_zod.z.array(import_zod.z.string()).default(["text", "image", "audio", "video"]),
-    // Auto-save configuration
     autoSave: import_zod.z.object({
       enabled: import_zod.z.boolean().default(true),
       debounceMs: import_zod.z.number().default(1e3),
       maxRetries: import_zod.z.number().default(3),
       backoffMs: import_zod.z.number().default(1e3)
     }).default({}),
-    // Soft delete configuration
     softDelete: import_zod.z.object({
       enabled: import_zod.z.boolean().default(true),
       showDeletedToUsers: import_zod.z.boolean().default(false),
       retentionDays: import_zod.z.number().default(30)
     }).default({}),
-    // File upload configuration
     upload: import_zod.z.object({
       maxFileSize: import_zod.z.number().default(104857600),
-      // 100MB
       allowedTypes: import_zod.z.array(import_zod.z.string()).default([
         "image/jpeg",
         "image/png",
@@ -178,893 +113,542 @@ var ContentManagementConfigSchema = import_zod.z.object({
         "video/ogg"
       ]),
       storage: import_zod.z.object({
-        type: import_zod.z.enum(["local", "s3", "gcs", "azure"]).default("local"),
+        type: import_zod.z.enum(["local", "s3"]).default("local"),
         path: import_zod.z.string().default("./uploads"),
         bucket: import_zod.z.string().optional(),
-        region: import_zod.z.string().optional(),
-        accessKey: import_zod.z.string().optional(),
-        secretKey: import_zod.z.string().optional()
-      }).default({})
+        region: import_zod.z.string().optional()
+      }).default({}).optional()
     }).default({})
   }).default({}),
-  // UI Configuration
-  ui: import_zod.z.object({
-    theme: import_zod.z.object({
-      mode: import_zod.z.enum(["light", "dark", "auto"]).default("auto"),
-      primaryColor: import_zod.z.string().default("#007bff"),
-      secondaryColor: import_zod.z.string().default("#6c757d"),
-      accentColor: import_zod.z.string().default("#17a2b8")
-    }).default({}),
-    editor: import_zod.z.object({
-      showToolbar: import_zod.z.boolean().default(true),
-      showStatusBar: import_zod.z.boolean().default(true),
-      showWordCount: import_zod.z.boolean().default(true),
-      showCharacterCount: import_zod.z.boolean().default(true),
-      autoSave: import_zod.z.boolean().default(true),
-      placeholder: import_zod.z.string().default("Start writing your content...")
-    }).default({}),
-    list: import_zod.z.object({
-      defaultView: import_zod.z.enum(["table", "list", "grid", "kanban"]).default("table"),
-      pageSize: import_zod.z.number().default(20),
-      showSearch: import_zod.z.boolean().default(true),
-      showFilters: import_zod.z.boolean().default(true),
-      showSorting: import_zod.z.boolean().default(true),
-      showPagination: import_zod.z.boolean().default(true)
+  database: import_zod.z.object({
+    type: import_zod.z.enum(["sqlite", "postgresql", "mysql", "mongodb"]).default("sqlite"),
+    url: import_zod.z.string().optional(),
+    host: import_zod.z.string().default("localhost"),
+    port: import_zod.z.number().optional(),
+    name: import_zod.z.string().default("content_management"),
+    username: import_zod.z.string().optional(),
+    password: import_zod.z.string().optional(),
+    ssl: import_zod.z.boolean().default(false),
+    pool: import_zod.z.object({
+      min: import_zod.z.number().default(2),
+      max: import_zod.z.number().default(10),
+      idleTimeoutMs: import_zod.z.number().optional()
     }).default({})
   }).default({}),
-  // Integration Configuration
   integrations: import_zod.z.object({
     neverAdmin: import_zod.z.object({
       enabled: import_zod.z.boolean().default(false),
-      url: import_zod.z.string().optional(),
-      apiKey: import_zod.z.string().optional(),
-      syncInterval: import_zod.z.number().default(3e5)
-      // 5 minutes
+      endpoint: import_zod.z.string().optional()
     }).default({}),
     neverHub: import_zod.z.object({
       enabled: import_zod.z.boolean().default(false),
-      url: import_zod.z.string().optional(),
-      apiKey: import_zod.z.string().optional(),
-      packageDiscovery: import_zod.z.boolean().default(true)
+      endpoint: import_zod.z.string().optional()
     }).default({}),
     analytics: import_zod.z.object({
       enabled: import_zod.z.boolean().default(false),
-      provider: import_zod.z.enum(["google", "mixpanel", "amplitude", "custom"]).optional(),
-      trackingId: import_zod.z.string().optional(),
-      config: import_zod.z.record(import_zod.z.any()).default({})
+      provider: import_zod.z.string().optional()
     }).default({})
   }).default({}),
-  // Security Configuration
   security: import_zod.z.object({
-    jwt: import_zod.z.object({
-      secret: import_zod.z.string().default("your-secret-key"),
-      expiresIn: import_zod.z.string().default("24h"),
-      issuer: import_zod.z.string().default("content-management-suite")
-    }).default({}),
     permissions: import_zod.z.object({
       enabled: import_zod.z.boolean().default(true),
-      defaultRole: import_zod.z.string().default("user"),
-      roles: import_zod.z.array(import_zod.z.object({
-        name: import_zod.z.string(),
-        permissions: import_zod.z.array(import_zod.z.string()),
-        description: import_zod.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: import_zod.z.string().default("user")
+    }).default({}),
+    roles: import_zod.z.array(import_zod.z.object({
+      name: import_zod.z.string(),
+      permissions: import_zod.z.array(import_zod.z.string()),
+      description: import_zod.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({}),
-  // Logging Configuration
   logging: import_zod.z.object({
-    level: import_zod.z.enum(["error", "warn", "info", "debug"]).default("info"),
-    format: import_zod.z.enum(["json", "text"]).default("json"),
-    file: import_zod.z.object({
-      enabled: import_zod.z.boolean().default(true),
-      path: import_zod.z.string().default("./logs"),
-      maxSize: import_zod.z.string().default("10MB"),
-      maxFiles: import_zod.z.number().default(5)
-    }).default({}),
-    console: import_zod.z.object({
-      enabled: import_zod.z.boolean().default(true),
-      colorize: import_zod.z.boolean().default(true)
-    }).default({})
+    level: import_zod.z.enum(["error", "warn", "info", "debug"]).default("info")
   }).default({}),
-  // Performance Configuration
   performance: import_zod.z.object({
     cache: import_zod.z.object({
       enabled: import_zod.z.boolean().default(true),
       ttl: import_zod.z.number().default(300),
-      // 5 minutes
       maxSize: import_zod.z.number().default(1e3)
-    }).default({}),
-    compression: import_zod.z.object({
-      enabled: import_zod.z.boolean().default(true),
-      level: import_zod.z.number().min(1).max(9).default(6)
-    }).default({}),
-    rateLimit: import_zod.z.object({
-      enabled: import_zod.z.boolean().default(true),
-      windowMs: import_zod.z.number().default(15 * 60 * 1e3),
-      // 15 minutes
-      max: import_zod.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
-var import_content_workflow_ui2 = require("@bernierllc/content-workflow-ui");
-var import_content_type_text2 = require("@bernierllc/content-type-text");
-var import_content_type_image2 = require("@bernierllc/content-type-image");
-var import_content_type_audio2 = require("@bernierllc/content-type-audio");
-var import_content_type_video2 = require("@bernierllc/content-type-video");
-var import_content_type_registry2 = require("@bernierllc/content-type-registry");
-var import_content_editorial_workflow = require("@bernierllc/content-editorial-workflow");
-var import_content_autosave_manager = require("@bernierllc/content-autosave-manager");
-var import_content_soft_delete = require("@bernierllc/content-soft-delete");
-
-// src/content-management-suite.ts
-var import_events = require("events");
-var import_express = __toESM(require("express"));
-var import_cors = __toESM(require("cors"));
-var import_helmet = __toESM(require("helmet"));
-var import_morgan = __toESM(require("morgan"));
-var import_compression = __toESM(require("compression"));
-var import_uuid = require("uuid");
-var import_content_type_registry = require("@bernierllc/content-type-registry");
-var import_content_type_text = require("@bernierllc/content-type-text");
-var import_content_type_image = require("@bernierllc/content-type-image");
-var import_content_type_audio = require("@bernierllc/content-type-audio");
-var import_content_type_video = require("@bernierllc/content-type-video");
-var import_content_workflow_ui = require("@bernierllc/content-workflow-ui");
-var ContentManagementSuiteImpl = class extends import_events.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 import_content_type_registry.ContentTypeRegistry();
-    this.configManager = this.createConfigManagerStub();
-    this.workflowService = this.createWorkflowServiceStub();
-    this.editorService = this.createEditorServiceStub();
-    this.workflow = {
-      stepper: import_content_workflow_ui.WorkflowStepper,
-      actions: import_content_workflow_ui.StageActionButtons,
-      timeline: import_content_workflow_ui.WorkflowTimeline,
-      admin: import_content_workflow_ui.WorkflowAdminConfig
+// src/namespaces/content.ts
+var crypto = __toESM(require("crypto"));
+var ContentNamespaceImpl = class {
+  constructor(emitter) {
+    this.store = /* @__PURE__ */ new Map();
+    this.emitter = emitter;
+  }
+  async create(input) {
+    const item = {
+      id: crypto.randomUUID(),
+      type: input.type,
+      data: { ...input.data },
+      status: "draft",
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
     };
-    this.server = (0, import_express.default)();
-    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 () => {
-      }
+    this.store.set(item.id, item);
+    this.emitter.emit("content:created", item);
+    return item;
+  }
+  async get(id) {
+    const item = this.store.get(id);
+    if (!item) {
+      throw new NotFoundError(`Content item not found: ${id}`);
+    }
+    return item;
+  }
+  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 update(id, input) {
+    const existing = this.store.get(id);
+    if (!existing) {
+      throw new NotFoundError(`Content item not found: ${id}`);
+    }
+    const updated = {
+      ...existing,
+      data: { ...existing.data, ...input.data },
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
     };
-  }
-  createWorkflowServiceStub() {
-    return {
-      listWorkflows: async () => [],
-      getWorkflow: async (id) => ({ id, name: "Default Workflow" }),
-      createWorkflow: async (data) => ({ id: (0, import_uuid.v4)(), ...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 () => {
-      }
+    this.store.set(id, updated);
+    this.emitter.emit("content:updated", updated);
+    return updated;
+  }
+  async delete(id) {
+    if (!this.store.has(id)) {
+      throw new NotFoundError(`Content item not found: ${id}`);
+    }
+    this.store.delete(id);
+    this.emitter.emit("content:deleted", { id });
+  }
+  async publish(id) {
+    const existing = this.store.get(id);
+    if (!existing) {
+      throw new NotFoundError(`Content item not found: ${id}`);
+    }
+    const published = {
+      ...existing,
+      status: "published",
+      publishedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
     };
-  }
-  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: (0, import_uuid.v4)(), 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 () => {
-      }
+    this.store.set(id, published);
+    this.emitter.emit("content:published", published);
+    return published;
+  }
+  async unpublish(id) {
+    const existing = this.store.get(id);
+    if (!existing) {
+      throw new NotFoundError(`Content item not found: ${id}`);
+    }
+    const unpublished = {
+      ...existing,
+      status: "draft",
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
     };
-  }
-  // 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) => {
-      }
+    this.store.set(id, unpublished);
+    this.emitter.emit("content:unpublished", unpublished);
+    return unpublished;
+  }
+  async schedule(id, date) {
+    const existing = this.store.get(id);
+    if (!existing) {
+      throw new NotFoundError(`Content item not found: ${id}`);
+    }
+    const scheduled = {
+      ...existing,
+      scheduledFor: date,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
     };
-  }
-  // 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) => {
-      }
-    };
-  }
-  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({});
-    }
-  }
-  setupMiddleware() {
-    if (this.config.server.security.helmet) {
-      this.server.use((0, import_helmet.default)());
-    }
-    this.server.use((0, import_cors.default)(this.config.server.cors));
-    if (this.config.performance.compression.enabled) {
-      this.server.use((0, import_compression.default)({
-        level: this.config.performance.compression.level
-      }));
-    }
-    if (this.options.logger) {
-      this.server.use((0, import_morgan.default)("combined", {
-        stream: {
-          write: (message) => {
-            this.options.logger?.info(message.trim());
-          }
-        }
-      }));
-    }
-    this.server.use(import_express.default.json({ limit: "10mb" }));
-    this.server.use(import_express.default.urlencoded({ extended: true, limit: "10mb" }));
-    this.middleware.sort((a, b) => (a.order || 0) - (b.order || 0)).forEach((middleware) => {
-      this.server.use(middleware.handler);
-    });
-  }
-  setupRoutes() {
-    this.server.get("/health", (req, res) => {
-      res.json({
-        status: "healthy",
-        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-        version: "0.1.0",
-        uptime: process.uptime()
-      });
+    this.store.set(id, scheduled);
+    this.emitter.emit("content:scheduled", { item: scheduled, date });
+    return scheduled;
+  }
+  async search(query, options) {
+    const lowerQuery = query.toLowerCase();
+    let items = Array.from(this.store.values()).filter((item) => {
+      return Object.values(item.data).some(
+        (value) => typeof value === "string" && value.toLowerCase().includes(lowerQuery)
+      );
     });
-    this.server.use("/api", this.createAPIRoutes());
-    this.server.use("/admin", this.createAdminRoutes());
-    this.server.use("/static", import_express.default.static("public"));
-    this.server.use(this.errorHandler.bind(this));
-  }
-  createAPIRoutes() {
-    const router = import_express.default.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 = import_express.default.Router();
-    router.get("/", (req, res) => {
-      res.json({
-        message: "Content Management Suite Admin",
-        version: "0.1.0",
-        endpoints: [
-          "/workflows",
-          "/content-types",
-          "/config",
-          "/users"
-        ]
-      });
-    });
-    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
-        }
-      });
-    } else {
-      res.status(500).json({
-        error: {
-          code: "INTERNAL_ERROR",
-          message: "An unexpected error occurred",
-          details: process.env.NODE_ENV === "development" ? error.message : void 0
-        }
-      });
-    }
-  }
-  registerDefaultContentTypes() {
-    this.contentTypes.set("text", import_content_type_text.TextContentType);
-    this.contentTypes.set("image", import_content_type_image.ImageContentType);
-    this.contentTypes.set("audio", import_content_type_audio.AudioContentTypeManager);
-    this.contentTypes.set("video", import_content_type_video.VideoContentType);
-  }
-  // Public API Methods
-  async start() {
-    if (this.isStarted) {
-      throw new ContentManagementSuiteError("Suite is already started", "ALREADY_STARTED");
+    if (options?.type) {
+      items = items.filter((item) => item.type === options.type);
     }
-    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));
-        });
-      });
-    } catch (error) {
-      this.emit("error", error);
-      throw new ContentManagementSuiteInternalError("Failed to start suite", error);
+    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 };
   }
-  async stop() {
-    if (this.isStopped) {
-      throw new ContentManagementSuiteError("Suite is already stopped", "ALREADY_STOPPED");
-    }
-    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);
-    }
-  }
-  getConfig() {
-    return this.config;
+};
+
+// src/namespaces/content-types.ts
+var ContentTypesNamespaceImpl = class {
+  constructor() {
+    this.store = /* @__PURE__ */ new Map();
   }
-  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);
+  register(contentType) {
+    const id = contentType.id ?? contentType.name;
+    if (!id) {
+      throw new Error("Content type must have an id or name");
     }
+    this.store.set(id, contentType);
   }
-  registerContentType(contentType) {
-    const id = contentType?.id || contentType?.name || "unknown";
-    this.contentTypes.set(id, contentType);
-    this.emit("contentType:registered", contentType);
-  }
-  unregisterContentType(contentTypeId) {
-    if (!this.contentTypes.has(contentTypeId)) {
-      throw new ContentManagementSuiteNotFoundError("Content type not found");
+  unregister(id) {
+    if (!this.store.has(id)) {
+      throw new NotFoundError(`Content type not found: ${id}`);
     }
-    this.contentTypes.delete(contentTypeId);
-    this.emit("contentType:unregistered", contentTypeId);
+    this.store.delete(id);
   }
-  getContentType(contentTypeId) {
-    const contentType = this.contentTypes.get(contentTypeId);
-    if (!contentType) {
-      throw new ContentManagementSuiteNotFoundError("Content type not found");
+  get(id) {
+    const contentType = this.store.get(id);
+    if (contentType === void 0) {
+      throw new NotFoundError(`Content type not found: ${id}`);
     }
-    return contentType;
+    return { id, contentType };
   }
-  listContentTypes() {
-    return Array.from(this.contentTypes.entries()).map(([id, contentType]) => ({
+  list() {
+    return Array.from(this.store.entries()).map(([id, contentType]) => ({
       id,
-      contentType,
-      ...contentType
+      contentType
     }));
   }
-  // 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);
-  }
-  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);
+};
+
+// src/namespaces/workflows.ts
+var crypto2 = __toESM(require("crypto"));
+var WorkflowsNamespaceImpl = class {
+  constructor() {
+    this.store = /* @__PURE__ */ new Map();
+  }
+  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 } : {}
+    };
+    this.store.set(workflow.id, workflow);
+    return workflow;
   }
-  // Hook Management
-  addHook(hook) {
-    if (!this.hooks.has(hook.name)) {
-      this.hooks.set(hook.name, []);
+  async get(id) {
+    const workflow = this.store.get(id);
+    if (!workflow) {
+      throw new NotFoundError(`Workflow not found: ${id}`);
     }
-    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);
+    return workflow;
   }
-  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);
-    }
-    this.emit("hook:removed", hookName);
+  async list() {
+    return Array.from(this.store.values());
   }
-  // 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 update(id, input) {
+    const existing = this.store.get(id);
+    if (!existing) {
+      throw new NotFoundError(`Workflow not found: ${id}`);
     }
+    const updated = { ...existing, ...input };
+    this.store.set(id, 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(`Workflow not found: ${id}`);
     }
+    this.store.delete(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);
-    }
-  }
-  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);
-    }
+};
+
+// src/namespaces/users.ts
+var crypto3 = __toESM(require("crypto"));
+var UsersNamespaceImpl = class {
+  constructor(emitter) {
+    this.store = /* @__PURE__ */ new Map();
+    this.emitter = emitter;
+  }
+  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;
+  }
+  async get(id) {
+    const user = this.store.get(id);
+    if (!user) {
+      throw new NotFoundError(`User not found: ${id}`);
+    }
+    return user;
+  }
+  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 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);
+  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 publishContent(req, res) {
-    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);
-    }
+};
+var PermissionsNamespaceImpl = class {
+  constructor() {
+    this.store = /* @__PURE__ */ new Map();
   }
-  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);
-    }
+  async check(userId, permission) {
+    const perms = this.store.get(userId);
+    return perms?.has(permission) ?? false;
   }
-  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 grant(userId, permission) {
+    let perms = this.store.get(userId);
+    if (!perms) {
+      perms = /* @__PURE__ */ new Set();
+      this.store.set(userId, perms);
     }
+    perms.add(permission);
   }
-  async getWorkflows(req, res) {
-    try {
-      const workflows = await this.workflowService.listWorkflows();
-      res.json(workflows);
-    } catch (error) {
-      throw new ContentManagementSuiteInternalError("Failed to get workflows", error);
+  async revoke(userId, permission) {
+    const perms = this.store.get(userId);
+    if (perms) {
+      perms.delete(permission);
     }
   }
-  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);
+};
+
+// 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 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);
-    }
+  return result;
+}
+var ConfigNamespaceImpl = class {
+  constructor(initialConfig, emitter) {
+    this.config = initialConfig;
+    this.emitter = emitter;
   }
-  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);
-    }
+  get() {
+    return this.config;
   }
-  async deleteWorkflow(req, res) {
+  update(partial) {
+    const merged = deepMerge(this.config, partial);
     try {
-      const { id } = req.params;
-      await this.workflowService.deleteWorkflow(id);
-      res.status(204).send();
-    } catch (error) {
-      throw new ContentManagementSuiteInternalError("Failed to delete workflow", 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 getContentTypes(req, res) {
-    try {
-      const contentTypes = this.listContentTypes();
-      res.json(contentTypes);
-    } catch (error) {
-      throw new ContentManagementSuiteInternalError("Failed to get content types", error);
-    }
+};
+
+// src/namespaces/plugins.ts
+var PluginsNamespaceImpl = class {
+  constructor(suite) {
+    this.store = /* @__PURE__ */ new Map();
+    this.suite = suite;
   }
-  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 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 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);
+  async unregister(name) {
+    const plugin = this.store.get(name);
+    if (!plugin) {
+      throw new NotFoundError(`Plugin not found: ${name}`);
     }
-  }
-  async updateContentType(req, res) {
-    try {
-      const id = req.params.id;
-      if (!id) {
-        throw new ContentManagementSuiteNotFoundError("Content type ID required");
-      }
-      const { data } = req.body;
-      this.unregisterContentType(id);
-      this.registerContentType(data);
-      res.json(data);
-    } catch (error) {
-      throw new ContentManagementSuiteInternalError("Failed to update content type", error);
+    if (plugin.teardown) {
+      await plugin.teardown(this.suite);
     }
+    this.store.delete(name);
   }
-  async deleteContentType(req, res) {
-    try {
-      const id = req.params.id;
-      if (!id) {
-        throw new ContentManagementSuiteNotFoundError("Content type ID required");
+};
+
+// src/content-management-suite.ts
+var ContentManagementSuiteImpl = class extends import_events.EventEmitter {
+  constructor(options) {
+    super();
+    this._initialized = false;
+    this._options = options ?? {};
+    this._logger = this._options.logger;
+    const parsedConfig = ContentManagementConfigSchema.parse(
+      this._options.config ?? {}
+    );
+    this.content = new ContentNamespaceImpl(this);
+    this.contentTypes = new ContentTypesNamespaceImpl();
+    this.workflows = new WorkflowsNamespaceImpl();
+    this.users = new UsersNamespaceImpl(this);
+    this.permissions = new PermissionsNamespaceImpl();
+    this.config = new ConfigNamespaceImpl(parsedConfig, this);
+    this.plugins = new PluginsNamespaceImpl(this);
+  }
+  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" });
+    if (this._options.plugins) {
+      for (const plugin of this._options.plugins) {
+        await this.plugins.register(plugin);
       }
-      this.unregisterContentType(id);
-      res.status(204).send();
-    } catch (error) {
-      throw new ContentManagementSuiteInternalError("Failed to delete content type", error);
-    }
-  }
-  async handleGetConfig(req, res) {
-    try {
-      res.json(this.config);
-    } catch (error) {
-      throw new ContentManagementSuiteInternalError("Failed to get config", error);
     }
+    this._initialized = true;
+    this.emit("initialized", void 0);
   }
-  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);
-    }
-  }
-  async getUsers(req, res) {
-    try {
-      res.json([]);
-    } catch (error) {
-      throw new ContentManagementSuiteInternalError("Failed to get users", error);
-    }
-  }
-  async getUser(req, res) {
-    try {
-      const { id } = req.params;
-      res.json({ id, name: "User" });
-    } catch (error) {
-      throw new ContentManagementSuiteNotFoundError("User not found", error);
-    }
-  }
-  async createUser(req, res) {
-    try {
-      const { data } = req.body;
-      res.status(201).json({ id: (0, import_uuid.v4)(), ...data });
-    } catch (error) {
-      throw new ContentManagementSuiteInternalError("Failed to create user", error);
+  async dispose() {
+    if (!this._initialized) {
+      throw new InternalError("Suite is not initialized");
     }
+    this._initialized = false;
+    this.emit("disposed", void 0);
   }
-  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);
-    }
+  on(event, listener) {
+    return super.on(event, listener);
   }
-  async deleteUser(req, res) {
-    try {
-      const { id: _id } = req.params;
-      res.status(204).send();
-    } catch (error) {
-      throw new ContentManagementSuiteInternalError("Failed to delete user", error);
-    }
+  emit(event, ...args) {
+    return super.emit(event, ...args);
   }
 };
-function createContentManagementSuite(options = {}) {
+function createContentManagementSuite(options) {
   return new ContentManagementSuiteImpl(options);
 }
+
+// src/index.ts
+var import_content_type_registry = require("@bernierllc/content-type-registry");
+var import_content_editorial_workflow = require("@bernierllc/content-editorial-workflow");
+var import_content_autosave_manager = require("@bernierllc/content-autosave-manager");
+var import_content_soft_delete = require("@bernierllc/content-soft-delete");
+var import_content_type_text = require("@bernierllc/content-type-text");
+var import_content_type_image = require("@bernierllc/content-type-image");
+var import_content_type_audio = require("@bernierllc/content-type-audio");
+var import_content_type_video = require("@bernierllc/content-type-video");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AudioContentTypeManager,
   AutosaveManager,
+  ConflictError,
   ContentManagementConfigSchema,
-  ContentManagementSuiteConflictError,
-  ContentManagementSuiteError,
-  ContentManagementSuiteForbiddenError,
-  ContentManagementSuiteInternalError,
-  ContentManagementSuiteNotFoundError,
-  ContentManagementSuiteUnauthorizedError,
-  ContentManagementSuiteValidationError,
+  ContentManagementError,
   ContentSoftDelete,
   ContentTypeRegistry,
   EditorialWorkflowEngine,
+  ForbiddenError,
   ImageContentType,
-  StageActionButtons,
+  InternalError,
+  NotFoundError,
   TextContentType,
+  UnauthorizedError,
+  ValidationError,
   VideoContentType,
-  WorkflowAdminConfig,
   WorkflowBuilder,
   WorkflowFactory,
-  WorkflowStepper,
   WorkflowTemplates,
-  WorkflowTimeline,
   createContentManagementSuite
 });
 //# sourceMappingURL=index.js.map