import Transformer from "./transformer.js";
import { Attributes, Document, ElementInterface, FastTraverseArg, HasIndent, NameIds, NodeInterface, QuoteattrCallback, ReporterInterface, Systemmessage, TextElementInterface, TraverseArgs, Visitor, SubstitutionNames, SubstitutionDefs, RefNames, LoggerType } from "./types.js";
import { Settings } from "./settings.js";
import { whitespaceNormalizeName } from "./nodeUtils.js";
declare function _addNodeClassNames(names: string[], o: any): void;
declare const SkipChildren: {
    new (): {};
};
declare const StopTraversal: {
    new (): {};
};
declare class SkipNode extends Error {
}
declare const SkipDeparture: {
    new (): {};
};
declare const SkipSiblings: {
    new (): {};
};
declare const NodeFound: {
    new (): {};
};
/**
 *  "Visitor" pattern [GoF95]_ abstract superclass implementation for
 *  document tree traversals.
 *
 *  Each node class has corresponding methods, doing nothing by
 *  default; override individual methods for specific and useful
 *  behaviour.  The `dispatch_visit()` method is called by
 *  `Node.walk()` upon entering a node.  `Node.walkabout()` also calls
 *  the `dispatch_departure()` method before exiting a node.
 *
 *  The dispatch methods call "``visit_`` + node class name" or
 *  "``depart_`` + node class name", resp.
 *
 *  This is a base class for visitors whose ``visit_...`` & ``depart_...``
 *  methods should be implemented for *all* node types encountered (such as
 *  for `docutils.writers.Writer` subclasses).  Unimplemented methods will
 *  raise exceptions.
 *
 *  For sparse traversals, where only certain node types are of interest,
 *  subclass `SparseNodeVisitor` instead.  When (mostly or entirely) uniform
 *  processing is desired, subclass `GenericNodeVisitor`.
 *
 *  .. [GoF95] Gamma, Helm, Johnson, Vlissides. *Design Patterns: Elements of
 *     Reusable Object-Oriented Software*. Addison-Wesley, Reading, MA, USA,
 *     1995.
 */
declare class NodeVisitor {
    document: Document;
    optional: string[];
    protected strictVisitor: boolean | undefined | null;
    [name: string]: any;
    /**
   * Create a NodeVisitor.
   * @param {nodes.document} document - document to visit
   */
    constructor(document: Document);
    /**
   * Call this."``visit_`` + node class name" with `node` as
   * parameter.  If the ``visit_...`` method does not exist, call
   * this.unknown_visit.
   */
    dispatchVisit(node: NodeInterface): {} | undefined | void;
    dispatchDeparture(node: NodeInterface): {} | undefined | void;
    /**
   * Called when entering unknown `Node` types.
   *
   * Raise an exception unless overridden.
   */
    unknownVisit(node: NodeInterface): never | void;
    /**
   * Called before exiting unknown `Node` types.
   *
   * Raise exception unless overridden.
   */
    unknownDeparture(node: NodeInterface): never | void;
}
/**
 * Base class for sparse traversals, where only certain node types are of
 * interest.  When ``visit_...`` & ``depart_...`` methods should be
 * implemented for *all* node types (such as for `docutils.writers.Writer`
 * subclasses), subclass `NodeVisitor` instead.
 */
declare class SparseNodeVisitor extends NodeVisitor {
}
/**
 *  Generic "Visitor" abstract superclass, for simple traversals.
 *
 *  Unless overridden, each ``visit_...`` method calls `default_visit()`, and
 *  each ``depart_...`` method (when using `Node.walkabout()`) calls
 *  `default_departure()`. `default_visit()` (and `default_departure()`) must
 *  be overridden in subclasses.
 *
 *  Define fully generic visitors by overriding `default_visit()` (and
 *  `default_departure()`) only. Define semi-generic visitors by overriding
 *  individual ``visit_...()`` (and ``depart_...()``) methods also.
 *
 *  `NodeVisitor.unknown_visit()` (`NodeVisitor.unknown_departure()`) should
 *  be overridden for default behavior.
 */
declare class GenericNodeVisitor extends NodeVisitor {
    static nodeClassNames: never[];
    constructor(document: Document);
    default_visit(node: NodeInterface): void;
    default_departure(node: NodeInterface): void;
}
declare class Resolvable {
}
declare class Root {
}
declare class Titular {
}
/**
 * Category of Node which may occur before Bibliographic Nodes.
 */
