@bernierllc/content-management-suite 0.4.2 → 0.6.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,541 @@ 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({}),
-  // 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
+// src/namespaces/content.ts
+import * as crypto from "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 = 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 () => {
-      }
+    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: 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 () => {
-      }
+    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: 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 () => {
-      }
+    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) => {
-      }
-    };
-  }
-  // 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) => {
-      }
+    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()
     };
-  }
-  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(helmet());
-    }
-    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 (this.options.logger) {
-      this.server.use(morgan("combined", {
-        stream: {
-          write: (message) => {
-            this.options.logger?.info(message.trim());
-          }
-        }
-      }));
-    }
-    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);
+    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)
+      );
     });
-  }
-  setupRoutes() {
-    this.server.get("/health", (req, res) => {
-      res.json({
-        status: "healthy",
-        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-        version: "0.1.0",
-        uptime: process.uptime()
-      });
-    });
-    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"
-        ]
-      });
-    });
-    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", TextContentType);
-    this.contentTypes.set("image", ImageContentType);
-    this.contentTypes.set("audio", AudioContentTypeManager);
-    this.contentTypes.set("video", VideoContentType);
-  }
-  // Public API Methods
-  async start() {
-    if (this.isStarted) {
-      throw new ContentManagementSuiteError("Suite is already started", "ALREADY_STARTED");
-    }
-    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);
-    }
-  }
-  async stop() {
-    if (this.isStopped) {
-      throw new ContentManagementSuiteError("Suite is already stopped", "ALREADY_STOPPED");
+    if (options?.type) {
+      items = items.filter((item) => item.type === options.type);
     }
-    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);
+    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 };
   }
-  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
+import * as crypto2 from "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, []);
-    }
-    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 workflow = this.store.get(id);
+    if (!workflow) {
+      throw new NotFoundError(`Workflow not found: ${id}`);
     }
-    this.emit("hook:removed", hookName);
+    return workflow;
   }
-  // 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() {
+    return Array.from(this.store.values());
   }
-  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 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 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 delete(id) {
+    if (!this.store.has(id)) {
+      throw new NotFoundError(`Workflow not found: ${id}`);
     }
+    this.store.delete(id);
   }
-  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
+import * as crypto3 from "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 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);
     }
+    this._initialized = true;
+    this.emit("initialized", void 0);
   }
-  async handleGetConfig(req, res) {
-    try {
-      res.json(this.config);
-    } catch (error) {
-      throw new ContentManagementSuiteInternalError("Failed to get config", error);
+  async dispose() {
+    if (!this._initialized) {
+      throw new InternalError("Suite is not initialized");
     }
+    this._initialized = false;
+    this.emit("disposed", 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);
-    }
+  on(event, listener) {
+    return super.on(event, listener);
   }
-  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: uuidv4(), ...data });
-    } catch (error) {
-      throw new ContentManagementSuiteInternalError("Failed to create user", error);
-    }
-  }
-  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 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
+import { ContentTypeRegistry } 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";
+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";
 export {
-  AudioContentTypeManager2 as AudioContentTypeManager,
+  AudioContentTypeManager,
   AutosaveManager,
+  ConflictError,
   ContentManagementConfigSchema,
-  ContentManagementSuiteConflictError,
-  ContentManagementSuiteError,
-  ContentManagementSuiteForbiddenError,
-  ContentManagementSuiteInternalError,
-  ContentManagementSuiteNotFoundError,
-  ContentManagementSuiteUnauthorizedError,
-  ContentManagementSuiteValidationError,
+  ContentManagementError,
   ContentSoftDelete,
-  ContentTypeRegistry2 as ContentTypeRegistry,
+  ContentTypeRegistry,
   EditorialWorkflowEngine,
-  ImageContentType2 as ImageContentType,
-  StageActionButtons2 as StageActionButtons,
-  TextContentType2 as TextContentType,
-  VideoContentType2 as VideoContentType,
-  WorkflowAdminConfig2 as WorkflowAdminConfig,
+  ForbiddenError,
+  ImageContentType,
+  InternalError,
+  NotFoundError,
+  TextContentType,
+  UnauthorizedError,
+  ValidationError,
+  VideoContentType,
   WorkflowBuilder,
   WorkflowFactory,
-  WorkflowStepper2 as WorkflowStepper,
   WorkflowTemplates,
-  WorkflowTimeline2 as WorkflowTimeline,
   createContentManagementSuite
 };
 //# sourceMappingURL=index.mjs.map