/**
 * @module imscDoc
 */
/**
 * @typedef {import("./error").ErrorHandler} ErrorHandler
 * @typedef {import("./parser").Node} Node
 * @typedef {import("./parser").Parser} Parser
 */
/**
 * Allows a client to provide callbacks to handle children of the <metadata> element
 * @typedef {Object} MetadataHandler
 * @property {?OpenTagCallBack} onOpenTag
 * @property {?CloseTagCallBack} onCloseTag
 * @property {?TextCallBack} onText
 */
/**
 * Called when the opening tag of an element node is encountered.
 * @callback OpenTagCallBack
 * @param {string} ns Namespace URI of the element
 * @param {string} name Local name of the element
 * @param {Record<string, {uri: string, name: string, value: string}>} attributes List of attributes, each consisting of a
 *                              `uri`, `name` and `value`
 */
/**
 * Called when the closing tag of an element node is encountered.
 * @callback CloseTagCallBack
 */
/**
 * Called when a text node is encountered.
 * @callback TextCallBack
 * @param {string} contents Contents of the text node
 */
/**
 * Parses an IMSC1 document into an opaque in-memory representation that exposes
 * a single method <pre>getMediaTimeEvents()</pre> that returns a list of time
 * offsets (in seconds) of the ISD, i.e. the points in time where the visual
 * representation of the document change. `metadataHandler` allows the caller to
 * be called back when nodes are present in <metadata> elements.
 *
 * @param {string} xmlstring XML document
 * @param {ErrorHandler} errorHandler Error callback
 * @param {?MetadataHandler} metadataHandler Callback for <Metadata> elements
 * @param {Parser} parser XML parser
 * @returns {?TTElement} Opaque in-memory representation of an IMSC1 document
 */