declare class PreBibliographic {
}
declare class Bibliographic {
}
declare class Decorative extends PreBibliographic {
}
declare class Structural {
}
declare class Body {
}
declare class General extends Body {
}
/** List-like elements. */
declare class Sequential extends Body {
}
declare class Admonition extends Body {
}
/** Special internal body elements.  */
declare class Special extends Body {
}
/** Internal elements that don't appear in output. */
declare class Invisible extends PreBibliographic {
}
declare class Part {
}
declare class Inline {
}
declare class Referential extends Resolvable {
}
declare class Targetable extends Resolvable {
}
/** Contains a `label` as its first element. */
declare class Labeled {
}
/**
 * Node class.
 *
 * The base class for all docutils nodes.
 */
declare abstract class Node implements NodeInterface {
    removeChild(index: number): void;
    append(item: NodeInterface): void;
    getChild(index: number): NodeInterface;
    hasChildren(): boolean;
    getNumChildren(): number;
    clearChildren(): void;
    getChildren(): NodeInterface[];
    protected get children(): NodeInterface[];
    protected set children(value: NodeInterface[]);
    isSetup: boolean;
    /**
   * List attributes which are defined for every Element-derived class
   * instance and can be safely transferred to a different node.
   */
    basicAttributes: string[];
    /**
   * List attributes, automatically initialized to empty lists for
   * all nodes.
   */
    listAttributes: string[];
    /** List attributes that are known to the Element base class. */
    knownAttributes: string[];
    childTextSeparator: string;
    abstract emptytag(): string;
    referenced: boolean;
    names: string[];
    currentSource: string;
    currentLine: number;
    rawsource: string;
    tagname: string;
    get parent(): ElementInterface;
    _parent?: NodeInterface;
    document?: Document;
    source: string | undefined;
    line: number | undefined;
    classTypes: any[];
    private _children;
    attributes: Attributes;
    /**
   * Create a node
   */
    constructor();
    _init(): void;
    /**
   Return the first node in the iterable returned by traverse(),
   or None if the iterable is empty.

   Parameter list is the same as of traverse.  Note that
   include_self defaults to 0, though.
   */
    nextNode(args: TraverseArgs): NodeInterface | undefined;
    hasClassType(classType: any): boolean;
    isInline(): boolean;
    isAdmonition(): boolean;
    asDOM(dom: {}): {};
    abstract pformat(indent?: string, level?: number): string;
    abstract astext(): string;
    abstract copy(): NodeInterface;
    abstract deepcopy(): NodeInterface;
    abstract _domNode(domroot: globalThis.Document): {};
    setupChild(child: NodeInterface): void;
    /**
   * Traverse a tree of `Node` objects, calling the
   * `dispatch_visit()` method of `visitor` when entering each
   * node.  (The `walkabout()` method is similar, except it also
   * calls the `dispatch_departure()` method before exiting each
   * node.)
   *
   * This tree traversal supports limited in-place tree
   * modifications.  Replacing one node with one or more nodes is
   * OK, as is removing an element.  However, if the node removed
   * or replaced occurs after the current node, the old node will
   * still be traversed, and any new nodes will not.
   *
   * Within ``visit`` methods (and ``depart`` methods for
   * `walkabout()`), `TreePruningException` subclasses may be raised
   * (`SkipChildren`, `SkipSiblings`, `SkipNode`, `SkipDeparture`).
   *
   * Parameter `visitor`: A `NodeVisitor` object, containing a
   * ``visit`` implementation for each `Node` subclass encountered.
   *
   * Return true if we should stop the traversal.
   */
    walk(visitor: Visitor): boolean;
    walkabout(visitor: Visitor): boolean;
    _fastTraverse(cls: FastTraverseArg): NodeInterface[];
    _allTraverse(): NodeInterface[];
    traverse(args: TraverseArgs): NodeInterface[];
    add(iNodes: NodeInterface[] | NodeInterface): void;
    endtag(): string;
    starttag(quoteattr?: QuoteattrCallback): string;
    addBackref(prbid: {}): void;
    updateBasicAtts(dict_: Attributes): void;
    appendAttrList(attr: string, values: (string | {})[]): void;
    replaceAttr(attr: string, value: (string | {})[] | string | {}, force?: boolean): void;
    copyAttrConsistent(attr: string, value: (string | {}), replace?: boolean): void;
    updateAllAtts(dict_: Attributes, updateFun?: (attr: string, value: (string | {}), replace?: boolean) => void, replace?: boolean, andSource?: boolean): void;
    /**
   Updates all attributes from node or dictionary `dict_`.

   Appends the basic attributes ('ids', 'names', 'classes',
   'dupnames', but not 'source') and then, for all other attributes in
   dict_, updates the same attribute in self.  When attributes with the
   same identifier appear in both self and dict_ whose values aren't each
   lists and replace is True, the values in self are replaced with the
   values in dict_; if the values from self and dict_ for the given
   identifier are both of list type, then the two lists are concatenated
   and the result stored in self; otherwise, the values in self are
   preserved.  When and_source is True, the 'source' attribute is
   included in the copy.

   NOTE: When replace is False, and self contains a 'source' attribute,
   'source' is not replaced even when dict_ has a 'source'
   attribute, though it may still be merged into a list depending
   on the value of update_fun.
   */
    updateAllAttsConcatenating(dict_: Attributes, replace?: boolean, andSource?: boolean): void;
    /**
   Returns True if and only if the given attribute is NOT one of the
   basic list attributes defined for all Elements.
   */
    isNotListAttribute(attr: string): boolean;
    /**
   Returns True if and only if the given attribute is NOT recognized by
   this class.
   */
    isNotKnownAttribute(attr: string): boolean;
    copyAttrConcatenate(attr: string, value: string | string[], replace?: boolean): void;
    getCustomAttr(attrName: string): undefined;
}
declare class Element extends Node implements ElementInterface {
    nodeName: any;
    /**
   * A list of class-specific attributes that should not be copied with the
   * standard attributes when replacing a node.
   *
   * NOTE: Derived classes should override this value to prevent any of its
   * attributes being copied by adding to the value in its parent class.
   */
    localAttributes: string[];
    /**
   * The element generic identifier. If None, it is set as an instance
   * attribute to the name of the class.
   */
    tagname: string;
    attributes: Attributes;
    /**
   * Create element.
   * @classdesc Abstracts a docutils Element.
   * @extends module:nodes~Node
   */
    constructor(rawsource?: string, children?: NodeInterface[], attributes?: Attributes);
    _init(): void;
    _domNode(domroot: globalThis.Document): {};
    emptytag(): string;
    astext(): string;
    extend(...items: any[]): void;
    append(item: NodeInterface): void;
    add(item: NodeInterface[] | NodeInterface): void;
    setupChild(child: NodeInterface): void;
    starttag(quoteAttr?: QuoteattrCallback): string;
    endtag(): string;
    attlist(): Attributes;
    nonDefaultAttributes(): Attributes;
    isNotDefault(key: string): boolean;
    firstChildNotMatchingClass(childClass: any | any[], start?: number, end?: number): number | undefined;
    pformat(indent?: string, level?: number): string;
    copy(): NodeInterface;
    deepcopy(): NodeInterface;
    /** Note that this Element has been referenced by its name
   `name` or id `id`. */
    noteReferencedBy(name: string, id: string): void;
}
declare class header extends Element {
    constructor(rawsource?: string, children?: NodeInterface[], attributes?: Attributes);
}
declare class footer extends Element {
    constructor(rawsource?: string, children?: NodeInterface[], attributes?: Attributes);
}
declare class decoration extends Element {
    constructor(rawsource?: string, children?: NodeInterface[], attributes?: Attributes);
    getHeader(): NodeInterface;
    getFooter(): NodeInterface;
}
declare class Text extends Node {
    pformat(indent?: string, level?: number): string;
    copy(): NodeInterface;
    deepcopy(): NodeInterface;
    walk(visitor: Visitor): boolean;
    private data;
    constructor(data: string, rawsource?: string);
    _domNode(domroot: globalThis.Document): {};
    astext(): string;
    toString(): string;
    toSource(): string;
    add(iNodes: NodeInterface[] | NodeInterface): void;
    emptytag(): string;
}
declare class TextElement extends Element implements TextElementInterface {
    constructor(rawsource?: string, text?: string, children?: NodeInterface[], attributes?: Attributes);
}
export interface TransformerInterface {
    addPending(pending: NodeInterface, priority: number): void;
}
/**
 * Document class. Do not call the constructor, rather call
 * {@link newDocument} to obtain a new document instance
 *
 * Implements {@link Document}
 * @extends Element
 * @implements Document
 */
