import { D as Delta, P as ParserConfig, T as Transformer, b as TNode } from '../ast-types-U4BC1m-E.js';
export { c as Attributes, A as AttributorHandler, d as BlockAttributeHandler, e as BlockAttributeResolver, a as BlockDescriptor, B as BlockHandler, f as DeltaOp, K as KnownNodeType, M as MarkHandler, g as NodeOverrideContext, N as NodeOverrideHandler, R as RendererConfig, S as SimpleTagMark, i as isEmbedNode, h as isTextNode } from '../ast-types-U4BC1m-E.js';
export { B as BaseRenderer } from '../base-renderer-CKK0r7zD.js';
export { S as SimpleRenderer, a as SimpleRendererConfig } from '../simple-renderer-yivghYpg.js';

/**
 * Parse a Quill Delta into a raw AST tree of TNode objects.
 *
 * This is the pure-function equivalent of `new DeltaParser(delta, config).toAST()`.
 * Block attribute recognition is driven by the `ParserConfig`, keeping
 * the parser free of Quill-specific knowledge.
 *
 * Returns a raw AST — apply transformers separately via {@link applyTransformers}
 * or use {@link parseQuillDelta} for a batteries-included pipeline.
 *
 * @example
 * ```ts
 * import { parseDelta, applyTransformers } from 'quill-delta-renderer/core';
 * import { listGrouper, tableGrouper } from 'quill-delta-renderer/common';
 *
 * const raw = parseDelta(delta, { blockAttributes: DEFAULT_BLOCK_ATTRIBUTES });
 * const ast = applyTransformers(raw, [listGrouper, tableGrouper]);
 * ```
 */
declare function parseDelta(delta: Delta, config: ParserConfig): TNode;
/**
 * Parses a Quill Delta into a tree of TNode objects.
 *
 * Provides a fluent builder API for registering transformers.
 * For a simpler functional approach, use {@link parseDelta} directly.
 *
 * @example
 * ```ts
 * const ast = new DeltaParser(delta, { blockAttributes: DEFAULT_BLOCK_ATTRIBUTES })
 *   .use(listGrouper)
 *   .use(tableGrouper)
 *   .toAST();
 * ```
 */
declare class DeltaParser {
    private readonly delta;
    private readonly config;
    private readonly transformers;
    constructor(delta: Delta, config: ParserConfig);
    /**
     * Register a transformer (middleware) to be applied after initial parsing.
     * Transformers run in the order they are registered.
     */
    use(transformer: Transformer): this;
    /**
     * Parse the delta into a raw AST, then apply all registered transformers.
     */
    toAST(): TNode;
}

/**
 * Runs a sequence of transformers against an AST root node.
 * Each transformer receives the children array from the previous step.
 *
 * Returns a new root node with the transformed children.
 *
 * @example
 * ```ts
 * const finalAst = applyTransformers(rawAst, [listGrouper, tableGrouper]);
 * ```
 */
declare function applyTransformers(root: TNode, transformers: Transformer[]): TNode;
/**
 * Composes multiple transformers into a single transformer function.
 *
 * @example
 * ```ts
 * const combined = composeTransformers(listGrouper, tableGrouper);
 * const finalChildren = combined(rawChildren);
 * ```
 */
declare function composeTransformers(...transformers: Transformer[]): Transformer;

export { Delta, DeltaParser, ParserConfig, TNode, Transformer, applyTransformers, composeTransformers, parseDelta };