export function fromParser(xmlstring: string, errorHandler: ErrorHandler, metadataHandler: MetadataHandler | null, parser: Parser): TTElement | null;
export class ForeignElement {
    constructor(node: any);
    node: any;
}
export class TTElement {
    /**
     * @type {number[]}
     */
    events: number[];
    head: HeadElement;
    /**
     * @type {?BodyElement}
     */
    body: BodyElement | null;
    /**
     * @param {Node} node
     * @param {string} xmllang
     * @param {ErrorHandler} errorHandler
     */
    initFromNode(node: Node, xmllang: string, errorHandler: ErrorHandler): void;
    cellLength: {
        h: ComputedLength;
        w: ComputedLength;
    } | undefined;
    effectiveFrameRate: number | undefined;
    tickRate: number | undefined;
    aspectRatio: number | null | undefined;
    pxLength: {
        h: null;
        w: null;
    } | {
        h: ComputedLength;
        w: ComputedLength;
    } | undefined;
    /** set root container dimensions to (1, 1) arbitrarily
      * the root container is mapped to actual dimensions at rendering
    **/
    dimensions: {
        h: ComputedLength;
        w: ComputedLength;
    } | undefined;
    /**
     * @type {string}
     */
    lang: string | undefined;
    _registerEvent(elem: any): void;
    /**
     * Retrieves the range of ISD times covered by the document
     *
     * @returns {[number, number]} Array of two elements: min_begin_time and max_begin_time
     *
     */
    getMediaTimeRange(): [number, number];
    /**
     * Returns list of ISD begin times
     *
     * @returns {number[]}
     */
    getMediaTimeEvents(): number[];
}
export class HeadElement {
    styling: StylingElement;
    layout: LayoutElement;
}
export class StylingElement {
    /**
     * @type {Record<string, StyleElement>}
     */
    styles: Record<string, StyleElement>;
    /**
     * @type {Record<string, any>}
     */
    initials: Record<string, any>;
}
export class StyleElement {
    /**
     * @type {string}
     */
    id: string;
    /**
     * @type {Record<string, any>}
     */
    styleAttrs: Record<string, any>;
    /**
     * @type {string[]}
     */
    styleRefs: string[];
    /**
     * @param {Node} node
     * @param {ErrorHandler} errorHandler
     */
    initFromNode(node: Node, errorHandler: ErrorHandler): void;
}
export class InitialElement {
    /**
     * @type {Record<string, string>}
     */
    styleAttrs: Record<string, string>;
    /**
     * @param {Node} node
     */
    initFromNode(node: Node): void;
}
export class LayoutElement {
    regions: {};
}
export class ContentElement {
    /**
     * @param {string} kind
     */
    constructor(kind: string);
    kind: string;
}
export class ImageElement extends ContentElement {
    /**
     * @param {string} src
     * @param {string} type
     */
    constructor(src: string, type: string);
    /**
     * @type {string}
     */
    src: string;
    /**
     * @type {string}
     */
    type: string;
    /**
     * @param {TTElement} doc
     * @param {Node} parent
     * @param {Node} node
     * @param {string} xmllang
     * @param {ErrorHandler} errorHandler
     */
    initFromNode(doc: TTElement, parent: Node, node: Node, xmllang: string, errorHandler: ErrorHandler): void;
    lang: string | undefined;
}
export class IdentifiedMixin {
    /**
     * @param {string} id
     */
    constructor(id: string);
    id: string;
    /**
     * @param {TTElement} doc
     * @param {Node} parent
     * @param {Node} node
     */
    initFromNode(doc: TTElement, parent: Node, node: Node): void;
}
export class LayoutMixin {
    /**
     * @param {string} id
     */
    constructor(id: string);
    regionID: string;
    /**
     * @param {TTElement} doc
     * @param {Node} parent
     * @param {Node} node
     */
    initFromNode(doc: TTElement, parent: Node, node: Node): void;
}
export class StyledMixin {
    /**
     * @param {Record<string, any>} styleAttrs
     */
    constructor(styleAttrs: Record<string, any>);
    styleAttrs: Record<string, any>;
    /**
     * @param {TTElement} doc
     * @param {Node} parent
     * @param {Node} node
     * @param {ErrorHandler} errorHandler
     */
    initFromNode(doc: TTElement, parent: Node, node: Node, errorHandler: ErrorHandler): void;
}
export class AnimatedMixin {
    /**
     * @param {any[]} sets
     */
    constructor(sets: any[]);
    sets: any[];
    initFromNode(): void;
}
export class ContainerMixin {
    /**
     * @param {string} contents
     */
    constructor(contents: string);
    contents: string;
    initFromNode(): void;
}
export class TimedMixin {
    /**
     *
     * @param {number} explicit_begin
     * @param {number} explicit_end
     * @param {number} explicit_dur
     */
    constructor(explicit_begin: number, explicit_end: number, explicit_dur: number);
    explicit_begin: number;
    explicit_end: number;
    explicit_dur: number;
    /**
     * @param {TTElement} doc
     * @param {Node} parent
     * @param {Node} node
     * @param {ErrorHandler} errorHandler
     */
    initFromNode(doc: TTElement, parent: Node, node: Node, errorHandler: ErrorHandler): void;
    timeContainer: string | undefined;
}
export class BodyElement extends ContentElement {
    constructor();
    /**
     * @param {TTElement} doc
     * @param {Node} node
     * @param {string} xmllang
     * @param {ErrorHandler} errorHandler
     */
    initFromNode(doc: TTElement, node: Node, xmllang: string, errorHandler: ErrorHandler): void;
    lang: string | undefined;
}
export class DivElement extends ContentElement {
    constructor();
    /**
     * @param {TTElement} doc
     * @param {Node} parent
     * @param {Node} node
     * @param {string} xmllang
     * @param {ErrorHandler} errorHandler
     */
    initFromNode(doc: TTElement, parent: Node, node: Node, xmllang: string, errorHandler: ErrorHandler): void;
    lang: string | undefined;
}
export class PElement extends ContentElement {
    constructor();
    /**
     * @param {TTElement} doc
     * @param {Node} parent
     * @param {Node} node
     * @param {string} xmllang
     * @param {ErrorHandler} errorHandler
     */
    initFromNode(doc: TTElement, parent: Node, node: Node, xmllang: string, errorHandler: ErrorHandler): void;
    lang: string | undefined;
}
export class SpanElement extends ContentElement {
    constructor();
    /**
     * @param {TTElement} doc
     * @param {Node} parent
     * @param {Node} node
     * @param {string} xmllang
     * @param {string} xmlspace
     * @param {ErrorHandler} errorHandler
     */
    initFromNode(doc: TTElement, parent: Node, node: Node, xmllang: string, xmlspace: string, errorHandler: ErrorHandler): void;
    space: string | undefined;
    lang: string | undefined;
}
export class AnonymousSpanElement extends ContentElement {
    constructor();
    /**
     * @param {TTElement} doc
     * @param {Node} parent
     * @param {string} text
     * @param {string} xmlspace
     * @param {string} xmllang
     * @param {ErrorHandler} errorHandler
     */
    initFromText(doc: TTElement, parent: Node, text: string, xmllang: string, xmlspace: string, errorHandler: ErrorHandler): void;
    text: string | undefined;
    space: string | undefined;
    lang: string | undefined;
}
export class BrElement extends ContentElement {
    constructor();
    /**
     * @param {TTElement} doc
     * @param {Node} parent
     * @param {Node} node
     * @param {string} xmllang
     * @param {ErrorHandler} errorHandler
     */
    initFromNode(doc: TTElement, parent: Node, node: Node, xmllang: string, errorHandler: ErrorHandler): void;
    lang: string | undefined;
}
export class RegionElement {
    /**
     * @param {string} xmllang
     * @returns {RegionElement}
     */
    createDefaultRegion(xmllang: string): RegionElement;
    lang: string | undefined;
    /**
     * @param {TTElement} doc
     * @param {Node} node
     * @param {string} xmllang
     * @param {ErrorHandler} errorHandler
     */
    initFromNode(doc: TTElement, node: Node, xmllang: string, errorHandler: ErrorHandler): void;
    styleAttrs: Record<string, any> | undefined;
    styleRefs: string[] | undefined;
}
export class SetElement {
    /**
     * @param {TTElement} doc
     * @param {Node} parent
     * @param {Node} node
     * @param {ErrorHandler} errorHandler
     */
    initFromNode(doc: TTElement, parent: Node, node: Node, errorHandler: ErrorHandler): void;
    styles: Record<string, any> | undefined;
}
export type ErrorHandler = import("./error").ErrorHandler;
export type Node = import("./parser").Node;
export type Parser = import("./parser").Parser;
/**
 * Allows a client to provide callbacks to handle children of the <metadata> element
 */
export type MetadataHandler = {
    onOpenTag: OpenTagCallBack | null;
    onCloseTag: CloseTagCallBack | null;
    onText: TextCallBack | null;
};
/**
 * Called when the opening tag of an element node is encountered.
 */
export type OpenTagCallBack = (ns: string, name: string, attributes: Record<string, {
    uri: string;
    name: string;
    value: string;
}>) => any;
/**
 * Called when the closing tag of an element node is encountered.
 */
export type CloseTagCallBack = () => any;
/**
 * Called when a text node is encountered.
 */
export type TextCallBack = (contents: string) => any;
/**
 * Binary search utility function
 */
export type BinarySearchResult = {
    /**
     * Was an exact match found?
     */
    found: boolean;
    /**
     * Position of the exact match or insert position
     */
    index: number;
};
import { ComputedLength } from "./utils.js";
//# sourceMappingURL=doc.d.ts.map