declare class document extends Element implements Document {
    settings: Settings;
    reporter: ReporterInterface;
    decoration?: decoration;
    transformMessages: Systemmessage[];
    parseMessages: Systemmessage[];
    transformer: Transformer;
    substitutionDefs: SubstitutionDefs;
    substitutionNames: SubstitutionNames;
    citationRefs: RefNames;
    private citations;
    private footnoteRefs;
    private autofootnoteRefs;
    private symbolFootnotes;
    private footnotes;
    private symbolFootnoteRefs;
    private indirectTargets;
    private autofootnotes;
    private refIds;
    private refNames;
    nameIds: NameIds;
    private ids;
    private nameTypes;
    private idStart;
    private autofootnoteStart;
    private symbolFootnoteStart;
    private idPrefix;
    private autoIdPrefix;
    logger: LoggerType;
    /** Private constructor */
    constructor(settings: Settings, reporter: ReporterInterface, logger: LoggerType, rawsource?: string, children?: NodeInterface[], attributes?: Attributes);
    setId(node: NodeInterface, msgnode?: NodeInterface): string;
    setNameIdMap(node: NodeInterface, id: string, msgnode: NodeInterface, explicit?: boolean): void;
    setDuplicateNameId(node: NodeInterface, id: string, name: string, msgnode: NodeInterface, explicit?: boolean): void;
    hasName(name: string): boolean;
    noteImplicitTarget(target: NodeInterface, msgnode: NodeInterface): void;
    noteExplicitTarget(target: NodeInterface, msgnode?: NodeInterface): void;
    noteRefname(node: NodeInterface): void;
    noteRefId(node: NodeInterface): void | never;
    noteIndirectTarget(target: NodeInterface): void;
    noteAnonymousTarget(target: NodeInterface): void;
    noteAutofootnote(footnote: NodeInterface): void;
    noteAutofootnoteRef(ref: NodeInterface): void;
    noteSymbolFootnote(footnote: NodeInterface): void;
    noteSymbolFootnoteRef(ref: NodeInterface): void;
    noteFootnote(footnote: NodeInterface): void;
    noteFootnoteRef(ref: NodeInterface): void;
    noteCitation(citation: NodeInterface): void;
    noteCitationRef(ref: NodeInterface): void | never;
    noteSubstitutionDef(subdef: substitution_definition, defName: string, msgnode: NodeInterface): void;
    noteSubstitutionRef(subref: NodeInterface, refname: string): void;
    notePending(pending: NodeInterface, priority: number): void;
    noteParseMessage(message: Systemmessage): void;
    noteTransformMessage(message: Systemmessage): void;
    noteSource(source: string, offset: number): void;
    getDecoration(): decoration;
}
declare class FixedTextElement extends TextElement {
}
declare class title extends TextElement {
    constructor(rawsource?: string, text?: string, children?: NodeInterface[], attributes?: Attributes);
}
declare class subtitle extends TextElement {
    constructor(rawsource?: string, text?: string, children?: NodeInterface[], attributes?: Attributes);
}
declare class rubric extends TextElement {
    constructor(rawsource?: string, text?: string, children?: NodeInterface[], attributes?: Attributes);
}
declare class docinfo extends Element {
    constructor(rawsource?: string, children?: NodeInterface[], attributes?: Attributes);
}
declare class author extends TextElement {
    constructor(rawsource?: string, text?: string, children?: NodeInterface[], attributes?: Attributes);
}
declare class authors extends Element {
    constructor(rawsource?: string, children?: NodeInterface[], attributes?: Attributes);
}
declare class organization extends TextElement {
    constructor(rawsource?: string, text?: string, children?: NodeInterface[], attributes?: Attributes);
}
declare class address extends FixedTextElement {
    constructor(...args: any[]);
}
declare class contact extends TextElement {
    constructor(rawsource?: string, text?: string, children?: NodeInterface[], attributes?: Attributes);
}
declare class version extends TextElement {
    constructor(rawsource?: string, text?: string, children?: NodeInterface[], attributes?: Attributes);
}
declare class revision extends TextElement {
    constructor(rawsource?: string, text?: string, children?: NodeInterface[], attributes?: Attributes);
}
declare class status extends TextElement {
    constructor(rawsource?: string, text?: string, children?: NodeInterface[], attributes?: Attributes);
}
declare class date extends TextElement {
    constructor(rawsource?: string, text?: string, children?: NodeInterface[], attributes?: Attributes);
}
declare class copyright extends TextElement {
    constructor(rawsource?: string, text?: string, children?: NodeInterface[], attributes?: Attributes);
}
declare class section extends Element {
    constructor(rawsource?: string, children?: NodeInterface[], attributes?: Attributes);
}
/**
 *  Topics are terminal, "leaf" mini-sections, like block quotes with titles,
 *  or textual figures.  A topic is just like a section, except that it has no
 *  subsections, and it doesn't have to conform to section placement rules.
 *
 *  Topics are allowed wherever body elements (list, table, etc.) are allowed,
 *  but only at the top level of a section or document.  Topics cannot nest
 *  inside topics, sidebars, or body elements; you can't have a topic inside a
 *  table, list, block quote, etc.
 */
