@azlib/cms 0.2.0

package/dist/index.d.mts

@@ -0,0 +1,851 @@
+//#region src/core/types.d.ts
+/**
+ * @azlib/cms - Universal Domain Types & Interfaces
+ */
+type ContentStatus = "draft" | "pending_review" | "scheduled" | "published" | "private" | "trash";
+type FieldType = "text" | "slug" | "richText" | "number" | "boolean" | "select" | "image" | "taxonomy" | "relationship" | "date" | "json" | "repeater";
+interface SelectOption {
+  readonly label: string;
+  readonly value: string | number;
+}
+interface FieldDefinition<TValue = any> {
+  readonly name: string;
+  readonly type: FieldType;
+  readonly label?: string;
+  readonly description?: string;
+  readonly required?: boolean;
+  readonly defaultValue?: TValue;
+  readonly unique?: boolean;
+  readonly options?: readonly (string | SelectOption)[];
+  readonly taxonomy?: string;
+  readonly targetCollection?: string;
+  readonly fromField?: string;
+  readonly fields?: readonly FieldDefinition[];
+  readonly min?: number;
+  readonly max?: number;
+  readonly pattern?: string;
+  readonly validate?: (value: any, data: Record<string, unknown>) => string | null | boolean;
+}
+interface CollectionConfig {
+  readonly slug: string;
+  readonly label: string;
+  readonly singularLabel?: string;
+  readonly description?: string;
+  readonly hierarchical?: boolean;
+  readonly timestamps?: boolean;
+  readonly revisions?: boolean;
+  readonly draftable?: boolean;
+  readonly fields: readonly FieldDefinition[];
+  readonly taxonomies?: readonly string[];
+  readonly defaultSort?: {
+    readonly field: string;
+    readonly direction: "asc" | "desc";
+  };
+}
+interface ContentItem<TData extends Record<string, unknown> = Record<string, unknown>> {
+  id: string;
+  collection: string;
+  slug: string;
+  status: ContentStatus;
+  title?: string;
+  parentId?: string | null;
+  authorId?: string | null;
+  publishedAt?: string | null;
+  scheduledAt?: string | null;
+  createdAt: string;
+  updatedAt: string;
+  version: number;
+  data: TData;
+  terms?: Record<string, string[]>;
+}
+interface ContentQueryOptions {
+  status?: ContentStatus | ContentStatus[];
+  authorId?: string;
+  parentId?: string | null;
+  termIds?: string[];
+  search?: string;
+  where?: Record<string, unknown>;
+  orderBy?: string;
+  orderDirection?: "asc" | "desc";
+  limit?: number;
+  offset?: number;
+  includeRevisions?: boolean;
+  includeTerms?: boolean;
+}
+interface PaginatedResult<T> {
+  items: T[];
+  total: number;
+  limit: number;
+  offset: number;
+  hasMore: boolean;
+}
+interface RevisionRecord {
+  id: string;
+  contentId: string;
+  collection: string;
+  version: number;
+  snapshot: ContentItem;
+  authorId?: string | null;
+  note?: string;
+  createdAt: string;
+}
+interface RevisionDiffField {
+  field: string;
+  oldValue: unknown;
+  newValue: unknown;
+}
+interface RevisionDiff {
+  contentId: string;
+  fromVersion: number;
+  toVersion: number;
+  changes: RevisionDiffField[];
+}
+interface TaxonomyConfig {
+  readonly slug: string;
+  readonly label: string;
+  readonly singularLabel?: string;
+  readonly hierarchical?: boolean;
+  readonly postTypes?: readonly string[];
+  readonly description?: string;
+}
+interface TermItem {
+  id: string;
+  taxonomy: string;
+  name: string;
+  slug: string;
+  description?: string;
+  parentId?: string | null;
+  count: number;
+  meta?: Record<string, unknown>;
+  createdAt: string;
+  updatedAt: string;
+}
+interface TermTreeItem extends TermItem {
+  children: TermTreeItem[];
+}
+interface MediaItem {
+  id: string;
+  filename: string;
+  originalName: string;
+  mimeType: string;
+  sizeBytes: number;
+  url: string;
+  path?: string;
+  width?: number;
+  height?: number;
+  altText?: string;
+  caption?: string;
+  authorId?: string | null;
+  variants?: Record<string, string>;
+  createdAt: string;
+  updatedAt: string;
+}
+interface OptionItem<T = unknown> {
+  key: string;
+  value: T;
+  autoload: boolean;
+  namespace?: string;
+  updatedAt: string;
+}
+type UserRole = "admin" | "editor" | "author" | "contributor" | "subscriber" | (string & {});
+type CMSCapability = "manage_options" | "manage_taxonomies" | "upload_files" | "delete_files" | "edit_posts" | "edit_others_posts" | "publish_posts" | "delete_posts" | "delete_others_posts" | "read_private_posts" | (string & {});
+interface CMSUser {
+  id: string;
+  username: string;
+  email: string;
+  displayName: string;
+  role: UserRole;
+  capabilities?: string[];
+  active?: boolean;
+}
+interface SiteConfig {
+  name: string;
+  description?: string;
+  url?: string;
+  logo?: string;
+  locale?: string;
+  timezone?: string;
+}
+interface CMSConfig {
+  site?: SiteConfig;
+  collections: readonly CollectionConfig[];
+  taxonomies?: readonly TaxonomyConfig[];
+  admin?: {
+    route?: string;
+    enableRegistration?: boolean;
+  };
+}
+//#endregion
+//#region src/core/config.d.ts
+/**
+ * Default standard collections provided when not explicitly specified.
+ */
+declare const DEFAULT_COLLECTIONS: CollectionConfig[];
+/**
+ * Type-safe configuration helper function for azlib.config.ts.
+ */
+declare function defineConfig(config: CMSConfig): CMSConfig;
+/**
+ * Normalize and merge user config with CMS defaults.
+ */
+declare function normalizeConfig(config: Partial<CMSConfig>): CMSConfig;
+//#endregion
+//#region src/core/hooks.d.ts
+/**
+ * @azlib/cms - WordPress-style Action and Filter Hook System
+ */
+type ActionCallback = (...args: unknown[]) => void | Promise<void>;
+type FilterCallback<T = unknown> = (value: T, ...args: unknown[]) => T | Promise<T>;
+type SyncFilterCallback<T = unknown> = (value: T, ...args: unknown[]) => T;
+interface HookEntry<TCallback> {
+  readonly callback: TCallback;
+  readonly priority: number;
+}
+declare class HooksManager {
+  private actions;
+  private filters;
+  /**
+   * Register an action callback.
+   * Lower priority numbers execute first (default: 10).
+   */
+  addAction(tag: string, callback: ActionCallback, priority?: number): this;
+  /**
+   * Execute all callbacks registered for the specified action asynchronously.
+   */
+  doAction(tag: string, ...args: unknown[]): Promise<void>;
+  /**
+   * Execute all callbacks registered for the specified action synchronously.
+   */
+  doActionSync(tag: string, ...args: unknown[]): void;
+  /**
+   * Register a filter callback.
+   * Filter callbacks receive a value and return the modified value.
+   */
+  addFilter<T = unknown>(tag: string, callback: FilterCallback<T>, priority?: number): this;
+  /**
+   * Apply all filters registered for the specified tag sequentially.
+   */
+  applyFilters<T = unknown>(tag: string, initialValue: T, ...args: unknown[]): Promise<T>;
+  /**
+   * Apply all filters registered for the specified tag synchronously.
+   */
+  applyFiltersSync<T = unknown>(tag: string, initialValue: T, ...args: unknown[]): T;
+  /**
+   * Remove a registered action callback.
+   */
+  removeAction(tag: string, callback: ActionCallback): boolean;
+  /**
+   * Remove a registered filter callback.
+   */
+  removeFilter<T = unknown>(tag: string, callback: FilterCallback<T>): boolean;
+  /**
+   * Check if any callbacks are registered for an action.
+   */
+  hasAction(tag: string): boolean;
+  /**
+   * Check if any callbacks are registered for a filter.
+   */
+  hasFilter(tag: string): boolean;
+  /**
+   * Remove all registered actions and filters.
+   */
+  removeAll(tag?: string): void;
+}
+declare const defaultHooks: HooksManager;
+//#endregion
+//#region src/storage/storage-contract.d.ts
+interface CMSStorageAdapter {
+  init(): Promise<void>;
+  close(): Promise<void>;
+  createContent<T extends Record<string, unknown>>(item: Omit<ContentItem<T>, "id" | "createdAt" | "updatedAt" | "version">): Promise<ContentItem<T>>;
+  getContent<T extends Record<string, unknown>>(collection: string, id: string): Promise<ContentItem<T> | null>;
+  getContentBySlug<T extends Record<string, unknown>>(collection: string, slug: string): Promise<ContentItem<T> | null>;
+  findContent<T extends Record<string, unknown>>(collection: string, options?: ContentQueryOptions): Promise<PaginatedResult<ContentItem<T>>>;
+  updateContent<T extends Record<string, unknown>>(collection: string, id: string, updates: Partial<Omit<ContentItem<T>, "id" | "collection" | "createdAt">>): Promise<ContentItem<T> | null>;
+  deleteContent(collection: string, id: string): Promise<boolean>;
+  countContent(collection: string, options?: ContentQueryOptions): Promise<number>;
+  createRevision(contentId: string, collection: string, version: number, snapshot: ContentItem, authorId?: string | null, note?: string): Promise<RevisionRecord>;
+  getRevisions(contentId: string): Promise<RevisionRecord[]>;
+  getRevision(revisionId: string): Promise<RevisionRecord | null>;
+  deleteRevisionsByContentId(contentId: string): Promise<number>;
+  createTerm(term: Omit<TermItem, "id" | "count" | "createdAt" | "updatedAt">): Promise<TermItem>;
+  getTermById(id: string): Promise<TermItem | null>;
+  getTermBySlug(taxonomy: string, slug: string): Promise<TermItem | null>;
+  getTerms(taxonomy: string, options?: {
+    parentId?: string | null;
+  }): Promise<TermItem[]>;
+  updateTerm(id: string, updates: Partial<Omit<TermItem, "id" | "taxonomy" | "createdAt">>): Promise<TermItem | null>;
+  deleteTerm(id: string): Promise<boolean>;
+  assignTermsToContent(contentId: string, termIds: string[]): Promise<void>;
+  getContentTerms(contentId: string, taxonomy?: string): Promise<TermItem[]>;
+  removeTermsFromContent(contentId: string, termIds: string[]): Promise<void>;
+  createMedia(item: Omit<MediaItem, "id" | "createdAt" | "updatedAt">): Promise<MediaItem>;
+  getMedia(id: string): Promise<MediaItem | null>;
+  findMedia(options?: {
+    search?: string;
+    mimeType?: string;
+    authorId?: string;
+    limit?: number;
+    offset?: number;
+  }): Promise<PaginatedResult<MediaItem>>;
+  updateMedia(id: string, updates: Partial<Omit<MediaItem, "id" | "createdAt">>): Promise<MediaItem | null>;
+  deleteMedia(id: string): Promise<boolean>;
+  getOption<T = unknown>(key: string): Promise<OptionItem<T> | null>;
+  setOption<T = unknown>(item: OptionItem<T>): Promise<void>;
+  deleteOption(key: string): Promise<boolean>;
+  getOptions(namespace?: string): Promise<OptionItem[]>;
+}
+//#endregion
+//#region src/core/options.d.ts
+declare class OptionsManager {
+  private storage;
+  private hooks?;
+  constructor(storage: CMSStorageAdapter, hooks?: HooksManager | undefined);
+  /**
+   * Retrieve an option by key. Returns defaultValue if option does not exist.
+   */
+  get<T = unknown>(key: string, defaultValue?: T): Promise<T | undefined>;
+  /**
+   * Set or update an option value.
+   */
+  set<T = unknown>(key: string, value: T, options?: {
+    autoload?: boolean;
+    namespace?: string;
+  }): Promise<OptionItem<T>>;
+  /**
+   * Delete an option by key.
+   */
+  delete(key: string): Promise<boolean>;
+  /**
+   * Check if an option exists.
+   */
+  has(key: string): Promise<boolean>;
+  /**
+   * Get all options, optionally filtered by namespace.
+   */
+  getAll(namespace?: string): Promise<Record<string, unknown>>;
+}
+//#endregion
+//#region src/content/lifecycle.d.ts
+declare const VALID_STATUS_TRANSITIONS: Record<ContentStatus, readonly ContentStatus[]>;
+declare class ContentLifecycle {
+  private storage;
+  private hooks?;
+  constructor(storage: CMSStorageAdapter, hooks?: HooksManager | undefined);
+  /**
+   * Validate whether a status transition is permitted.
+   */
+  canTransition(currentStatus: ContentStatus, nextStatus: ContentStatus): boolean;
+  /**
+   * Process all scheduled content across a collection (or all collections) and publish mature items.
+   */
+  processScheduledContent(collection: string, now?: Date): Promise<ContentItem[]>;
+}
+//#endregion
+//#region src/content/revisions.d.ts
+declare class RevisionManager {
+  private storage;
+  private hooks?;
+  constructor(storage: CMSStorageAdapter, hooks?: HooksManager | undefined);
+  /**
+   * Save a revision snapshot for a content item.
+   */
+  createRevision(item: ContentItem, authorId?: string | null, note?: string): Promise<RevisionRecord>;
+  /**
+   * Get all revisions for a content item.
+   */
+  getRevisions(contentId: string): Promise<RevisionRecord[]>;
+  /**
+   * Get a specific revision by ID.
+   */
+  getRevision(revisionId: string): Promise<RevisionRecord | null>;
+  /**
+   * Compute differences between two content snapshots.
+   */
+  computeDiff(oldSnapshot: ContentItem, newSnapshot: ContentItem): RevisionDiff;
+  /**
+   * Restore a content item to a previous revision snapshot.
+   */
+  restoreRevision(collection: string, revisionId: string, authorId?: string): Promise<ContentItem | null>;
+}
+//#endregion
+//#region src/taxonomy/taxonomy.d.ts
+declare class TaxonomyManager {
+  private storage;
+  private hooks?;
+  private registeredTaxonomies;
+  constructor(storage: CMSStorageAdapter, hooks?: HooksManager | undefined);
+  /**
+   * Register a taxonomy definition.
+   */
+  registerTaxonomy(config: TaxonomyConfig): void;
+  /**
+   * Get all registered taxonomies.
+   */
+  getTaxonomies(): TaxonomyConfig[];
+  /**
+   * Get a single taxonomy configuration by slug.
+   */
+  getTaxonomy(slug: string): TaxonomyConfig | undefined;
+  /**
+   * Create a new term (e.g. category or tag).
+   */
+  createTerm(taxonomy: string, data: {
+    name: string;
+    slug?: string;
+    description?: string;
+    parentId?: string | null;
+    meta?: Record<string, unknown>;
+  }): Promise<TermItem>;
+  /**
+   * Get a term by ID.
+   */
+  getTermById(id: string): Promise<TermItem | null>;
+  /**
+   * Get a term by slug within a taxonomy.
+   */
+  getTermBySlug(taxonomy: string, slug: string): Promise<TermItem | null>;
+  /**
+   * Get terms for a taxonomy.
+   */
+  getTerms(taxonomy: string, options?: {
+    parentId?: string | null;
+  }): Promise<TermItem[]>;
+  /**
+   * Build a hierarchical tree of terms for a taxonomy (parent -> children).
+   */
+  getTermTree(taxonomy: string): Promise<TermTreeItem[]>;
+  /**
+   * Update a term.
+   */
+  updateTerm(id: string, updates: {
+    name?: string;
+    slug?: string;
+    description?: string;
+    parentId?: string | null;
+    meta?: Record<string, unknown>;
+  }): Promise<TermItem | null>;
+  /**
+   * Delete a term.
+   */
+  deleteTerm(id: string): Promise<boolean>;
+  /**
+   * Assign term IDs to a content item.
+   */
+  assignTerms(contentId: string, termIds: string[]): Promise<void>;
+  /**
+   * Get all terms assigned to a content item.
+   */
+  getContentTerms(contentId: string, taxonomy?: string): Promise<TermItem[]>;
+  /**
+   * Remove terms from a content item.
+   */
+  removeTerms(contentId: string, termIds: string[]): Promise<void>;
+}
+//#endregion
+//#region src/media/media-manager.d.ts
+interface MediaUploadInput {
+  filename: string;
+  mimeType: string;
+  sizeBytes: number;
+  url?: string;
+  width?: number;
+  height?: number;
+  altText?: string;
+  caption?: string;
+  variants?: Record<string, string>;
+}
+declare class MediaManager {
+  private storage;
+  private hooks?;
+  private publicBaseUrl;
+  private allowedMimePrefixes;
+  constructor(storage: CMSStorageAdapter, hooks?: HooksManager | undefined, publicBaseUrl?: string);
+  /**
+   * Upload / register a new media item.
+   */
+  upload(input: MediaUploadInput, authorId?: string | null): Promise<MediaItem>;
+  /**
+   * Get a media item by ID.
+   */
+  get(id: string): Promise<MediaItem | null>;
+  /**
+   * Find media items.
+   */
+  find(options?: {
+    search?: string;
+    mimeType?: string;
+    authorId?: string;
+    limit?: number;
+    offset?: number;
+  }): Promise<PaginatedResult<MediaItem>>;
+  /**
+   * Update media metadata (alt text, caption, dimensions).
+   */
+  updateMetadata(id: string, updates: {
+    altText?: string;
+    caption?: string;
+    width?: number;
+    height?: number;
+  }): Promise<MediaItem | null>;
+  /**
+   * Delete a media item.
+   */
+  delete(id: string): Promise<boolean>;
+}
+//#endregion
+//#region src/auth/rbac.d.ts
+declare const DEFAULT_ROLE_CAPABILITIES: Record<string, string[]>;
+declare class RBACManager {
+  private roleCapabilities;
+  constructor();
+  /**
+   * Register a custom role with its capabilities.
+   */
+  registerRole(role: string, capabilities: string[]): void;
+  /**
+   * Add a capability to an existing role.
+   */
+  addCapabilityToRole(role: string, capability: string): void;
+  /**
+   * Get all capabilities assigned to a role.
+   */
+  getRoleCapabilities(role: string): string[];
+  /**
+   * Check if a user possesses a specific capability.
+   * If a target content item context is provided, checks object ownership rules.
+   */
+  can(user: CMSUser | null | undefined, capability: CMSCapability, context?: {
+    contentItem?: ContentItem;
+  }): boolean;
+}
+//#endregion
+//#region src/core/engine.d.ts
+interface CreateContentInput {
+  title?: string;
+  slug?: string;
+  status?: ContentItem["status"];
+  parentId?: string | null;
+  scheduledAt?: string | null;
+  data?: Record<string, unknown>;
+  terms?: Record<string, string[]>;
+}
+interface UpdateContentInput {
+  title?: string;
+  slug?: string;
+  status?: ContentItem["status"];
+  parentId?: string | null;
+  scheduledAt?: string | null;
+  data?: Record<string, unknown>;
+  terms?: Record<string, string[]>;
+}
+interface CollectionService<TData extends Record<string, unknown> = Record<string, unknown>> {
+  readonly config: CollectionConfig;
+  create(input: CreateContentInput, authorId?: string | null): Promise<ContentItem<TData>>;
+  findById(id: string): Promise<ContentItem<TData> | null>;
+  findBySlug(slug: string): Promise<ContentItem<TData> | null>;
+  find(options?: ContentQueryOptions): Promise<PaginatedResult<ContentItem<TData>>>;
+  update(id: string, input: UpdateContentInput, authorId?: string | null, revisionNote?: string): Promise<ContentItem<TData> | null>;
+  delete(id: string): Promise<boolean>;
+  publish(id: string, authorId?: string | null): Promise<ContentItem<TData> | null>;
+  schedule(id: string, scheduledAt: Date | string, authorId?: string | null): Promise<ContentItem<TData> | null>;
+  getRevisions(id: string): Promise<RevisionRecord[]>;
+  getRevision(revisionId: string): Promise<RevisionRecord | null>;
+  restoreRevision(id: string, revisionId: string, authorId?: string): Promise<ContentItem<TData> | null>;
+  getDiff(oldVersion: ContentItem<TData>, newVersion: ContentItem<TData>): RevisionDiff;
+}
+declare class CMSEngine {
+  readonly config: CMSConfig;
+  readonly hooks: HooksManager;
+  readonly storage: CMSStorageAdapter;
+  readonly options: OptionsManager;
+  readonly taxonomies: TaxonomyManager;
+  readonly media: MediaManager;
+  readonly rbac: RBACManager;
+  readonly revisions: RevisionManager;
+  readonly lifecycle: ContentLifecycle;
+  private collections;
+  constructor(config?: Partial<CMSConfig>, storage?: CMSStorageAdapter, hooks?: HooksManager);
+  /**
+   * Initialize storage and trigger bootstrap hooks.
+   */
+  init(): Promise<void>;
+  /**
+   * Close storage connections.
+   */
+  close(): Promise<void>;
+  /**
+   * Get all registered collection configurations.
+   */
+  getCollections(): CollectionConfig[];
+  /**
+   * Get a single collection configuration.
+   */
+  getCollectionConfig(slug: string): CollectionConfig | undefined;
+  /**
+   * Access high-level CRUD service for a collection.
+   */
+  collection<TData extends Record<string, unknown> = Record<string, unknown>>(slug: string): CollectionService<TData>;
+  /**
+   * Run scheduled content publisher for all registered collections.
+   */
+  processScheduledContent(now?: Date): Promise<ContentItem[]>;
+}
+/**
+ * Factory helper to create a configured CMSEngine instance.
+ */
+declare function createCMSEngine(config?: Partial<CMSConfig>, storage?: CMSStorageAdapter, hooks?: HooksManager): CMSEngine;
+//#endregion
+//#region src/content/schema.d.ts
+interface TextFieldOptions {
+  name: string;
+  label?: string;
+  description?: string;
+  required?: boolean;
+  defaultValue?: string;
+  unique?: boolean;
+  min?: number;
+  max?: number;
+  pattern?: string;
+  validate?: (value: string, data: Record<string, unknown>) => string | null | boolean;
+}
+interface SlugFieldOptions {
+  name?: string;
+  label?: string;
+  from?: string;
+  required?: boolean;
+  unique?: boolean;
+}
+interface RichTextFieldOptions {
+  name: string;
+  label?: string;
+  description?: string;
+  required?: boolean;
+  defaultValue?: string;
+}
+interface NumberFieldOptions {
+  name: string;
+  label?: string;
+  description?: string;
+  required?: boolean;
+  defaultValue?: number;
+  min?: number;
+  max?: number;
+}
+interface BooleanFieldOptions {
+  name: string;
+  label?: string;
+  description?: string;
+  defaultValue?: boolean;
+}
+interface SelectFieldOptions {
+  name: string;
+  label?: string;
+  description?: string;
+  required?: boolean;
+  options: readonly (string | SelectOption)[];
+  defaultValue?: string | number;
+}
+interface ImageFieldOptions {
+  name: string;
+  label?: string;
+  description?: string;
+  required?: boolean;
+}
+interface TaxonomyFieldOptions {
+  name: string;
+  taxonomy: string;
+  label?: string;
+  required?: boolean;
+}
+interface RelationshipFieldOptions {
+  name: string;
+  targetCollection: string;
+  label?: string;
+  description?: string;
+  required?: boolean;
+}
+interface DateFieldOptions {
+  name: string;
+  label?: string;
+  description?: string;
+  required?: boolean;
+  defaultValue?: string;
+}
+interface JsonFieldOptions {
+  name: string;
+  label?: string;
+  description?: string;
+  required?: boolean;
+  defaultValue?: unknown;
+}
+interface RepeaterFieldOptions {
+  name: string;
+  label?: string;
+  description?: string;
+  fields: readonly FieldDefinition[];
+  min?: number;
+  max?: number;
+}
+declare const fields: {
+  text(options: TextFieldOptions): FieldDefinition<string>;
+  slug(options?: SlugFieldOptions): FieldDefinition<string>;
+  richText(options: RichTextFieldOptions): FieldDefinition<string>;
+  number(options: NumberFieldOptions): FieldDefinition<number>;
+  boolean(options: BooleanFieldOptions): FieldDefinition<boolean>;
+  select(options: SelectFieldOptions): FieldDefinition<string | number>;
+  image(options: ImageFieldOptions): FieldDefinition<string>;
+  taxonomy(options: TaxonomyFieldOptions): FieldDefinition<string | string[]>;
+  relationship(options: RelationshipFieldOptions): FieldDefinition<string | string[]>;
+  date(options: DateFieldOptions): FieldDefinition<string>;
+  json(options: JsonFieldOptions): FieldDefinition<unknown>;
+  repeater(options: RepeaterFieldOptions): FieldDefinition<Record<string, unknown>[]>;
+};
+interface CollectionOptions {
+  slug: string;
+  label: string;
+  singularLabel?: string;
+  description?: string;
+  hierarchical?: boolean;
+  timestamps?: boolean;
+  revisions?: boolean;
+  draftable?: boolean;
+  fields: readonly FieldDefinition[];
+  taxonomies?: readonly string[];
+  defaultSort?: {
+    field: string;
+    direction: "asc" | "desc";
+  };
+}
+/**
+ * Define a CMS Collection with field schemas and lifecycle rules.
+ */
+declare function collection(options: CollectionOptions): CollectionConfig;
+/**
+ * Validate and apply default values to input data for a collection.
+ */
+declare function validateAndNormalizeData(fieldsList: readonly FieldDefinition[], inputData: Record<string, unknown>): {
+  data: Record<string, unknown>;
+  errors: Record<string, string>;
+};
+//#endregion
+//#region src/content/slug.d.ts
+/**
+ * @azlib/cms - Slug generation and normalization utility
+ */
+/**
+ * Generate a clean, URL-safe slug from any input string.
+ */
+declare function slugify(input: string): string;
+/**
+ * Create a unique slug given an existing set of slugs or a check function.
+ */
+declare function resolveUniqueSlug(baseSlug: string, isSlugTaken: (slug: string) => Promise<boolean> | boolean, currentId?: string): Promise<string>;
+//#endregion
+//#region src/storage/memory-adapter.d.ts
+declare class MemoryStorageAdapter implements CMSStorageAdapter {
+  private content;
+  private revisions;
+  private terms;
+  private contentTerms;
+  private media;
+  private options;
+  init(): Promise<void>;
+  close(): Promise<void>;
+  createContent<T extends Record<string, unknown>>(item: Omit<ContentItem<T>, "id" | "createdAt" | "updatedAt" | "version">): Promise<ContentItem<T>>;
+  getContent<T extends Record<string, unknown>>(collection: string, id: string): Promise<ContentItem<T> | null>;
+  getContentBySlug<T extends Record<string, unknown>>(collection: string, slug: string): Promise<ContentItem<T> | null>;
+  findContent<T extends Record<string, unknown>>(collection: string, options?: ContentQueryOptions): Promise<PaginatedResult<ContentItem<T>>>;
+  updateContent<T extends Record<string, unknown>>(collection: string, id: string, updates: Partial<Omit<ContentItem<T>, "id" | "collection" | "createdAt">>): Promise<ContentItem<T> | null>;
+  deleteContent(collection: string, id: string): Promise<boolean>;
+  countContent(collection: string, options?: ContentQueryOptions): Promise<number>;
+  createRevision(contentId: string, collection: string, version: number, snapshot: ContentItem, authorId?: string | null, note?: string): Promise<RevisionRecord>;
+  getRevisions(contentId: string): Promise<RevisionRecord[]>;
+  getRevision(revisionId: string): Promise<RevisionRecord | null>;
+  deleteRevisionsByContentId(contentId: string): Promise<number>;
+  createTerm(term: Omit<TermItem, "id" | "count" | "createdAt" | "updatedAt">): Promise<TermItem>;
+  getTermById(id: string): Promise<TermItem | null>;
+  getTermBySlug(taxonomy: string, slug: string): Promise<TermItem | null>;
+  getTerms(taxonomy: string, options?: {
+    parentId?: string | null;
+  }): Promise<TermItem[]>;
+  updateTerm(id: string, updates: Partial<Omit<TermItem, "id" | "taxonomy" | "createdAt">>): Promise<TermItem | null>;
+  deleteTerm(id: string): Promise<boolean>;
+  assignTermsToContent(contentId: string, termIds: string[]): Promise<void>;
+  getContentTerms(contentId: string, taxonomy?: string): Promise<TermItem[]>;
+  removeTermsFromContent(contentId: string, termIds: string[]): Promise<void>;
+  private recalculateTermCounts;
+  createMedia(item: Omit<MediaItem, "id" | "createdAt" | "updatedAt">): Promise<MediaItem>;
+  getMedia(id: string): Promise<MediaItem | null>;
+  findMedia(options?: {
+    search?: string;
+    mimeType?: string;
+    authorId?: string;
+    limit?: number;
+    offset?: number;
+  }): Promise<PaginatedResult<MediaItem>>;
+  updateMedia(id: string, updates: Partial<Omit<MediaItem, "id" | "createdAt">>): Promise<MediaItem | null>;
+  deleteMedia(id: string): Promise<boolean>;
+  getOption<T = unknown>(key: string): Promise<OptionItem<T> | null>;
+  setOption<T = unknown>(item: OptionItem<T>): Promise<void>;
+  deleteOption(key: string): Promise<boolean>;
+  getOptions(namespace?: string): Promise<OptionItem[]>;
+}
+//#endregion
+//#region src/api/router.d.ts
+declare class CMSRouter {
+  private engine;
+  constructor(engine: CMSEngine);
+  /**
+   * Universal Web Standards request handler.
+   */
+  handle(request: Request): Promise<Response>;
+  private handleContent;
+  private handleTaxonomies;
+  private handleMedia;
+  private handleOptions;
+}
+declare function createCMSRouter(engine: CMSEngine): CMSRouter;
+//#endregion
+//#region src/client/cms-client.d.ts
+interface CMSClientOptions {
+  engine?: CMSEngine;
+  baseUrl?: string;
+  fetch?: typeof globalThis.fetch;
+  headers?: Record<string, string>;
+}
+interface ClientCollectionApi<TData extends Record<string, unknown> = Record<string, unknown>> {
+  find(options?: ContentQueryOptions): Promise<PaginatedResult<ContentItem<TData>>>;
+  findById(id: string): Promise<ContentItem<TData> | null>;
+  findBySlug(slug: string): Promise<ContentItem<TData> | null>;
+  create(data: Record<string, unknown>): Promise<ContentItem<TData>>;
+  update(id: string, data: Record<string, unknown>): Promise<ContentItem<TData> | null>;
+  delete(id: string): Promise<boolean>;
+}
+declare class CMSClient {
+  private engine?;
+  private baseUrl?;
+  private fetchFn;
+  private headers;
+  constructor(options: CMSClientOptions);
+  collection<TData extends Record<string, unknown> = Record<string, unknown>>(slug: string): ClientCollectionApi<TData>;
+  readonly taxonomies: {
+    getTerms: (taxonomy: string) => Promise<TermItem[]>;
+    getTree: (taxonomy: string) => Promise<TermTreeItem[]>;
+  };
+  readonly media: {
+    find: (options?: {
+      search?: string;
+      limit?: number;
+    }) => Promise<PaginatedResult<MediaItem>>;
+    get: (id: string) => Promise<MediaItem | null>;
+  };
+  readonly options: {
+    get: <T = unknown>(key: string, defaultValue?: T) => Promise<T | undefined>;
+  };
+  private request;
+}
+declare function createCmsClient(options: CMSClientOptions): CMSClient;
+//#endregion
+export { type ActionCallback, type BooleanFieldOptions, CMSCapability, CMSClient, type CMSClientOptions, CMSConfig, CMSEngine, CMSRouter, type CMSStorageAdapter, CMSUser, type ClientCollectionApi, CollectionConfig, type CollectionOptions, type CollectionService, ContentItem, ContentLifecycle, ContentQueryOptions, ContentStatus, type CreateContentInput, DEFAULT_COLLECTIONS, DEFAULT_ROLE_CAPABILITIES, type DateFieldOptions, FieldDefinition, FieldType, type FilterCallback, type HookEntry, HooksManager, type ImageFieldOptions, type JsonFieldOptions, MediaItem, MediaManager, type MediaUploadInput, MemoryStorageAdapter, type NumberFieldOptions, OptionItem, OptionsManager, PaginatedResult, RBACManager, type RelationshipFieldOptions, type RepeaterFieldOptions, RevisionDiff, RevisionDiffField, RevisionManager, RevisionRecord, type RichTextFieldOptions, type SelectFieldOptions, SelectOption, SiteConfig, type SlugFieldOptions, type SyncFilterCallback, TaxonomyConfig, type TaxonomyFieldOptions, TaxonomyManager, TermItem, TermTreeItem, type TextFieldOptions, type UpdateContentInput, UserRole, VALID_STATUS_TRANSITIONS, collection, createCMSEngine, createCMSRouter, createCmsClient, defaultHooks, defineConfig, fields, normalizeConfig, resolveUniqueSlug, slugify, validateAndNormalizeData };
+//# sourceMappingURL=index.d.mts.map