export type NODE_TYPE = number;
export namespace NODE_TYPE {
    const ELEMENT: number;
    const ATTR: number;
    const TEXT: number;
    const COMMENT: number;
    const FRAGMENT: number;
}
export type EMPTY = any;
export namespace EMPTY {
    const STR: string;
    const NUM: number;
    const OBJ: any;
    const ARR: never[];
    const MAP: Map<any, any>;
    const SET: Set<any>;
    const DOM: HTMLElement;
    function FUN(): void;
}
export type PATCH_TYPE = number;
export namespace PATCH_TYPE {
    const SET_ATTRIBUTE: number;
    const REMOVE_ATTRIBUTE: number;
    const NODE_VALUE: number;
    const INSERT_BEFORE: number;
    const REPLACE_CHILD: number;
    const REMOVE_CHILD: number;
}
export type TransitionStateNames = TransitionStateName[];
/**
 * @typedef {TransitionStateName[]} TransitionStateNames
 * @type {TransitionStateNames}
 */
export const TransitionStateNames: TransitionStateNames;
/**
 * Creates a mapping of TransitionState
 */
export type TransitionCache = Map<TransitionStateName, Set<Function>>;
/**
 * Creates a mapping of TransitionState
 *
 * @typedef {Map<TransitionStateName, Set<Function>>} TransitionCache
 */
export const TransitionCache: Map<string, Set<any>>;
/**
 * Associates active transaction mount with state.
 */
export type StateCache = Map<Mount, TransactionState>;
/**
 * Associates active transaction mount with state.
 *
 * @typedef {Map<Mount, TransactionState>} StateCache
 */
export const StateCache: Map<any, any>;
/**
 * Associates a VTree with a distinctive DOM Node.
 */
export type NodeCache = Map<VTree, ValidNode>;
/**
 * Associates a VTree with a distinctive DOM Node.
 *
 * @typedef {Map<VTree, ValidNode>} NodeCache
 */
export const NodeCache: Map<any, any>;
/**
 * Stores middleware functions/objects which hook into the render flow.
 */
export type MiddlewareCache = Set<Function>;
/**
 * Stores middleware functions/objects which hook into the render flow.
 *
 * @typedef {Set<Function>} MiddlewareCache
 */
export const MiddlewareCache: Set<any>;
export type CreateTreeHookCache = Set<Function>;
/**
 * @typedef {Set<Function>} CreateTreeHookCache
 */
export const CreateTreeHookCache: Set<any>;
export type CreateNodeHookCache = Set<CreateNodeHookCallback>;
/**
 * @typedef {(vTree: VTree) => ValidNode | void} CreateNodeHookCallback
 * @typedef {Set<CreateNodeHookCallback>} CreateNodeHookCache
 */
export const CreateNodeHookCache: Set<any>;
export type SyncTreeHookCache = Set<Function>;
/**
 * @typedef {Set<Function>} SyncTreeHookCache
 */
export const SyncTreeHookCache: Set<any>;
export type ReleaseHookCache = Set<Function>;
/**
 * @typedef {Set<Function>} ReleaseHookCache
 */
export const ReleaseHookCache: Set<any>;
export type ParseHookCache = Set<Function>;
/**
 * @typedef {Set<Function>} ParseHookCache
 */
export const ParseHookCache: Set<any>;
export type TransitionStateName = 'attached' | 'detached' | 'replaced' | 'attributeChanged' | 'textChanged';
/**
 * @typedef {'attached' | 'detached' | 'replaced' | 'attributeChanged' | 'textChanged'} TransitionStateName
 */
export const TransitionStateName: any;
export type VTreeAttributes = {
    [key: string]: any;
};
/**
 * @typedef {{ [key: string]: any }} VTreeAttributes
 *
 */
export const VTreeAttributes: any;
export type VTree = {
    /**
     * - unaltered extracted nodeName
     */
    rawNodeName: any;
    /**
     * - lowercased, string, nodeName
     */
    nodeName: string;
    /**
     * - defines the text value associated
     */
    nodeValue: string;
    /**
     * - the type of Node this is representing
     */
    nodeType: number;
    /**
     * - A unique identifier for the children
     */
    key: string;
    /**
     * - Any nested elements
     */
    childNodes: VTree[];
    /**
     * - Any key/val attributes for the Node
     */
    attributes: VTreeAttributes;
};
/**
 * @typedef {Object} VTree
 *
 * @property {any} rawNodeName - unaltered extracted nodeName
 * @property {string} nodeName - lowercased, string, nodeName
 * @property {string} nodeValue - defines the text value associated
 * @property {number} nodeType - the type of Node this is representing
 * @property {string} key - A unique identifier for the children
 * @property {VTree[]} childNodes - Any nested elements
 * @property {VTreeAttributes} attributes - Any key/val attributes for the Node
 */