declare class topic extends Element {
    constructor(rawsource?: string, children?: NodeInterface[], attributes?: Attributes);
}
declare class sidebar extends Element {
    constructor(rawsource?: string, children?: NodeInterface[], attributes?: Attributes);
}
declare class transition extends Element {
    constructor(rawsource?: string, children?: NodeInterface[], attributes?: Attributes);
}
declare class paragraph extends TextElement {
    constructor(rawsource?: string, text?: string, children?: NodeInterface[], attributes?: Attributes);
}
declare class compound extends Element {
    constructor(rawsource?: string, children?: NodeInterface[], attributes?: Attributes);
}
declare class container extends Element {
    constructor(rawsource?: string, children?: NodeInterface[], attributes?: Attributes);
}
declare class bullet_list extends Element {
    constructor(rawsource?: string, children?: NodeInterface[], attributes?: Attributes);
}
declare class enumerated_list extends Element {
    start?: number;
    suffix?: string;
    prefix?: string;
    enumtype: string;
    constructor(rawsource?: string, children?: NodeInterface[], attributes?: Attributes);
}
declare class list_item extends Element {
    constructor(rawsource?: string, children?: NodeInterface[], attributes?: Attributes);
}
declare class definition_list extends Element {
    constructor(rawsource?: string, children?: NodeInterface[], attributes?: Attributes);
}
declare class definition_list_item extends Element {
    constructor(rawsource?: string, children?: NodeInterface[], attributes?: Attributes);
}
declare class term extends TextElement {
    constructor(rawsource?: string, text?: string, children?: NodeInterface[], attributes?: Attributes);
}
declare class classifier extends TextElement {
    constructor(rawsource?: string, text?: string, children?: NodeInterface[], attributes?: Attributes);
}
declare class definition extends Element {
    constructor(rawsource?: string, children?: NodeInterface[], attributes?: Attributes);
}
declare class field_list extends Element {
    constructor(rawsource?: string, children?: NodeInterface[], attributes?: Attributes);
}
declare class field extends Element {
    constructor(rawsource?: string, children?: NodeInterface[], attributes?: Attributes);
}
declare class field_name extends TextElement {
    constructor(rawsource?: string, text?: string, children?: NodeInterface[], attributes?: Attributes);
}
declare class field_body extends Element {
    constructor(rawsource?: string, children?: NodeInterface[], attributes?: Attributes);
}
declare class option extends Element {
    constructor(rawsource?: string, children?: NodeInterface[], attributes?: Attributes);
}
declare class option_argument extends TextElement {
    constructor(rawsource?: string, text?: string, children?: NodeInterface[], attributes?: Attributes);
    astext(): string;
}
declare class option_group extends Element {
    constructor(rawsource?: string, children?: NodeInterface[], attributes?: Attributes);
}
declare class option_list extends Element {
    constructor(rawsource?: string, children?: NodeInterface[], attributes?: Attributes);
}
declare class option_list_item extends Element {
    constructor(rawsource?: string, children?: NodeInterface[], attributes?: Attributes);
}
declare class option_string extends TextElement {
    constructor(rawsource?: string, text?: string, children?: NodeInterface[], attributes?: Attributes);
}
declare class description extends Element {
    constructor(rawsource?: string, children?: NodeInterface[], attributes?: Attributes);
}
declare class literal_block extends FixedTextElement {
    constructor(...args: any[]);
}
declare class doctest_block extends FixedTextElement {
    constructor(...args: any[]);
}
declare class math_block extends FixedTextElement {
    constructor(...args: any[]);
}
declare class line_block extends Element {
    constructor(rawsource?: string, children?: NodeInterface[], attributes?: Attributes);
}
declare class line extends TextElement implements HasIndent {
    indent: number;
    _init(): void;
}
declare class block_quote extends Element {
    constructor(rawsource?: string, children?: NodeInterface[], attributes?: Attributes);
}
declare class attribution extends TextElement {
    constructor(rawsource?: string, text?: string, children?: NodeInterface[], attributes?: Attributes);
}
declare class attention extends Element {
    constructor(rawsource?: string, children?: NodeInterface[], attributes?: Attributes);
}
declare class caution extends Element {
    constructor(rawsource?: string, children?: NodeInterface[], attributes?: Attributes);
}
declare class danger extends Element {
    constructor(rawsource?: string, children?: NodeInterface[], attributes?: Attributes);
}
declare class error extends Element {
    constructor(rawsource?: string, children?: NodeInterface[], attributes?: Attributes);
}
declare class important extends Element {
    constructor(rawsource?: string, children?: NodeInterface[], attributes?: Attributes);
}
declare class note extends Element {
    constructor(rawsource?: string, children?: NodeInterface[], attributes?: Attributes);
}
declare class tip extends Element {
    constructor(rawsource?: string, children?: NodeInterface[], attributes?: Attributes);
}
declare class hint extends Element {
    constructor(rawsource?: string, children?: NodeInterface[], attributes?: Attributes);
}
declare class warning extends Element {
    constructor(rawsource?: string, children?: NodeInterface[], attributes?: Attributes);
}
declare class admonition extends Element {
    constructor(rawsource?: string, children?: NodeInterface[], attributes?: Attributes);
}
declare class comment extends FixedTextElement {
    constructor(...args: any[]);
}
declare class substitution_definition extends TextElement {
    constructor(...args: any[]);
}
declare class target extends TextElement {
    indirectReferenceName: string;
    constructor(...args: any[]);
}
declare class footnote extends Element {
    constructor(rawsource?: string, children?: NodeInterface[], attributes?: Attributes);
}
declare class citation extends Element {
    constructor(rawsource?: string, children?: NodeInterface[], attributes?: Attributes);
}
declare class label extends TextElement {
    constructor(rawsource?: string, text?: string, children?: NodeInterface[], attributes?: Attributes);
}
declare class figure extends Element {
    constructor(rawsource?: string, children?: NodeInterface[], attributes?: Attributes);
}
declare class caption extends TextElement {
    constructor(rawsource?: string, text?: string, children?: NodeInterface[], attributes?: Attributes);
}
declare class legend extends Element {
    constructor(rawsource?: string, children?: NodeInterface[], attributes?: Attributes);
}
declare class table extends Element {
    constructor(rawsource?: string, children?: NodeInterface[], attributes?: Attributes);
}
declare class tgroup extends Element {
    stubs?: {}[];
    constructor(rawsource?: string, children?: NodeInterface[], attributes?: Attributes);
}
declare class colspec extends Element {
    constructor(rawsource?: string, children?: NodeInterface[], attributes?: Attributes);
}
declare class thead extends Element {
    constructor(rawsource?: string, children?: NodeInterface[], attributes?: Attributes);
}
declare class tbody extends Element {
    constructor(rawsource?: string, children?: NodeInterface[], attributes?: Attributes);
}
declare class row extends Element {
    column?: number;
    constructor(rawsource?: string, children?: NodeInterface[], attributes?: Attributes);
}
declare class entry extends Element {
    constructor(rawsource?: string, children?: NodeInterface[], attributes?: Attributes);
}
declare class system_message extends Element implements Systemmessage {
    constructor(message: string, children: NodeInterface[], attributes: Attributes);
}
/**
 *  The "pending" element is used to encapsulate a pending operation: the
 *  operation (transform), the point at which to apply it, and any data it
 *  requires.  Only the pending operation's location within the document is
 *  stored in the public document tree (by the "pending" object itself); the
 *  operation and its data are stored in the "pending" object's internal
 *  instance attributes.
 *
 *  For example, say you want a table of contents in your reStructuredText
 *  document.  The easiest way to specify where to put it is from within the
 *  document, with a directive::
 *
 *      .. contents::
 *
 *  But the "contents" directive can't do its work until the entire document
 *  has been parsed and possibly transformed to some extent.  So the directive
 *  code leaves a placeholder behind that will trigger the second phase of its
 *  processing, something like this::
 *
 *      <pending ...public attributes...> + internal attributes
 *
 *  Use `document.note_pending()` so that the
 *  `docutils.transforms.Transformer` stage of processing can run all pending
 *  transforms.
 */
