export * from './domImpl';
export * from './domComponent';
export * from './domComputed';
export * from './domDispose';
export * from './domForEach';
export * from './domMethods';
export * from './domevent';
import * as _domComponent from './domComponent';
import * as _domComputed from './domComputed';
import * as _domDispose from './domDispose';
import * as _domForEach from './domForEach';
import * as _domImpl from './domImpl';
import * as _domMethods from './domMethods';
import * as domevent from './domevent';
import { IDomArgs, TagElem, TagName } from './domImpl';
/**
 * `dom()` provides a way to build a DOM tree easily.
 *
 * The first argument is a string consisting of a lowercase tag name (e.g. `"div"`), with optional
 * `"#foo"` suffix to add the ID `'foo'`, and zero or more `".bar"` suffixes to add a CSS class
 * `'bar'`.
 *
 * The rest of the arguments are optional and may be any number, of these types:
 *
 * @param Nodes - become children of the created element
 * @param strings - become text node children
 * @param objects - Literal objects to set string attributes on the element.
 *    E.g. `{title: "foo"}`.
 * @param null - The values `null` and `undefined` values are ignored completely.
 * @param Arrays - flattened with each item processed recursively
 * @param functions - called with the element being built as the argument, for a chance to modify
 *    the element as it's being created. Return values are processed recursively.
 * @param functions - "dom methods" are a expressions such as `dom.attr('href', url)` or
 *    `dom.hide(obs)`, which are special cases of the "functions" category.
 *
 * @example
 * ```ts
 * import {dom} from 'grainjs';
 * dom('a', {href: url, className: 'myclass'}, 'Hello ', dom('strong', 'world'));
 * ```
 * creates HTML element `<a href={{url}} class="myclass">Hello <strong>world</strong></a>`.
 *
 * @example
 * Here's an example equivalent to the one above, using dom methods `dom.cls`, `dom.attr`,
 * `dom.text`. In reality, these methods are useful with observable values rather than constant
 * strings.
 * ```ts
 *  dom('a', dom.attr('href', url), dom.cls('myclass'),
 *      dom.text('Hello '), dom('strong', dom.text('world')));
 * ```
 *
 * @see [DOM & Observables](/basics).
 */
export declare function dom<Tag extends TagName>(tagString: Tag, ...args: IDomArgs<TagElem<Tag>>): TagElem<Tag>;
export declare namespace dom {
    const svg: typeof _domImpl.svg;
    const frag: typeof _domImpl.frag;
    const update: typeof _domImpl.update;
    const find: typeof _domImpl.find;
    const findAll: typeof _domImpl.findAll;
    const domDispose: typeof _domDispose.domDispose;
    const onDisposeElem: typeof _domDispose.onDisposeElem;
    const onDispose: typeof _domDispose.onDispose;
    const autoDisposeElem: typeof _domDispose.autoDisposeElem;
    const autoDispose: typeof _domDispose.autoDispose;
    const attrsElem: typeof _domMethods.attrsElem;
    const attrs: typeof _domMethods.attrs;
    const attrElem: typeof _domMethods.attrElem;
    const attr: typeof _domMethods.attr;
    const boolAttrElem: typeof _domMethods.boolAttrElem;
    const boolAttr: typeof _domMethods.boolAttr;
    const textElem: typeof _domMethods.textElem;
    const text: typeof _domMethods.text;
    const styleElem: typeof _domMethods.styleElem;
    const style: typeof _domMethods.style;
    const propElem: typeof _domMethods.propElem;
    const prop: typeof _domMethods.prop;
    const showElem: typeof _domMethods.showElem;
    const show: typeof _domMethods.show;
    const hideElem: typeof _domMethods.hideElem;
    const hide: typeof _domMethods.hide;
    const clsElem: typeof _domMethods.clsElem;
    const cls: typeof _domMethods.cls;
    const clsPrefix: typeof _domMethods.clsPrefix;
    const dataElem: typeof _domMethods.dataElem;
    const data: typeof _domMethods.data;
    const getData: typeof _domMethods.getData;
    const replaceContent: typeof _domComputed.replaceContent;
    const domComputed: typeof _domComputed.domComputed;
    const domComputedOwned: typeof _domComputed.domComputedOwned;
    const maybe: typeof _domComputed.maybe;
    const maybeOwned: typeof _domComputed.maybeOwned;
    const forEach: typeof _domForEach.forEach;
    const create: typeof _domComponent.create;
    const onElem: typeof domevent.onElem;
    const on: typeof domevent.on;
    const onMatchElem: typeof domevent.onMatchElem;
    const onMatch: typeof domevent.onMatch;
    const onKeyElem: typeof domevent.onKeyElem;
    const onKeyPress: typeof domevent.onKeyPress;
    const onKeyDown: typeof domevent.onKeyDown;
}