export const VTree: any;
export type VTreeLike = {
    /**
     * - unaltered extracted nodeName
     */
    rawNodeName?: any | undefined;
    /**
     * - lowercased, string, nodeName, only required value
     */
    nodeName?: string | undefined;
    /**
     * - lowercased, string, elementName
     */
    elementName?: string | undefined;
    /**
     * - defines the text value associated
     */
    nodeValue?: string | undefined;
    /**
     * - the type of Node this is representing
     */
    nodeType?: number | undefined;
    /**
     * - A unique identifier for the children
     */
    key?: string | undefined;
    /**
     * - Any nested elements
     */
    childNodes?: VTreeLike[] | undefined;
    /**
     * - Any nested elements
     */
    children?: VTreeLike[] | undefined;
    /**
     * - Any key/val attributes for the Node
     */
    attributes?: any | undefined;
};
/**
 * @typedef {Object} VTreeLike

 * @property {any=} rawNodeName - unaltered extracted nodeName
 * @property {string=} nodeName - lowercased, string, nodeName, only required value
 * @property {string=} elementName - lowercased, string, elementName
 * @property {string=} nodeValue - defines the text value associated
 * @property {number=} nodeType - the type of Node this is representing
 * @property {string=} key - A unique identifier for the children
 * @property {VTreeLike[]=} childNodes - Any nested elements
 * @property {VTreeLike[]=} children - Any nested elements
 * @property {any=} attributes - Any key/val attributes for the Node
 */
export const VTreeLike: any;
export type ValidInput = HTMLElement | ChildNode | Element | Text | Comment | DocumentFragment | Function | string | string[] | VTree | VTree[] | VTreeLike | VTreeLike[];
/**
 * @typedef {HTMLElement | ChildNode | Element | Text | Comment | DocumentFragment | Function | string | string[] | VTree | VTree[] | VTreeLike | VTreeLike[]} ValidInput
 */
export const ValidInput: any;
export type ValidNode = Element | HTMLElement | Text | DocumentFragment | ChildNode;
/**
 * @typedef {Element | HTMLElement | Text | DocumentFragment | ChildNode} ValidNode
 */
export const ValidNode: any;
export type Mount = ValidNode | VTree | VTree[] | VTreeLike | VTreeLike[];
/**
 * @typedef {ValidNode | VTree | VTree[] | VTreeLike | VTreeLike[]} Mount
 */
export const Mount: any;
export type Middleware = {
    displayName?: string | undefined;
    subscribe?: Function | undefined;
    unsubscribe?: Function | undefined;
    createTreeHook?: Function | undefined;
    createNodeHook?: CreateNodeHookCallback | undefined;
    syncTreeHook?: Function | undefined;
    releaseHook?: Function | undefined;
    parseHook?: Function | undefined;
};
/**
 * @typedef {Object} Middleware
 *
 * @property {string=} displayName
 * @property {Function=} subscribe
 * @property {Function=} unsubscribe
 * @property {Function=} createTreeHook
 * @property {CreateNodeHookCallback=} createNodeHook
 * @property {Function=} syncTreeHook
 * @property {Function=} releaseHook
 * @property {Function=} parseHook
 */
export const Middleware: any;
export type ParserConfig = {
    /**
     * - Should the parser operate in strict mode
     */
    strict?: boolean | undefined;
    /**
     * - Trim surrounding whitespace nodes
     */
    trim?: boolean | undefined;
    /**
     * - Set of raw element tagNames, empty is all
     */
    rawElements?: string[] | undefined;
    /**
     * - Set of self closing element tagNames, empty is all
     */
    selfClosingElements?: string[] | undefined;
};
/**
 * @typedef {Object} ParserConfig
 *
 * @property {Boolean=} strict - Should the parser operate in strict mode
 * @property {Boolean=} trim - Trim surrounding whitespace nodes
 * @property {string[]=} rawElements - Set of raw element tagNames, empty is all
 * @property {string[]=} selfClosingElements - Set of self closing element tagNames, empty is all
 */
export const ParserConfig: any;
export type TransactionConfig = {
    /**
     * - to diff children or root
     */
    inner?: boolean | undefined;
    /**
     * - to execute scripts or not
     */
    executeScripts?: boolean | undefined;
    /**
     * - to override tasks
     */
    tasks?: Function[] | undefined;
    /**
     * - override parser options
     */
    parser?: ParserConfig | undefined;
    /**
     * - to disable mutation observer (enabled by default if available)
     */
    disableMutationObserver?: boolean | undefined;
};
/**
 * @typedef {Object} TransactionConfig
 *
 * @property {Boolean=} inner - to diff children or root
 * @property {Boolean=} executeScripts - to execute scripts or not
 * @property {Function[]=} tasks - to override tasks
 * @property {ParserConfig=} parser - override parser options
 * @property {Boolean=} disableMutationObserver - to disable mutation observer (enabled by default if available)
 */