declare class pending extends Element {
    details: {};
    transform: {};
    constructor(transform: {}, details: {}, rawsource: string | undefined, children: NodeInterface[], attributes: Attributes);
}
declare class raw extends FixedTextElement {
    constructor(...args: any[]);
}
declare class emphasis extends TextElement {
    constructor(rawsource?: string, text?: string, children?: NodeInterface[], attributes?: Attributes);
}
declare class strong extends TextElement {
    constructor(rawsource?: string, text?: string, children?: NodeInterface[], attributes?: Attributes);
}
declare class literal extends TextElement {
    constructor(rawsource?: string, text?: string, children?: NodeInterface[], attributes?: Attributes);
}
declare class reference extends TextElement {
    indirectReferenceName: string | undefined;
    constructor(rawsource?: string, text?: string, children?: NodeInterface[], attributes?: Attributes);
}
declare class footnote_reference extends TextElement {
    constructor(rawsource?: string, text?: string, children?: NodeInterface[], attributes?: Attributes);
}
declare class citation_reference extends TextElement {
    constructor(rawsource?: string, text?: string, children?: NodeInterface[], attributes?: Attributes);
}
declare class substitution_reference extends TextElement {
    constructor(rawsource?: string, text?: string, children?: NodeInterface[], attributes?: Attributes);
}
declare class title_reference extends TextElement {
    constructor(rawsource?: string, text?: string, children?: NodeInterface[], attributes?: Attributes);
}
declare class abbreviation extends TextElement {
    constructor(rawsource?: string, text?: string, children?: NodeInterface[], attributes?: Attributes);
}
declare class acronym extends TextElement {
    constructor(rawsource?: string, text?: string, children?: NodeInterface[], attributes?: Attributes);
}
declare class superscript extends TextElement {
    constructor(rawsource?: string, text?: string, children?: NodeInterface[], attributes?: Attributes);
}
declare class subscript extends TextElement {
    constructor(rawsource?: string, text?: string, children?: NodeInterface[], attributes?: Attributes);
}
declare class math extends TextElement {
    constructor(rawsource?: string, text?: string, children?: NodeInterface[], attributes?: Attributes);
}
declare class image extends Element {
    constructor(rawsource?: string, children?: NodeInterface[], attributes?: Attributes);
    astext(): string;
}
declare class inline extends TextElement {
    constructor(rawsource?: string, text?: string, children?: NodeInterface[], attributes?: Attributes);
}
declare class problematic extends TextElement {
    constructor(rawsource?: string, text?: string, children?: NodeInterface[], attributes?: Attributes);
}
declare class generated extends TextElement {
    constructor(rawsource?: string, text?: string, children?: NodeInterface[], attributes?: Attributes);
}
export { Node, whitespaceNormalizeName, NodeVisitor, GenericNodeVisitor, SparseNodeVisitor, Element, TextElement, Text, abbreviation, acronym, address, admonition, attention, attribution, author, authors, block_quote, bullet_list, caption, caution, citation, citation_reference, classifier, colspec, comment, compound, contact, container, copyright, danger, date, decoration, definition, definition_list, definition_list_item, description, docinfo, doctest_block, document, emphasis, entry, enumerated_list, error, field, field_body, field_list, field_name, figure, footer, footnote, footnote_reference, generated, header, hint, image, important, inline, label, legend, line, line_block, list_item, literal, literal_block, math, math_block, note, option, option_argument, option_group, option_list, option_list_item, option_string, organization, paragraph, pending, problematic, raw, reference, revision, row, rubric, section, sidebar, status, strong, subscript, substitution_definition, substitution_reference, subtitle, superscript, system_message, table, target, tbody, term, tgroup, thead, tip, title, title_reference, topic, transition, version, warning, Root, Titular, PreBibliographic, Bibliographic, Decorative, Structural, Body, General, Sequential, Admonition, Special, Invisible, Part, Inline, Referential, Targetable, Labeled, _addNodeClassNames, SkipChildren, StopTraversal, SkipNode, SkipDeparture, SkipSiblings, FixedTextElement, NodeFound, };