Types

Complete TypeScript type reference for DocsJS.

Core Types

DocumentNode

The base AST node type.

interface DocumentNode {
  type: string;
  children?: DocumentNode[];
  attributes?: Record<string, unknown>;
  content?: string;
  position?: Position;
}

Position

Source position information.

interface Position {
  start: { line: number; column: number; offset?: number };
  end: { line: number; column: number; offset?: number };
}

Configuration Types

EngineConfig

Engine configuration options.

interface EngineConfig {
  profile?: string;
  plugins?: PluginConfig[];
  security?: SecurityConfig;
  performance?: PerformanceConfig;
}

PluginConfig

Plugin configuration.

interface PluginConfig {
  name: string;
  version?: string;
  availableHooks: HookName[];
  permissions?: PluginPermissions;
  beforeParse?: HookFunction;
  afterParse?: HookFunction;
  beforeTransform?: HookFunction;
  afterTransform?: HookFunction;
  beforeRender?: HookFunction;
  afterRender?: HookFunction;
  beforeExport?: HookFunction;
  afterExport?: HookFunction;
}

type HookName =
  | "beforeParse"
  | "afterParse"
  | "beforeTransform"
  | "afterTransform"
  | "beforeRender"
  | "afterRender"
  | "beforeExport"
  | "afterExport";

type HookFunction = (context: PluginContext) => PluginContext | Promise<PluginContext>;

ProfileConfig

Profile configuration.

interface ProfileConfig {
  id: string;
  name: string;
  description?: string;
  parse?: ParseConfig;
  transform?: TransformConfig;
  render?: RenderConfig;
  security?: SecurityConfig;
  export?: ExportConfig;
}

ParseConfig

Parsing configuration.

interface ParseConfig {
  features?: {
    mathML?: boolean;
    tables?: boolean;
    images?: boolean;
    footnotes?: boolean;
    citations?: boolean;
    crossReferences?: boolean;
  };
  options?: {
    preserveStyles?: boolean;
    extractMetadata?: boolean;
  };
}

TransformConfig

Transformation configuration.

interface TransformConfig {
  preserveStructure?: boolean;
  extractMetadata?: boolean;
  customRules?: TransformRule[];
}

interface TransformRule {
  selector: string;
  action: "replace" | "remove" | "wrap" | "unwrap";
  value?: string;
}

RenderConfig

Rendering configuration.

interface RenderConfig {
  format?: "html" | "markdown" | "json";
  includeStyles?: boolean;
  mathRenderer?: "katex" | "mathjax" | "none";
  codeHighlighter?: "prism" | "highlight" | "none";
}

Security Types

SecurityConfig

Security configuration.

interface SecurityConfig {
  allowedDomains?: string[];
  sanitizerProfile?: "strict" | "balanced" | "fidelity-first";
  removeScripts?: boolean;
  removeExternalLinks?: boolean;
  maxFileSize?: number;
  allowedMimeTypes?: string[];
}

PluginPermissions

Plugin permission settings.

interface PluginPermissions {
  read?: string[];
  write?: string[];
  network?: boolean;
  compute?: ComputePermissions;
  ast?: ASTPermissions;
  export?: ExportPermissions;
  misc?: MiscPermissions;
}

interface ComputePermissions {
  maxMemoryMB?: number;
  maxCpuSecs?: number;
}

interface ASTPermissions {
  canModifySemantics?: boolean;
  canAccessOriginal?: boolean;
  canExportRawAst?: boolean;
}

interface ExportPermissions {
  canGenerateFiles?: boolean;
  canUpload?: boolean;
}

interface MiscPermissions {
  allowUnsafeCode?: boolean;
}

Context Types

PluginContext

Context passed to plugin hooks.

interface PluginContext {
  ast: DocumentNode;
  input: InputContext;
  output: OutputContext;
  pipeline: PipelineContext;
  utils: UtilityContext;
}

interface InputContext {
  source: string;
  format: string;
  metadata?: Record<string, unknown>;
}

interface OutputContext {
  content?: string;
  format: string;
  metadata?: Record<string, unknown>;
}

interface PipelineContext {
  state: PipelineState;
  config: EngineConfig;
  profile?: ProfileConfig;
}

interface PipelineState {
  intermediate: Record<string, unknown>;
  errors: Error[];
  warnings: string[];
}

interface UtilityContext {
  logger: Logger;
  cache: Cache;
}

Result Types

TransformResult

Result of document transformation.

interface TransformResult {
  output: string;
  diagnostics: Diagnostic[];
  metrics: PerformanceMetrics;
  metadata?: DocumentMetadata;
}

Diagnostic

Processing diagnostic information.

interface Diagnostic {
  type: "error" | "warning" | "info";
  message: string;
  location?: {
    line: number;
    column: number;
  };
  code?: string;
}

PerformanceMetrics

Performance measurement data.

interface PerformanceMetrics {
  parseTime: number;
  transformTime: number;
  renderTime: number;
  totalTime: number;
  memoryUsage?: number;
}

DocumentMetadata

Extracted document metadata.

interface DocumentMetadata {
  title?: string;
  author?: string;
  created?: Date;
  modified?: Date;
  wordCount?: number;
  pageCount?: number;
  language?: string;
}

Event Types

ChangeEventDetail

Detail for docsjs-change event.

interface ChangeEventDetail {
  htmlSnapshot: string;
  textContent: string;
  wordCount: number;
  charCount: number;
}

ErrorEventDetail

Detail for docsjs-error event.

interface ErrorEventDetail {
  error: Error;
  code?: string;
  recoverable: boolean;
}

LoadEventDetail

Detail for docsjs-load event.

interface LoadEventDetail {
  source: "html" | "docx" | "clipboard";
  size: number;
  processingTime: number;
}

Utility Types

Logger

Logging utility interface.

interface Logger {
  debug(message: string, ...args: unknown[]): void;
  info(message: string, ...args: unknown[]): void;
  warn(message: string, ...args: unknown[]): void;
  error(message: string, ...args: unknown[]): void;
}

Cache

Caching utility interface.

interface Cache {
  get<T>(key: string): T | undefined;
  set<T>(key: string, value: T, ttl?: number): void;
  has(key: string): boolean;
  delete(key: string): boolean;
  clear(): void;
}

Next Steps

• CoreEngine API - Engine reference
• Components API - Component reference
• Events API - Event handling