export const TransactionConfig: any;
export type GlobalConfig = {
    /**
     * - To set the runtime execution mode
     */
    NODE_ENV?: string | undefined;
    /**
     * - to collect performance metrics, defaults to false
     */
    collectMetrics?: boolean | undefined;
};
/**
 * @typedef {Object} GlobalConfig
 *
 * @property {string=} NODE_ENV - To set the runtime execution mode
 * @property {Boolean=} collectMetrics - to collect performance metrics, defaults to false
 */
export const GlobalConfig: any;
export type Config = TransactionConfig & GlobalConfig & {
    [key: string]: unknown;
};
/**
 * @typedef {TransactionConfig & GlobalConfig & { [key: string]: unknown }} Config
 */
export const Config: {};
export type Supplemental = {
    tags: {
        [key: string]: any;
    };
    attributes: {
        [key: string]: any;
    };
    children: {
        [key: string]: any;
    };
};
/**
 * @typedef {Object} Supplemental
 *
 * @property {{ [key: string]: any }} tags
 * @property {{ [key: string]: any }} attributes
 * @property {{ [key: string]: any }} children
 */
export const Supplemental: any;
export type TransactionState = {
    measure: Function;
    svgElements: Set<VTree>;
    scriptsToExecute: Map<VTree, string | undefined>;
    oldTree?: VTree | undefined;
    isRendering?: boolean | undefined;
    isDirty?: boolean | undefined;
    mutationObserver?: MutationObserver | undefined;
    activeTransaction: import('../transaction').default;
    nextTransaction?: import('../transaction').default | undefined;
    ownerDocument?: Document | undefined;
};
/**
 * @typedef {Object} TransactionState
 *
 * @property {Function} measure
 * @property {Set<VTree>} svgElements
 * @property {Map<VTree, string | undefined>} scriptsToExecute
 * @property {VTree=} oldTree
 * @property {Boolean=} isRendering
 * @property {Boolean=} isDirty
 * @property {MutationObserver=} mutationObserver
 * @property {import('../transaction').default} activeTransaction
 * @property {import('../transaction').default=} nextTransaction
 * @property {Document=} ownerDocument
*/
export const TransactionState: any;
export type Internals = {
    VERSION?: string | undefined;
    globalConfig?: GlobalConfig | undefined;
    decodeEntities: Function;
    escape: Function;
    makeMeasure: Function;
    memory: any;
    Pool: any;
    process: any;
    PATCH_TYPE: {
        [key: string]: any;
    };
    parse?: Function | undefined;
    createNode: Function;
    syncTree: Function;
    Transaction: unknown;
    defaultTasks: Function[];
    tasks: {
        [key: string]: any;
    };
    StateCache: StateCache;
    NodeCache: NodeCache;
    TransitionCache: TransitionCache;
    MiddlewareCache: MiddlewareCache;
    CreateTreeHookCache: CreateTreeHookCache;
    CreateNodeHookCache: CreateNodeHookCache;
    SyncTreeHookCache: SyncTreeHookCache;
    ReleaseHookCache: ReleaseHookCache;
    ParseHookCache: ParseHookCache;
};
/**
 * @typedef {Object} Internals
 *
 * @property {string=} VERSION
 * @property {GlobalConfig=} globalConfig
 * @property {Function} decodeEntities
 * @property {Function} escape
 * @property {Function} makeMeasure
 * @property {any} memory
 * @property {any} Pool
 * @property {any} process
 * @property {{ [key: string]: any }} PATCH_TYPE
 * @property {Function=} parse
 * @property {Function} createNode
 * @property {Function} syncTree
 * @property {unknown} Transaction
 * @property {Function[]} defaultTasks
 * @property {{ [key: string]: any }} tasks
 * @property {StateCache} StateCache
 * @property {NodeCache} NodeCache
 * @property {TransitionCache} TransitionCache
 * @property {MiddlewareCache} MiddlewareCache
 * @property {CreateTreeHookCache} CreateTreeHookCache
 * @property {CreateNodeHookCache} CreateNodeHookCache
 * @property {SyncTreeHookCache} SyncTreeHookCache
 * @property {ReleaseHookCache} ReleaseHookCache
 * @property {ParseHookCache} ParseHookCache
 */
export const Internals: any;
export type CreateNodeHookCallback = (vTree: VTree) => ValidNode | void;
