/**
 * 定义vNode的类型
 */
type VNodeTag = string;

declare const EffectConstant: {
    NoEffect: number;
    DepsChange: number;
    LayoutEffect: number;
    Effect: number;
};

type ValueOf<T> = T[keyof T];
interface Hook<S, A> {
    state: Reducer$2<S, A> | Effect | Memo<S> | CallBack<S> | MutableRef<S>;
    hIndex: number;
}
interface Reducer$2<S, A> {
    stateValue: S | null;
    trigger: Trigger<A> | null;
    reducer: ((S: any, A: any) => S) | null;
    updates: Array<Update<S, A>> | null;
    isUseState: boolean;
}
type Update<S, A> = {
    action: A;
    didCalculated: boolean;
    state: S | null;
};
type Effect = {
    effect: () => (() => void) | void;
    removeEffect: (() => void) | void;
    dependencies: Array<any> | null;
    effectConstant: ValueOf<typeof EffectConstant>;
};
type Memo<V> = {
    result: V | null;
    dependencies: Array<any> | null;
};
type CallBack<F> = {
    func: F | null;
    dependencies: Array<any> | null;
};
type MutableRef<V> = {
    current: V;
};
export type RefObject<T> = {
    readonly current: T | null;
};
export type RefCallBack<T> = {
    bivarianceHack(inst: T | null): void;
}['bivarianceHack'];
type Trigger<A> = (state: A) => void;

interface IObserver {
    useProp: (key: string) => void;
    addListener: (listener: () => void) => void;
    removeListener: (listener: () => void) => void;
    setProp: (key: string, mutation: any) => void;
    triggerChangeListeners: (mutation: any) => void;
    triggerUpdate: (vNode: any) => void;
    allChange: () => void;
    clearByVNode: (vNode: any) => void;
}
/**
 * 一个对象（对象、数组、集合）对应一个Observer
 */
declare class Observer implements IObserver {
    vNodeKeys: WeakMap<object, any>;
    keyVNodes: Map<any, any>;
    listeners: ((mutation: any) => void)[];
    watchers: {
        [key: string]: ((key: string, oldValue: any, newValue: any, mutation: any) => void)[];
    };
    useProp(key: string | symbol): void;
    setProp(key: string | symbol, mutation: any): void;
    triggerUpdate(vNode: VNode): void;
    addListener(listener: (mutation: any) => void): void;
    removeListener(listener: (mutation: any) => void): void;
    triggerChangeListeners({ mutation, vNodes }: {
        mutation: any;
        vNodes: any;
    }): void;
    allChange(): void;
    clearByVNode(vNode: VNode): void;
}











declare class VNode {
    tag: VNodeTag;
    key: string | null;
    props: any;
    type: any;
    realNode: any;
    parent: VNode | null;
    child: VNode | null;
    next: VNode | null;
    cIndex: number;
    eIndex: number;
    ref: RefType | ((handle: any) => void) | null;
    oldProps: any;
    isCleared: boolean;
    changeList: any;
    effectList: any[] | null;
    updates: any[] | null;
    stateCallbacks: any[] | null;
    isForceUpdate: boolean;
    isSuspended: boolean;
    state: any;
    hooks: Array<Hook<any, any>> | null;
    depContexts: Array<ContextType<any>> | null;
    isDepContextChange: boolean;
    dirtyNodes: Array<VNode> | null;
    shouldUpdate: boolean;
    childShouldUpdate: boolean;
    task: any;
    context: any;
    isLazyComponent: boolean;
    lazyType: any;
    flags: number;
    clearChild: VNode | null;
    isCreated: boolean;
    oldHooks: Array<Hook<any, any>> | null;
    oldState: any;
    oldRef: RefType | ((handle: any) => void) | null;
    oldChild: VNode | null;
    promiseResolve: boolean;
    devProps: any;
    suspenseState: SuspenseState | null;
    path: string;
    toUpdateNodes: Set<VNode> | null;
    delegatedEvents: Set<string>;
    isStoreChange: boolean;
    observers: Set<Observer> | null;
    classComponentWillUnmount: ((vNode: VNode) => any) | null;
    src: Source | null;
    constructor(tag: VNodeTag, props: any, key: null | string, realNode: any);
}

type ProviderType<T> = {
    vtype: number;
    _context: ContextType<T>;
};
type ContextType<T> = {
    vtype: number;
    Consumer: ContextType<T> | null;
    Provider: ProviderType<T> | null;
    value: T;
};
type RefType = {
    current: any;
};
interface PromiseType<R> {
    then<U>(onFulfill: (value: R) => void | PromiseType<U> | U, onReject: (error: any) => void | PromiseType<U> | U): void | PromiseType<U>;
}
interface SuspenseState {
    promiseSet: Set<PromiseType<any>> | null;
    childStatus: string;
    oldChildStatus: string;
    didCapture: boolean;
    promiseResolved: boolean;
}
type Source = {
    fileName: string;
    lineNumber: number;
};
type Callback$1 = () => void;









/**
 * Component的api setState和forceUpdate在实例生成阶段实现
 */
export interface Component<P = KVObject, S = KVObject, SS = any, C = any> extends ComponentLifecycle<P, S, SS> {
    forceUpdate(callback?: () => void): void;
    render(): InulaNode;
}
export declare class Component<P = KVObject, S = KVObject, SS = any, C = any> {
    static contextType?: Context$1<any> | undefined;
    context: C | undefined;
    readonly props: Readonly<P>;
    state: Readonly<S>;
    refs: {
        [key: string]: Component<any>;
    };
    constructor(props: P, context?: C);
    setState<K extends keyof S>(state: ((prevState: Readonly<S>, props: Readonly<P>) => Pick<S, K> | S | null) | Pick<S, K> | S | null, callback?: Callback$1): void;
}
/**
 * 支持PureComponent
 */
export declare class PureComponent<P, S, SS, C = any> extends Component<P, S, SS> {
    constructor(props: P, context: C);
}

type DomAnimationEvent = AnimationEvent;
type DomClipboardEvent = ClipboardEvent;
type DomCompositionEvent = CompositionEvent;
type DomDragEvent = DragEvent;
type DomFocusEvent = FocusEvent;
type DomKeyboardEvent = KeyboardEvent;
type DomMouseEvent = MouseEvent;
type DomTouchEvent = TouchEvent;
type DomPointerEvent = PointerEvent;
type DomTransitionEvent = TransitionEvent;
type DomUIEvent = UIEvent;
type DomWheelEvent = WheelEvent;

type Event_DomAnimationEvent = DomAnimationEvent;
type Event_DomClipboardEvent = DomClipboardEvent;
type Event_DomCompositionEvent = DomCompositionEvent;
type Event_DomDragEvent = DomDragEvent;
type Event_DomFocusEvent = DomFocusEvent;
type Event_DomKeyboardEvent = DomKeyboardEvent;
type Event_DomMouseEvent = DomMouseEvent;
type Event_DomTouchEvent = DomTouchEvent;
type Event_DomPointerEvent = DomPointerEvent;
type Event_DomTransitionEvent = DomTransitionEvent;
type Event_DomUIEvent = DomUIEvent;
type Event_DomWheelEvent = DomWheelEvent;
declare namespace Event {
  export type { Event_DomAnimationEvent as DomAnimationEvent, Event_DomClipboardEvent as DomClipboardEvent, Event_DomCompositionEvent as DomCompositionEvent, Event_DomDragEvent as DomDragEvent, Event_DomFocusEvent as DomFocusEvent, Event_DomKeyboardEvent as DomKeyboardEvent, Event_DomMouseEvent as DomMouseEvent, Event_DomTouchEvent as DomTouchEvent, Event_DomPointerEvent as DomPointerEvent, Event_DomTransitionEvent as DomTransitionEvent, Event_DomUIEvent as DomUIEvent, Event_DomWheelEvent as DomWheelEvent };
}

type HTMLAttributeReferrerPolicy = '' | 'no-referrer' | 'no-referrer-when-downgrade' | 'origin' | 'origin-when-cross-origin' | 'same-origin' | 'strict-origin' | 'strict-origin-when-cross-origin' | 'unsafe-url';
type HTMLAttributeAnchorTarget = '_self' | '_blank' | '_parent' | '_top' | (string & KVObject);
type AriaRole = 'article' | 'cell' | 'columnheader' | 'definition' | 'directory' | 'document' | 'feed' | 'figure' | 'group' | 'heading' | 'img' | 'list' | 'listitem' | 'math' | 'none' | 'note' | 'presentation' | 'row' | 'rowgroup' | 'rowheader' | 'separator' | 'term' | 'alert' | 'alertdialog' | 'button' | 'checkbox' | 'dialog' | 'gridcell' | 'link' | 'log' | 'marquee' | 'menuitem' | 'menuitemcheckbox' | 'menuitemradio' | 'option' | 'progressbar' | 'radio' | 'scrollbar' | 'searchbox' | 'slider' | 'spinbutton' | 'status' | 'switch' | 'tab' | 'tabpanel' | 'textbox' | 'timer' | 'tooltip' | 'treeitem' | 'combobox' | 'grid' | 'listbox' | 'menu' | 'menubar' | 'radiogroup' | 'tablist' | 'tree' | 'treegrid' | 'application' | 'banner' | 'complementary' | 'contentinfo' | 'form' | 'main' | 'navigation' | 'region' | 'search' | 'status' | 'timer' | 'alertdialog' | 'dialog' | 'toolbar' | 'table' | (string & KVObject);
interface InulaSVGProps<T> extends SVGAttributes<T>, ClassAttributes<T> {
}
interface AudioHTMLAttributes<T> extends MediaHTMLAttributes<T> {
}
interface AnchorHTMLAttributes<T> extends HTMLAttributes<T> {
    download?: any;
    href?: string;
    hrefLang?: string;
    target?: HTMLAttributeAnchorTarget;
    media?: string;
    ping?: string;
    rel?: string;
    type?: string;
    referrerPolicy?: HTMLAttributeReferrerPolicy;
}
interface MediaHTMLAttributes<T> extends HTMLAttributes<T> {
    autoPlay?: boolean;
    controls?: boolean;
    controlsList?: string;
    loop?: boolean;
    muted?: boolean;
    src?: string;
    crossOrigin?: string;
    mediaGroup?: string;
    preload?: string;
    playsInline?: boolean;
}
interface MetaHTMLAttributes<T> extends HTMLAttributes<T> {
    charSet?: string;
    content?: string;
    httpEquiv?: string;
    name?: string;
    media?: string;
}
interface MeterHTMLAttributes<T> extends HTMLAttributes<T> {
    value?: string | ReadonlyArray<string> | number;
    min?: number | string;
    max?: number | string;
    low?: number;
    high?: number;
    optimum?: number;
    form?: string;
}
interface QuoteHTMLAttributes<T> extends HTMLAttributes<T> {
    cite?: string;
}
interface ObjectHTMLAttributes<T> extends HTMLAttributes<T> {
    classID?: string;
    data?: string;
    type?: string;
    width?: number | string;
    height?: number | string;
    form?: string;
    name?: string;
    useMap?: string;
    wmode?: string;
}
interface OlHTMLAttributes<T> extends HTMLAttributes<T> {
    reversed?: boolean;
    start?: number;
    type?: '1' | 'a' | 'A' | 'i' | 'I';
}
interface OptgroupHTMLAttributes<T> extends HTMLAttributes<T> {
    disabled?: boolean;
    label?: string;
}
interface OptionHTMLAttributes<T> extends HTMLAttributes<T> {
    disabled?: boolean;
    label?: string;
    selected?: boolean;
    value?: string | ReadonlyArray<string> | number;
}
interface OutputHTMLAttributes<T> extends HTMLAttributes<T> {
    form?: string;
    htmlFor?: string;
    name?: string;
}
interface ParamHTMLAttributes<T> extends HTMLAttributes<T> {
    name?: string;
    value?: string | ReadonlyArray<string> | number;
}
interface ProgressHTMLAttributes<T> extends HTMLAttributes<T> {
    max?: number | string;
    value?: string | ReadonlyArray<string> | number;
}
interface SlotHTMLAttributes<T> extends HTMLAttributes<T> {
    name?: string;
}
interface ScriptHTMLAttributes<T> extends HTMLAttributes<T> {
    async?: boolean;
    defer?: boolean;
    src?: string;
    type?: string;
    integrity?: string;
    nonce?: string;
    crossOrigin?: string;
    noModule?: boolean;
    referrerPolicy?: HTMLAttributeReferrerPolicy;
    /** @deprecated */
    charSet?: string;
}
interface SelectHTMLAttributes<T> extends HTMLAttributes<T> {
    autoComplete?: string;
    name?: string;
    disabled?: boolean;
    required?: boolean;
    multiple?: boolean;
    size?: number;
    form?: string;
    value?: string | ReadonlyArray<string> | number;
    autoFocus?: boolean;
    onChange?: InulaChangeEventHandler<T>;
}
interface SourceHTMLAttributes<T> extends HTMLAttributes<T> {
    height?: number | string;
    media?: string;
    sizes?: string;
    src?: string;
    srcSet?: string;
    type?: string;
    width?: number | string;
}
interface StyleHTMLAttributes<T> extends HTMLAttributes<T> {
    media?: string;
    nonce?: string;
    scoped?: boolean;
    type?: string;
}
interface TableHTMLAttributes<T> extends HTMLAttributes<T> {
    cellPadding?: number | string;
    cellSpacing?: number | string;
    summary?: string;
    width?: number | string;
}
interface TextareaHTMLAttributes<T> extends HTMLAttributes<T> {
    autoComplete?: string;
    name?: string;
    placeholder?: string;
    disabled?: boolean;
    readOnly?: boolean;
    required?: boolean;
    cols?: number;
    rows?: number;
    wrap?: string;
    autoFocus?: boolean;
    maxLength?: number;
    minLength?: number;
    dirName?: string;
    form?: string;
    value?: string | ReadonlyArray<string> | number;
    onChange?: InulaChangeEventHandler<T>;
}
interface ThHTMLAttributes<T> extends HTMLAttributes<T> {
    align?: 'left' | 'center' | 'right' | 'justify' | 'char';
    colSpan?: number;
    headers?: string;
    rowSpan?: number;
    scope?: string;
    abbr?: string;
}
interface TimeHTMLAttributes<T> extends HTMLAttributes<T> {
    dateTime?: string;
}
interface TrackHTMLAttributes<T> extends HTMLAttributes<T> {
    default?: boolean;
    kind?: string;
    label?: string;
    src?: string;
    srcLang?: string;
}
interface VideoHTMLAttributes<T> extends MediaHTMLAttributes<T> {
    height?: number | string;
    playsInline?: boolean;
    poster?: string;
    width?: number | string;
    disablePictureInPicture?: boolean;
    disableRemotePlayback?: boolean;
}
interface TdHTMLAttributes<T> extends HTMLAttributes<T> {
    align?: 'left' | 'center' | 'right' | 'justify' | 'char';
    valign?: 'top' | 'middle' | 'bottom' | 'baseline';
    colSpan?: number;
    rowSpan?: number;
    headers?: string;
    scope?: string;
    height?: number | string;
    width?: number | string;
    abbr?: string;
}
interface SVGAttributes<T> extends AriaAttributes, DOMAttributes<T> {
    id?: string;
    lang?: string;
    tabIndex?: number;
    role?: AriaRole;
    className?: string;
    style?: InulaCSSProperties;
    height?: number | string;
    width?: number | string;
    x?: number | string;
    y?: number | string;
    color?: string;
    fill?: string;
    fillOpacity?: number | string;
    fillRule?: 'nonzero' | 'evenodd' | 'inherit';
    stroke?: string;
    strokeDasharray?: string | number;
    strokeDashoffset?: string | number;
    strokeLinecap?: 'butt' | 'round' | 'square' | 'inherit';
    strokeLinejoin?: 'miter' | 'round' | 'bevel' | 'inherit';
    strokeMiterlimit?: number | string;
    strokeOpacity?: number | string;
    strokeWidth?: number | string;
    transform?: string;
    fontFamily?: string;
    fontSize?: number | string;
    textAnchor?: string;
    gradientTransform?: string;
    gradientUnits?: string;
    clipPath?: string;
    clipRule?: number | string;
    cursor?: number | string;
    display?: number | string;
    filter?: string;
    mask?: string;
    opacity?: number | string;
    pointerEvents?: number | string;
    visibility?: number | string;
    accentHeight?: number | string;
    accumulate?: 'none' | 'sum';
    additive?: 'replace' | 'sum';
    alignmentBaseline?: 'auto' | 'baseline' | 'before-edge' | 'text-before-edge' | 'middle' | 'central' | 'after-edge' | 'text-after-edge' | 'ideographic' | 'alphabetic' | 'hanging' | 'mathematical' | 'inherit';
    allowReorder?: 'no' | 'yes';
    alphabetic?: number | string;
    amplitude?: number | string;
    arabicForm?: 'initial' | 'medial' | 'terminal' | 'isolated';
    ascent?: number | string;
    attributeName?: string;
    attributeType?: string;
    autoReverse?: InulaBoolean;
    azimuth?: number | string;
    baseFrequency?: number | string;
    baselineShift?: number | string;
    baseProfile?: number | string;
    bbox?: number | string;
    begin?: number | string;
    bias?: number | string;
    by?: number | string;
    calcMode?: number | string;
    capHeight?: number | string;
    clip?: number | string;
    clipPathUnits?: number | string;
    colorInterpolation?: number | string;
    colorInterpolationFilters?: 'auto' | 'sRGB' | 'linearRGB' | 'inherit';
    colorProfile?: number | string;
    colorRendering?: number | string;
    contentScriptType?: number | string;
    contentStyleType?: number | string;
    cx?: number | string | undefined;
    cy?: number | string | undefined;
    d?: string | undefined;
    diffuseConstant?: number | string;
    direction?: number | string;
    divisor?: number | string;
    dominantBaseline?: number | string;
    dur?: number | string;
    dx?: number | string;
    dy?: number | string;
    edgeMode?: number | string;
    elevation?: number | string;
    enableBackground?: number | string;
    end?: number | string;
    exponent?: number | string;
    externalResourcesRequired?: InulaBoolean;
    filterRes?: number | string;
    filterUnits?: number | string;
    floodColor?: number | string;
    floodOpacity?: number | string;
    focusable?: InulaBoolean | 'auto';
    fontSizeAdjust?: number | string;
    fontStretch?: number | string;
    fontStyle?: number | string;
    fontVariant?: number | string;
    fontWeight?: number | string;
    format?: number | string;
    from?: number | string;
    g1?: number | string;
    g2?: number | string;
    glyphName?: number | string;
    glyphOrientationHorizontal?: number | string;
    glyphOrientationVertical?: number | string;
    fx?: number | string;
    fy?: number | string;
    glyphRef?: number | string;
    hanging?: number | string;
    horizAdvX?: number | string;
    horizOriginX?: number | string;
    href?: string;
    ideographic?: number | string;
    imageRendering?: number | string;
    in2?: number | string;
    in?: string;
    intercept?: number | string;
    k?: number | string;
    k1?: number | string;
    k2?: number | string;
    k3?: number | string;
    k4?: number | string;
    kernelMatrix?: number | string;
    kernelUnitLength?: number | string;
    kerning?: number | string;
    keyPoints?: number | string;
    keySplines?: number | string;
    keyTimes?: number | string;
    lengthAdjust?: number | string;
    letterSpacing?: number | string;
    lightingColor?: number | string;
    limitingConeAngle?: number | string;
    local?: number | string;
    markerEnd?: string;
    markerHeight?: number | string;
    markerMid?: string;
    markerStart?: string;
    markerUnits?: number | string;
    markerWidth?: number | string;
    maskContentUnits?: number | string;
    maskUnits?: number | string;
    mathematical?: number | string;
    mode?: number | string;
    numOctaves?: number | string;
    offset?: number | string;
    operator?: number | string;
    order?: number | string;
    orient?: number | string;
    orientation?: number | string;
    origin?: number | string;
    overflow?: number | string;
    overlinePosition?: number | string;
    overlineThickness?: number | string;
    paintOrder?: number | string;
    panose1?: number | string;
    path?: string;
    pathLength?: number | string;
    patternContentUnits?: string;
    patternTransform?: number | string;
    patternUnits?: string;
    points?: string;
    pointsAtX?: number | string;
    pointsAtY?: number | string;
    pointsAtZ?: number | string;
    preserveAlpha?: InulaBoolean;
    preserveAspectRatio?: string;
    primitiveUnits?: number | string;
    r?: number | string;
    radius?: number | string;
    refX?: number | string;
    refY?: number | string;
    renderingIntent?: number | string;
    repeatCount?: number | string;
    repeatDur?: number | string;
    requiredExtensions?: number | string;
    requiredFeatures?: number | string;
    rx?: number | string;
    ry?: number | string;
    restart?: number | string;
    result?: string;
    rotate?: number | string;
    scale?: number | string;
    seed?: number | string;
    shapeRendering?: number | string;
    specularConstant?: number | string;
    specularExponent?: number | string;
    slope?: number | string;
    spacing?: number | string;
    speed?: number | string;
    spreadMethod?: string;
    startOffset?: number | string;
    stdDeviation?: number | string;
    stopColor?: string;
    stopOpacity?: number | string;
    stemh?: number | string;
    stemv?: number | string;
    stitchTiles?: number | string;
    strikethroughPosition?: number | string;
    strikethroughThickness?: number | string;
    string?: number | string;
    surfaceScale?: number | string;
    systemLanguage?: number | string;
    targetX?: number | string;
    targetY?: number | string;
    tableValues?: number | string;
    textDecoration?: number | string;
    textLength?: number | string;
    textRendering?: number | string;
    to?: number | string;
    underlinePosition?: number | string;
    underlineThickness?: number | string;
    u1?: number | string;
    u2?: number | string;
    unicode?: number | string;
    unicodeBidi?: number | string;
    unicodeRange?: number | string;
    unitsPerEm?: number | string;
    vertOriginX?: number | string;
    vertOriginY?: number | string;
    vAlphabetic?: number | string;
    values?: string;
    vectorEffect?: number | string;
    version?: string;
    vertAdvY?: number | string;
    vHanging?: number | string;
    vIdeographic?: number | string;
    viewBox?: string;
    viewTarget?: number | string;
    vMathematical?: number | string;
    widths?: number | string;
    wordSpacing?: number | string;
    writingMode?: number | string;
    x1?: number | string;
    x2?: number | string;
    xChannelSelector?: string;
    xHeight?: number | string;
    xlinkActuate?: string;
    xlinkArcrole?: string;
    xlinkHref?: string;
    xlinkRole?: string;
    xlinkShow?: string;
    xlinkTitle?: string;
    xlinkType?: string;
    xmlBase?: string;
    xmlLang?: string;
    xmlns?: string;
    xmlnsXlink?: string;
    xmlSpace?: string;
    y1?: number | string;
    y2?: number | string;
    yChannelSelector?: string;
    z?: number | string;
    zoomAndPan?: string;
}
interface WebViewHTMLAttributes<T> extends HTMLAttributes<T> {
    src?: string;
    httpreferrer?: string;
    useragent?: string;
    allowFullScreen?: boolean;
    allowpopups?: boolean;
    autoFocus?: boolean;
    autosize?: boolean;
    blinkfeatures?: string;
    disableblinkfeatures?: string;
    disableguestresize?: boolean;
    disablewebsecurity?: boolean;
    guestinstance?: string;
    nodeintegration?: boolean;
    partition?: string;
    plugins?: boolean;
    preload?: string;
    webpreferences?: string;
}
interface AreaHTMLAttributes<T> extends HTMLAttributes<T> {
    alt?: string;
    coords?: string;
    download?: any;
    href?: string;
    hrefLang?: string;
    media?: string;
    rel?: string;
    shape?: string;
    target?: string;
    referrerPolicy?: HTMLAttributeReferrerPolicy;
}
interface BaseHTMLAttributes<T> extends HTMLAttributes<T> {
    href?: string;
    target?: string;
}
interface BlockquoteHTMLAttributes<T> extends HTMLAttributes<T> {
    cite?: string;
}
interface ButtonHTMLAttributes<T> extends HTMLAttributes<T> {
    autoFocus?: boolean;
    disabled?: boolean;
    name?: string;
    type?: 'submit' | 'reset' | 'button';
    value?: string | ReadonlyArray<string> | number;
    form?: string;
    formAction?: string;
    formEncType?: string;
    formMethod?: string;
    formNoValidate?: boolean;
    formTarget?: string;
}
interface CanvasHTMLAttributes<T> extends HTMLAttributes<T> {
    height?: number | string;
    width?: number | string;
}
interface ColHTMLAttributes<T> extends HTMLAttributes<T> {
    span?: number;
    width?: number | string;
}
interface ColgroupHTMLAttributes<T> extends HTMLAttributes<T> {
    span?: number;
}
interface DataHTMLAttributes<T> extends HTMLAttributes<T> {
    value?: string | ReadonlyArray<string> | number;
}
interface DetailsHTMLAttributes<T> extends HTMLAttributes<T> {
    open?: boolean;
    onToggle?: InulaEventHandler<T>;
}
interface DelHTMLAttributes<T> extends HTMLAttributes<T> {
    cite?: string;
    dateTime?: string;
}
interface DialogHTMLAttributes<T> extends HTMLAttributes<T> {
    open?: boolean;
}
interface EmbedHTMLAttributes<T> extends HTMLAttributes<T> {
    height?: number | string;
    src?: string;
    type?: string;
    width?: number | string;
}
interface FieldsetHTMLAttributes<T> extends HTMLAttributes<T> {
    disabled?: boolean;
    form?: string;
    name?: string;
}
interface FormHTMLAttributes<T> extends HTMLAttributes<T> {
    action?: string;
    method?: string;
    target?: string;
    acceptCharset?: string;
    encType?: string;
    autoComplete?: string;
    name?: string;
    noValidate?: boolean;
}
interface HtmlHTMLAttributes<T> extends HTMLAttributes<T> {
    manifest?: string;
}
interface IframeHTMLAttributes<T> extends HTMLAttributes<T> {
    src?: string;
    srcDoc?: string;
    sandbox?: string;
    allow?: string;
    allowFullScreen?: boolean;
    allowTransparency?: boolean;
    referrerPolicy?: HTMLAttributeReferrerPolicy;
    width?: number | string;
    height?: number | string;
    loading?: 'eager' | 'lazy';
    name?: string;
    /** @deprecated */
    frameBorder?: number | string;
    /** @deprecated */
    marginHeight?: number;
    /** @deprecated */
    marginWidth?: number;
    /** @deprecated */
    scrolling?: string;
    seamless?: boolean;
}
interface ImgHTMLAttributes<T> extends HTMLAttributes<T> {
    alt?: string;
    src?: string;
    srcSet?: string;
    sizes?: string;
    crossOrigin?: 'anonymous' | 'use-credentials' | '';
    referrerPolicy?: HTMLAttributeReferrerPolicy;
    height?: number | string;
    width?: number | string;
    loading?: 'eager' | 'lazy';
    decoding?: 'async' | 'auto' | 'sync';
    useMap?: string;
}
interface InsHTMLAttributes<T> extends HTMLAttributes<T> {
    cite?: string;
    dateTime?: string;
}
type HTMLInputTypeAttribute = 'button' | 'checkbox' | 'color' | 'date' | 'datetime-local' | 'email' | 'file' | 'hidden' | 'image' | 'month' | 'number' | 'password' | 'radio' | 'range' | 'reset' | 'search' | 'submit' | 'tel' | 'text' | 'time' | 'url' | 'week' | (string & KVObject);
interface InputHTMLAttributes<T> extends HTMLAttributes<T> {
    accept?: string;
    alt?: string;
    autoComplete?: string;
    autoFocus?: boolean;
    capture?: boolean | 'user' | 'environment';
    checked?: boolean;
    crossOrigin?: string;
    disabled?: boolean;
    enterKeyHint?: 'enter' | 'done' | 'go' | 'next' | 'previous' | 'search' | 'send';
    form?: string;
    formAction?: string;
    formEncType?: string;
    formMethod?: string;
    formNoValidate?: boolean;
    formTarget?: string;
    height?: number | string;
    list?: string;
    max?: number | string;
    maxLength?: number;
    min?: number | string;
    minLength?: number;
    multiple?: boolean;
    name?: string;
    pattern?: string;
    placeholder?: string;
    readOnly?: boolean;
    required?: boolean;
    size?: number;
    src?: string;
    step?: number | string;
    type?: HTMLInputTypeAttribute;
    value?: string | ReadonlyArray<string> | number;
    width?: number | string;
    onChange?: InulaChangeEventHandler<T>;
}
interface KeygenHTMLAttributes<T> extends HTMLAttributes<T> {
    autoFocus?: boolean;
    challenge?: string;
    disabled?: boolean;
    form?: string;
    keyType?: string;
    keyParams?: string;
    name?: string;
}
interface LabelHTMLAttributes<T> extends HTMLAttributes<T> {
    form?: string;
    htmlFor?: string;
}
interface LiHTMLAttributes<T> extends HTMLAttributes<T> {
    value?: string | ReadonlyArray<string> | number;
}
interface LinkHTMLAttributes<T> extends HTMLAttributes<T> {
    href?: string;
    rel?: string;
    type?: string;
    as?: string;
    crossOrigin?: string;
    integrity?: string;
    referrerPolicy?: HTMLAttributeReferrerPolicy;
    hrefLang?: string;
    charSet?: string;
    media?: string;
    sizes?: string;
    imageSrcSet?: string;
}
interface MapHTMLAttributes<T> extends HTMLAttributes<T> {
    name?: string;
}
interface MenuHTMLAttributes<T> extends HTMLAttributes<T> {
    type?: string;
}
type InulaRole = 'application' | 'alert' | 'alertdialog' | 'article' | 'banner' | 'button' | 'cell' | 'checkbox' | 'columnheader' | 'combobox' | 'complementary' | 'contentinfo' | 'definition' | 'dialog' | 'directory' | 'document' | 'feed' | 'figure' | 'form' | 'grid' | 'gridcell' | 'group' | 'heading' | 'img' | 'link' | 'list' | 'listbox' | 'listitem' | 'log' | 'main' | 'marquee' | 'math' | 'menu' | 'menubar' | 'menuitem' | 'menuitemcheckbox' | 'menuitemradio' | 'navigation' | 'none' | 'note' | 'option' | 'presentation' | 'progressbar' | 'radio' | 'radiogroup' | 'region' | 'row' | 'rowgroup' | 'rowheader' | 'scrollbar' | 'search' | 'searchbox' | 'separator' | 'slider' | 'spinbutton' | 'status' | 'switch' | 'tab' | 'table' | 'tablist' | 'tabpanel' | 'term' | 'textbox' | 'timer' | 'toolbar' | 'tooltip' | 'tree' | 'treegrid' | 'treeitem' | (string & KVObject);
interface AriaAttributes {
    'aria-activedescendant'?: string;
    'aria-atomic'?: InulaBoolean;
    'aria-autocomplete'?: 'none' | 'inline' | 'list' | 'both';
    'aria-current'?: boolean | 'false' | 'true' | 'page' | 'step' | 'location' | 'date' | 'time';
    'aria-haspopup'?: boolean | 'false' | 'true' | 'menu' | 'listbox' | 'tree' | 'grid' | 'dialog';
    'aria-level'?: number;
    'aria-modal'?: InulaBoolean;
    'aria-multiline'?: InulaBoolean;
    'aria-multiselectable'?: InulaBoolean;
    'aria-orientation'?: 'horizontal' | 'vertical';
    'aria-placeholder'?: string;
    'aria-roledescription'?: string;
    'aria-busy'?: InulaBoolean;
    'aria-checked'?: boolean | 'false' | 'mixed' | 'true';
    'aria-disabled'?: InulaBoolean;
    'aria-expanded'?: InulaBoolean;
    'aria-hidden'?: InulaBoolean;
    'aria-invalid'?: boolean | 'false' | 'true' | 'grammar' | 'spelling';
    'aria-pressed'?: boolean | 'false' | 'mixed' | 'true';
    'aria-readonly'?: InulaBoolean;
    'aria-required'?: InulaBoolean;
    'aria-selected'?: InulaBoolean;
    'aria-controls'?: string;
    'aria-describedby'?: string;
    'aria-details'?: string;
    'aria-errormessage'?: string;
    'aria-flowto'?: string;
    'aria-labelledby'?: string;
    'aria-owns'?: string;
    'aria-live'?: 'off' | 'assertive' | 'polite';
    'aria-relevant'?: 'additions' | 'additions removals' | 'additions text' | 'all' | 'removals' | 'removals additions' | 'removals text' | 'text' | 'text additions' | 'text removals';
    /** @deprecated in ARIA 1.1 */
    'aria-dropeffect'?: 'none' | 'copy' | 'execute' | 'link' | 'move' | 'popup';
    /** @deprecated in ARIA 1.1 */
    'aria-grabbed'?: InulaBoolean;
    'aria-valuemax'?: number;
    'aria-valuemin'?: number;
    'aria-valuenow'?: number;
    'aria-valuetext'?: string;
    'aria-colcount'?: number;
    'aria-colindex'?: number;
    'aria-colspan'?: number;
    'aria-keyshortcuts'?: string;
    'aria-label'?: string;
    'aria-posinset'?: number;
    'aria-rowcount'?: number;
    'aria-rowindex'?: number;
    'aria-rowspan'?: number;
    'aria-setsize'?: number;
    'aria-sort'?: 'none' | 'ascending' | 'descending' | 'other';
}
interface HTMLAttributes<T> extends AriaAttributes, DOMAttributes<T> {
    id?: string;
    className?: string;
    style?: InulaCSSProperties;
    accessKey?: string;
    contentEditable?: InulaBoolean | 'inherit';
    contextMenu?: string;
    dir?: string;
    draggable?: InulaBoolean;
    hidden?: boolean;
    lang?: string;
    spellCheck?: InulaBoolean;
    tabIndex?: number;
    title?: string;
    translate?: 'yes' | 'no';
    radioGroup?: string;
    role?: InulaRole;
    about?: string;
    datatype?: string;
    inlist?: any;
    prefix?: string;
    property?: string;
    resource?: string;
    typeof?: string;
    vocab?: string;
    autoCapitalize?: string;
    autoCorrect?: string;
    autoSave?: string;
    color?: string;
    itemProp?: string;
    itemScope?: boolean;
    itemType?: string;
    itemID?: string;
    itemRef?: string;
    results?: number;
    security?: string;
    unselectable?: 'on' | 'off';
    inputMode?: 'none' | 'text' | 'tel' | 'url' | 'email' | 'numeric' | 'decimal' | 'search';
    is?: string;
    defaultChecked?: boolean;
    defaultValue?: string | number | ReadonlyArray<string>;
    suppressContentEditableWarning?: boolean;
    suppressHydrationWarning?: boolean;
    placeholder?: string;
}
interface DOMAttributes<T> {
    children?: InulaNode;
    dangerouslySetInnerHTML?: {
        __html: string;
    };
    onCopy?: InulaClipboardEventHandler<T>;
    onCopyCapture?: InulaClipboardEventHandler<T>;
    onCut?: InulaClipboardEventHandler<T>;
    onCutCapture?: InulaClipboardEventHandler<T>;
    onPaste?: InulaClipboardEventHandler<T>;
    onPasteCapture?: InulaClipboardEventHandler<T>;
    onCompositionEnd?: InulaCompositionEventHandler<T>;
    onCompositionEndCapture?: InulaCompositionEventHandler<T>;
    onCompositionStart?: InulaCompositionEventHandler<T>;
    onCompositionStartCapture?: InulaCompositionEventHandler<T>;
    onCompositionUpdate?: InulaCompositionEventHandler<T>;
    onCompositionUpdateCapture?: InulaCompositionEventHandler<T>;
    onFocus?: InulaFocusEventHandler<T>;
    onFocusCapture?: InulaFocusEventHandler<T>;
    onBlur?: InulaFocusEventHandler<T>;
    onBlurCapture?: InulaFocusEventHandler<T>;
    onChange?: InulaFormEventHandler<T>;
    onChangeCapture?: InulaFormEventHandler<T>;
    onBeforeInput?: InulaFormEventHandler<T>;
    onBeforeInputCapture?: InulaFormEventHandler<T>;
    onInput?: InulaFormEventHandler<T>;
    onInputCapture?: InulaFormEventHandler<T>;
    onReset?: InulaFormEventHandler<T>;
    onResetCapture?: InulaFormEventHandler<T>;
    onSubmit?: InulaFormEventHandler<T>;
    onSubmitCapture?: InulaFormEventHandler<T>;
    onInvalid?: InulaFormEventHandler<T>;
    onInvalidCapture?: InulaFormEventHandler<T>;
    onLoad?: InulaEventHandler<T>;
    onLoadCapture?: InulaEventHandler<T>;
    onError?: InulaEventHandler<T>;
    onErrorCapture?: InulaEventHandler<T>;
    onKeyDown?: InulaKeyboardEventHandler<T>;
    onKeyDownCapture?: InulaKeyboardEventHandler<T>;
    /** @deprecated */
    onKeyPress?: InulaKeyboardEventHandler<T>;
    /** @deprecated */
    onKeyPressCapture?: InulaKeyboardEventHandler<T>;
    onKeyUp?: InulaKeyboardEventHandler<T>;
    onKeyUpCapture?: InulaKeyboardEventHandler<T>;
    onAbort?: InulaEventHandler<T>;
    onAbortCapture?: InulaEventHandler<T>;
    onCanPlay?: InulaEventHandler<T>;
    onCanPlayCapture?: InulaEventHandler<T>;
    onCanPlayThrough?: InulaEventHandler<T>;
    onCanPlayThroughCapture?: InulaEventHandler<T>;
    onDurationChange?: InulaEventHandler<T>;
    onDurationChangeCapture?: InulaEventHandler<T>;
    onEmptied?: InulaEventHandler<T>;
    onEmptiedCapture?: InulaEventHandler<T>;
    onEncrypted?: InulaEventHandler<T>;
    onEncryptedCapture?: InulaEventHandler<T>;
    onEnded?: InulaEventHandler<T>;
    onEndedCapture?: InulaEventHandler<T>;
    onLoadedData?: InulaEventHandler<T>;
    onLoadedDataCapture?: InulaEventHandler<T>;
    onLoadedMetadata?: InulaEventHandler<T>;
    onLoadedMetadataCapture?: InulaEventHandler<T>;
    onLoadStart?: InulaEventHandler<T>;
    onLoadStartCapture?: InulaEventHandler<T>;
    onPause?: InulaEventHandler<T>;
    onPauseCapture?: InulaEventHandler<T>;
    onPlay?: InulaEventHandler<T>;
    onPlayCapture?: InulaEventHandler<T>;
    onPlaying?: InulaEventHandler<T>;
    onPlayingCapture?: InulaEventHandler<T>;
    onProgress?: InulaEventHandler<T>;
    onProgressCapture?: InulaEventHandler<T>;
    onRateChange?: InulaEventHandler<T>;
    onRateChangeCapture?: InulaEventHandler<T>;
    onSeeked?: InulaEventHandler<T>;
    onSeekedCapture?: InulaEventHandler<T>;
    onSeeking?: InulaEventHandler<T>;
    onSeekingCapture?: InulaEventHandler<T>;
    onStalled?: InulaEventHandler<T>;
    onStalledCapture?: InulaEventHandler<T>;
    onSuspend?: InulaEventHandler<T>;
    onSuspendCapture?: InulaEventHandler<T>;
    onTimeUpdate?: InulaEventHandler<T>;
    onTimeUpdateCapture?: InulaEventHandler<T>;
    onVolumeChange?: InulaEventHandler<T>;
    onVolumeChangeCapture?: InulaEventHandler<T>;
    onWaiting?: InulaEventHandler<T>;
    onWaitingCapture?: InulaEventHandler<T>;
    onAuxClick?: InulaMouseEventHandler<T>;
    onAuxClickCapture?: InulaMouseEventHandler<T>;
    onClick?: InulaMouseEventHandler<T>;
    onClickCapture?: InulaMouseEventHandler<T>;
    onContextMenu?: InulaMouseEventHandler<T>;
    onContextMenuCapture?: InulaMouseEventHandler<T>;
    onDoubleClick?: InulaMouseEventHandler<T>;
    onDoubleClickCapture?: InulaMouseEventHandler<T>;
    onDrag?: InulaDragEventHandler<T>;
    onDragCapture?: InulaDragEventHandler<T>;
    onDragEnd?: InulaDragEventHandler<T>;
    onDragEndCapture?: InulaDragEventHandler<T>;
    onDragEnter?: InulaDragEventHandler<T>;
    onDragEnterCapture?: InulaDragEventHandler<T>;
    onDragExit?: InulaDragEventHandler<T>;
    onDragExitCapture?: InulaDragEventHandler<T>;
    onDragLeave?: InulaDragEventHandler<T>;
    onDragLeaveCapture?: InulaDragEventHandler<T>;
    onDragOver?: InulaDragEventHandler<T>;
    onDragOverCapture?: InulaDragEventHandler<T>;
    onDragStart?: InulaDragEventHandler<T>;
    onDragStartCapture?: InulaDragEventHandler<T>;
    onDrop?: InulaDragEventHandler<T>;
    onDropCapture?: InulaDragEventHandler<T>;
    onMouseDown?: InulaMouseEventHandler<T>;
    onMouseDownCapture?: InulaMouseEventHandler<T>;
    onMouseEnter?: InulaMouseEventHandler<T>;
    onMouseLeave?: InulaMouseEventHandler<T>;
    onMouseMove?: InulaMouseEventHandler<T>;
    onMouseMoveCapture?: InulaMouseEventHandler<T>;
    onMouseOut?: InulaMouseEventHandler<T>;
    onMouseOutCapture?: InulaMouseEventHandler<T>;
    onMouseOver?: InulaMouseEventHandler<T>;
    onMouseOverCapture?: InulaMouseEventHandler<T>;
    onMouseUp?: InulaMouseEventHandler<T>;
    onMouseUpCapture?: InulaMouseEventHandler<T>;
    onSelect?: InulaEventHandler<T>;
    onSelectCapture?: InulaEventHandler<T>;
    onTouchCancel?: InulaTouchEventHandler<T>;
    onTouchCancelCapture?: InulaTouchEventHandler<T>;
    onTouchEnd?: InulaTouchEventHandler<T>;
    onTouchEndCapture?: InulaTouchEventHandler<T>;
    onTouchMove?: InulaTouchEventHandler<T>;
    onTouchMoveCapture?: InulaTouchEventHandler<T>;
    onTouchStart?: InulaTouchEventHandler<T>;
    onTouchStartCapture?: InulaTouchEventHandler<T>;
    onPointerDown?: InulaPointerEventHandler<T>;
    onPointerDownCapture?: InulaPointerEventHandler<T>;
    onPointerMove?: InulaPointerEventHandler<T>;
    onPointerMoveCapture?: InulaPointerEventHandler<T>;
    onPointerUp?: InulaPointerEventHandler<T>;
    onPointerUpCapture?: InulaPointerEventHandler<T>;
    onPointerCancel?: InulaPointerEventHandler<T>;
    onPointerCancelCapture?: InulaPointerEventHandler<T>;
    onPointerEnter?: InulaPointerEventHandler<T>;
    onPointerEnterCapture?: InulaPointerEventHandler<T>;
    onPointerLeave?: InulaPointerEventHandler<T>;
    onPointerLeaveCapture?: InulaPointerEventHandler<T>;
    onPointerOver?: InulaPointerEventHandler<T>;
    onPointerOverCapture?: InulaPointerEventHandler<T>;
    onPointerOut?: InulaPointerEventHandler<T>;
    onPointerOutCapture?: InulaPointerEventHandler<T>;
    onGotPointerCapture?: InulaPointerEventHandler<T>;
    onGotPointerCaptureCapture?: InulaPointerEventHandler<T>;
    onLostPointerCapture?: InulaPointerEventHandler<T>;
    onLostPointerCaptureCapture?: InulaPointerEventHandler<T>;
    onScroll?: InulaUIEventHandler<T>;
    onScrollCapture?: InulaUIEventHandler<T>;
    onWheel?: InulaWheelEventHandler<T>;
    onWheelCapture?: InulaWheelEventHandler<T>;
    onAnimationStart?: InulaAnimationEventHandler<T>;
    onAnimationStartCapture?: InulaAnimationEventHandler<T>;
    onAnimationEnd?: InulaAnimationEventHandler<T>;
    onAnimationEndCapture?: InulaAnimationEventHandler<T>;
    onAnimationIteration?: InulaAnimationEventHandler<T>;
    onAnimationIterationCapture?: InulaAnimationEventHandler<T>;
    onTransitionEnd?: InulaTransitionEventHandler<T>;
    onTransitionEndCapture?: InulaTransitionEventHandler<T>;
}
interface AllHTMLAttributes<T> extends HTMLAttributes<T> {
    accept?: string;
    acceptCharset?: string;
    action?: string;
    allowFullScreen?: boolean;
    allowTransparency?: boolean;
    alt?: string;
    as?: string;
    async?: boolean;
    autoFocus?: boolean;
    autoComplete?: string;
    autoPlay?: boolean;
    capture?: boolean | 'user' | 'environment';
    cellPadding?: number | string;
    cellSpacing?: number | string;
    charSet?: string;
    challenge?: string;
    checked?: boolean;
    cite?: string;
    classID?: string;
    colSpan?: number;
    cols?: number;
    content?: string;
    controls?: boolean;
    coords?: string;
    crossOrigin?: string;
    data?: string;
    dateTime?: string;
    default?: boolean;
    defer?: boolean;
    disabled?: boolean;
    download?: any;
    encType?: string;
    form?: string;
    formAction?: string;
    formEncType?: string;
    formMethod?: string;
    formNoValidate?: boolean;
    formTarget?: string;
    frameBorder?: number | string;
    headers?: string;
    height?: number | string;
    high?: number;
    href?: string;
    hrefLang?: string;
    htmlFor?: string;
    httpEquiv?: string;
    integrity?: string;
    keyParams?: string;
    keyType?: string;
    kind?: string;
    label?: string;
    list?: string;
    loop?: boolean;
    low?: number;
    manifest?: string;
    marginHeight?: number;
    marginWidth?: number;
    max?: number | string;
    maxLength?: number;
    media?: string;
    mediaGroup?: string;
    method?: string;
    min?: number | string;
    minLength?: number;
    multiple?: boolean;
    muted?: boolean;
    name?: string;
    nonce?: string;
    noValidate?: boolean;
    open?: boolean;
    optimum?: number;
    pattern?: string;
    placeholder?: string;
    playsInline?: boolean;
    poster?: string;
    preload?: string;
    readOnly?: boolean;
    rel?: string;
    required?: boolean;
    reversed?: boolean;
    rows?: number;
    rowSpan?: number;
    sandbox?: string;
    scope?: string;
    scoped?: boolean;
    scrolling?: string;
    seamless?: boolean;
    selected?: boolean;
    shape?: string;
    size?: number;
    sizes?: string;
    span?: number;
    src?: string;
    srcDoc?: string;
    srcLang?: string;
    srcSet?: string;
    start?: number;
    step?: number | string;
    summary?: string;
    target?: string;
    type?: string;
    useMap?: string;
    value?: string | ReadonlyArray<string> | number;
    width?: number | string;
    wmode?: string;
    wrap?: string;
}

interface HTMLElement$1 extends Element {
}
interface HTMLWebViewElement extends HTMLElement$1 {
}

type DOMFactory<P extends DOMAttributes<T>, T extends Element> = (props?: (ClassAttributes<T> & P) | null, ...children: InulaNode[]) => DOMElement<P, T>;
interface InulaHTMLFactory<P extends HTMLAttributes<T>, T extends HTMLElement> extends DOMFactory<P, T> {
    (props?: (ClassAttributes<T> & P) | null, ...children: InulaNode[]): DetailedInulaHTMLElement<P, T>;
}
interface InulaHTMLElement<T extends HTMLElement> extends DetailedInulaHTMLElement<AllHTMLAttributes<T>, T> {
}
interface DOMElement<P extends HTMLAttributes<T> | SVGAttributes<T>, T extends Element> extends InulaElement<P, string> {
    ref: LegacyRef<T>;
}
interface InulaSVGElement extends DOMElement<SVGAttributes<SVGElement>, SVGElement> {
    type: keyof InulaSVG;
}
interface InulaSVG {
    animate: InulaSVGFactory;
    circle: InulaSVGFactory;
    clipPath: InulaSVGFactory;
    defs: InulaSVGFactory;
    desc: InulaSVGFactory;
    ellipse: InulaSVGFactory;
    feBlend: InulaSVGFactory;
    feColorMatrix: InulaSVGFactory;
    feComponentTransfer: InulaSVGFactory;
    feComposite: InulaSVGFactory;
    feConvolveMatrix: InulaSVGFactory;
    feDiffuseLighting: InulaSVGFactory;
    feDisplacementMap: InulaSVGFactory;
    feDistantLight: InulaSVGFactory;
    feDropShadow: InulaSVGFactory;
    feFlood: InulaSVGFactory;
    feFuncA: InulaSVGFactory;
    feFuncB: InulaSVGFactory;
    feFuncG: InulaSVGFactory;
    feFuncR: InulaSVGFactory;
    feImage: InulaSVGFactory;
    feGaussianBlur: InulaSVGFactory;
    feMerge: InulaSVGFactory;
    feMergeNode: InulaSVGFactory;
    feMorphology: InulaSVGFactory;
    feOffset: InulaSVGFactory;
    fePointLight: InulaSVGFactory;
    feSpecularLighting: InulaSVGFactory;
    feSpotLight: InulaSVGFactory;
    feTile: InulaSVGFactory;
    feTurbulence: InulaSVGFactory;
    filter: InulaSVGFactory;
    foreignObject: InulaSVGFactory;
    g: InulaSVGFactory;
    image: InulaSVGFactory;
    line: InulaSVGFactory;
    linearGradient: InulaSVGFactory;
    marker: InulaSVGFactory;
    mask: InulaSVGFactory;
    view: InulaSVGFactory;
    metadata: InulaSVGFactory;
    path: InulaSVGFactory;
    pattern: InulaSVGFactory;
    polygon: InulaSVGFactory;
    polyline: InulaSVGFactory;
    radialGradient: InulaSVGFactory;
    rect: InulaSVGFactory;
    stop: InulaSVGFactory;
    svg: InulaSVGFactory;
    switch: InulaSVGFactory;
    symbol: InulaSVGFactory;
    text: InulaSVGFactory;
    textPath: InulaSVGFactory;
    tspan: InulaSVGFactory;
    use: InulaSVGFactory;
}
interface InulaSVGFactory extends DOMFactory<SVGAttributes<SVGElement>, SVGElement> {
    (props?: (ClassAttributes<SVGElement> & SVGAttributes<SVGElement>) | null, ...children: InulaNode[]): InulaSVGElement;
}
interface DetailedInulaHTMLElement<P extends HTMLAttributes<T>, T extends HTMLElement> extends DOMElement<P, T> {
    type: keyof BaseElement;
}
interface InulaHTML {
    a: InulaHTMLFactory<AnchorHTMLAttributes<HTMLAnchorElement>, HTMLAnchorElement>;
    abbr: InulaHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>;
    address: InulaHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>;
    area: InulaHTMLFactory<AreaHTMLAttributes<HTMLAreaElement>, HTMLAreaElement>;
    article: InulaHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>;
    aside: InulaHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>;
    audio: InulaHTMLFactory<AudioHTMLAttributes<HTMLAudioElement>, HTMLAudioElement>;
    b: InulaHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>;
    base: InulaHTMLFactory<BaseHTMLAttributes<HTMLBaseElement>, HTMLBaseElement>;
    bdi: InulaHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>;
    bdo: InulaHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>;
    big: InulaHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>;
    blockquote: InulaHTMLFactory<BlockquoteHTMLAttributes<HTMLQuoteElement>, HTMLQuoteElement>;
    body: InulaHTMLFactory<HTMLAttributes<HTMLBodyElement>, HTMLBodyElement>;
    br: InulaHTMLFactory<HTMLAttributes<HTMLBRElement>, HTMLBRElement>;
    button: InulaHTMLFactory<ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>;
    canvas: InulaHTMLFactory<CanvasHTMLAttributes<HTMLCanvasElement>, HTMLCanvasElement>;
    caption: InulaHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>;
    cite: InulaHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>;
    code: InulaHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>;
    col: InulaHTMLFactory<ColHTMLAttributes<HTMLTableColElement>, HTMLTableColElement>;
    colgroup: InulaHTMLFactory<ColgroupHTMLAttributes<HTMLTableColElement>, HTMLTableColElement>;
    data: InulaHTMLFactory<DataHTMLAttributes<HTMLDataElement>, HTMLDataElement>;
    datalist: InulaHTMLFactory<HTMLAttributes<HTMLDataListElement>, HTMLDataListElement>;
    dd: InulaHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>;
    del: InulaHTMLFactory<DelHTMLAttributes<HTMLModElement>, HTMLModElement>;
    details: InulaHTMLFactory<DetailsHTMLAttributes<HTMLDetailsElement>, HTMLDetailsElement>;
    dfn: InulaHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>;
    dialog: InulaHTMLFactory<DialogHTMLAttributes<HTMLDialogElement>, HTMLDialogElement>;
    div: InulaHTMLFactory<HTMLAttributes<HTMLDivElement>, HTMLDivElement>;
    dl: InulaHTMLFactory<HTMLAttributes<HTMLDListElement>, HTMLDListElement>;
    dt: InulaHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>;
    em: InulaHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>;
    embed: InulaHTMLFactory<EmbedHTMLAttributes<HTMLEmbedElement>, HTMLEmbedElement>;
    fieldset: InulaHTMLFactory<FieldsetHTMLAttributes<HTMLFieldSetElement>, HTMLFieldSetElement>;
    figcaption: InulaHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>;
    figure: InulaHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>;
    footer: InulaHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>;
    form: InulaHTMLFactory<FormHTMLAttributes<HTMLFormElement>, HTMLFormElement>;
    h1: InulaHTMLFactory<HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>;
    h2: InulaHTMLFactory<HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>;
    h3: InulaHTMLFactory<HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>;
    h4: InulaHTMLFactory<HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>;
    h5: InulaHTMLFactory<HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>;
    h6: InulaHTMLFactory<HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>;
    head: InulaHTMLFactory<HTMLAttributes<HTMLElement>, HTMLHeadElement>;
    header: InulaHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>;
    hgroup: InulaHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>;
    hr: InulaHTMLFactory<HTMLAttributes<HTMLHRElement>, HTMLHRElement>;
    html: InulaHTMLFactory<HtmlHTMLAttributes<HTMLHtmlElement>, HTMLHtmlElement>;
    i: InulaHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>;
    iframe: InulaHTMLFactory<IframeHTMLAttributes<HTMLIFrameElement>, HTMLIFrameElement>;
    img: InulaHTMLFactory<ImgHTMLAttributes<HTMLImageElement>, HTMLImageElement>;
    input: InulaHTMLFactory<InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>;
    ins: InulaHTMLFactory<InsHTMLAttributes<HTMLModElement>, HTMLModElement>;
    kbd: InulaHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>;
    keygen: InulaHTMLFactory<KeygenHTMLAttributes<HTMLElement>, HTMLElement>;
    label: InulaHTMLFactory<LabelHTMLAttributes<HTMLLabelElement>, HTMLLabelElement>;
    legend: InulaHTMLFactory<HTMLAttributes<HTMLLegendElement>, HTMLLegendElement>;
    li: InulaHTMLFactory<LiHTMLAttributes<HTMLLIElement>, HTMLLIElement>;
    link: InulaHTMLFactory<LinkHTMLAttributes<HTMLLinkElement>, HTMLLinkElement>;
    main: InulaHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>;
    map: InulaHTMLFactory<MapHTMLAttributes<HTMLMapElement>, HTMLMapElement>;
    mark: InulaHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>;
    menu: InulaHTMLFactory<MenuHTMLAttributes<HTMLElement>, HTMLElement>;
    menuitem: InulaHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>;
    meta: InulaHTMLFactory<MetaHTMLAttributes<HTMLMetaElement>, HTMLMetaElement>;
    meter: InulaHTMLFactory<MeterHTMLAttributes<HTMLMeterElement>, HTMLMeterElement>;
    nav: InulaHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>;
    noscript: InulaHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>;
    object: InulaHTMLFactory<ObjectHTMLAttributes<HTMLObjectElement>, HTMLObjectElement>;
    ol: InulaHTMLFactory<OlHTMLAttributes<HTMLOListElement>, HTMLOListElement>;
    optgroup: InulaHTMLFactory<OptgroupHTMLAttributes<HTMLOptGroupElement>, HTMLOptGroupElement>;
    option: InulaHTMLFactory<OptionHTMLAttributes<HTMLOptionElement>, HTMLOptionElement>;
    output: InulaHTMLFactory<OutputHTMLAttributes<HTMLOutputElement>, HTMLOutputElement>;
    p: InulaHTMLFactory<HTMLAttributes<HTMLParagraphElement>, HTMLParagraphElement>;
    param: InulaHTMLFactory<ParamHTMLAttributes<HTMLParamElement>, HTMLParamElement>;
    picture: InulaHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>;
    pre: InulaHTMLFactory<HTMLAttributes<HTMLPreElement>, HTMLPreElement>;
    progress: InulaHTMLFactory<ProgressHTMLAttributes<HTMLProgressElement>, HTMLProgressElement>;
    q: InulaHTMLFactory<QuoteHTMLAttributes<HTMLQuoteElement>, HTMLQuoteElement>;
    rp: InulaHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>;
    rt: InulaHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>;
    ruby: InulaHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>;
    s: InulaHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>;
    samp: InulaHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>;
    slot: InulaHTMLFactory<SlotHTMLAttributes<HTMLSlotElement>, HTMLSlotElement>;
    script: InulaHTMLFactory<ScriptHTMLAttributes<HTMLScriptElement>, HTMLScriptElement>;
    section: InulaHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>;
    select: InulaHTMLFactory<SelectHTMLAttributes<HTMLSelectElement>, HTMLSelectElement>;
    small: InulaHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>;
    source: InulaHTMLFactory<SourceHTMLAttributes<HTMLSourceElement>, HTMLSourceElement>;
    span: InulaHTMLFactory<HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>;
    strong: InulaHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>;
    style: InulaHTMLFactory<StyleHTMLAttributes<HTMLStyleElement>, HTMLStyleElement>;
    sub: InulaHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>;
    summary: InulaHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>;
    sup: InulaHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>;
    table: InulaHTMLFactory<TableHTMLAttributes<HTMLTableElement>, HTMLTableElement>;
    template: InulaHTMLFactory<HTMLAttributes<HTMLTemplateElement>, HTMLTemplateElement>;
    tbody: InulaHTMLFactory<HTMLAttributes<HTMLTableSectionElement>, HTMLTableSectionElement>;
    td: InulaHTMLFactory<TdHTMLAttributes<HTMLTableDataCellElement>, HTMLTableDataCellElement>;
    textarea: InulaHTMLFactory<TextareaHTMLAttributes<HTMLTextAreaElement>, HTMLTextAreaElement>;
    tfoot: InulaHTMLFactory<HTMLAttributes<HTMLTableSectionElement>, HTMLTableSectionElement>;
    th: InulaHTMLFactory<ThHTMLAttributes<HTMLTableHeaderCellElement>, HTMLTableHeaderCellElement>;
    thead: InulaHTMLFactory<HTMLAttributes<HTMLTableSectionElement>, HTMLTableSectionElement>;
    time: InulaHTMLFactory<TimeHTMLAttributes<HTMLTimeElement>, HTMLTimeElement>;
    title: InulaHTMLFactory<HTMLAttributes<HTMLTitleElement>, HTMLTitleElement>;
    tr: InulaHTMLFactory<HTMLAttributes<HTMLTableRowElement>, HTMLTableRowElement>;
    track: InulaHTMLFactory<TrackHTMLAttributes<HTMLTrackElement>, HTMLTrackElement>;
    u: InulaHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>;
    ul: InulaHTMLFactory<HTMLAttributes<HTMLUListElement>, HTMLUListElement>;
    var: InulaHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>;
    video: InulaHTMLFactory<VideoHTMLAttributes<HTMLVideoElement>, HTMLVideoElement>;
    wbr: InulaHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>;
    webview: InulaHTMLFactory<WebViewHTMLAttributes<HTMLElement>, HTMLElement>;
}
type InulaHTMLProps<E extends HTMLAttributes<T>, T> = ClassAttributes<T> & E;
interface BaseElement {
    a: InulaHTMLProps<AnchorHTMLAttributes<HTMLAnchorElement>, HTMLAnchorElement>;
    abbr: InulaHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
    address: InulaHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
    area: InulaHTMLProps<AreaHTMLAttributes<HTMLAreaElement>, HTMLAreaElement>;
    article: InulaHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
    aside: InulaHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
    audio: InulaHTMLProps<AudioHTMLAttributes<HTMLAudioElement>, HTMLAudioElement>;
    b: InulaHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
    base: InulaHTMLProps<BaseHTMLAttributes<HTMLBaseElement>, HTMLBaseElement>;
    bdi: InulaHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
    bdo: InulaHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
    big: InulaHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
    blockquote: InulaHTMLProps<BlockquoteHTMLAttributes<HTMLQuoteElement>, HTMLQuoteElement>;
    body: InulaHTMLProps<HTMLAttributes<HTMLBodyElement>, HTMLBodyElement>;
    br: InulaHTMLProps<HTMLAttributes<HTMLBRElement>, HTMLBRElement>;
    button: InulaHTMLProps<ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>;
    canvas: InulaHTMLProps<CanvasHTMLAttributes<HTMLCanvasElement>, HTMLCanvasElement>;
    caption: InulaHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
    cite: InulaHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
    code: InulaHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
    col: InulaHTMLProps<ColHTMLAttributes<HTMLTableColElement>, HTMLTableColElement>;
    colgroup: InulaHTMLProps<ColgroupHTMLAttributes<HTMLTableColElement>, HTMLTableColElement>;
    data: InulaHTMLProps<DataHTMLAttributes<HTMLDataElement>, HTMLDataElement>;
    datalist: InulaHTMLProps<HTMLAttributes<HTMLDataListElement>, HTMLDataListElement>;
    dd: InulaHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
    del: InulaHTMLProps<DelHTMLAttributes<HTMLModElement>, HTMLModElement>;
    details: InulaHTMLProps<DetailsHTMLAttributes<HTMLDetailsElement>, HTMLDetailsElement>;
    dfn: InulaHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
    dialog: InulaHTMLProps<DialogHTMLAttributes<HTMLDialogElement>, HTMLDialogElement>;
    div: InulaHTMLProps<HTMLAttributes<HTMLDivElement>, HTMLDivElement>;
    dl: InulaHTMLProps<HTMLAttributes<HTMLDListElement>, HTMLDListElement>;
    dt: InulaHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
    em: InulaHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
    embed: InulaHTMLProps<EmbedHTMLAttributes<HTMLEmbedElement>, HTMLEmbedElement>;
    fieldset: InulaHTMLProps<FieldsetHTMLAttributes<HTMLFieldSetElement>, HTMLFieldSetElement>;
    figcaption: InulaHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
    figure: InulaHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
    footer: InulaHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
    form: InulaHTMLProps<FormHTMLAttributes<HTMLFormElement>, HTMLFormElement>;
    h1: InulaHTMLProps<HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>;
    h2: InulaHTMLProps<HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>;
    h3: InulaHTMLProps<HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>;
    h4: InulaHTMLProps<HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>;
    h5: InulaHTMLProps<HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>;
    h6: InulaHTMLProps<HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>;
    head: InulaHTMLProps<HTMLAttributes<HTMLHeadElement>, HTMLHeadElement>;
    header: InulaHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
    hgroup: InulaHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
    hr: InulaHTMLProps<HTMLAttributes<HTMLHRElement>, HTMLHRElement>;
    html: InulaHTMLProps<HtmlHTMLAttributes<HTMLHtmlElement>, HTMLHtmlElement>;
    i: InulaHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
    iframe: InulaHTMLProps<IframeHTMLAttributes<HTMLIFrameElement>, HTMLIFrameElement>;
    img: InulaHTMLProps<ImgHTMLAttributes<HTMLImageElement>, HTMLImageElement>;
    input: InulaHTMLProps<InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>;
    ins: InulaHTMLProps<InsHTMLAttributes<HTMLModElement>, HTMLModElement>;
    kbd: InulaHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
    keygen: InulaHTMLProps<KeygenHTMLAttributes<HTMLElement>, HTMLElement>;
    label: InulaHTMLProps<LabelHTMLAttributes<HTMLLabelElement>, HTMLLabelElement>;
    legend: InulaHTMLProps<HTMLAttributes<HTMLLegendElement>, HTMLLegendElement>;
    li: InulaHTMLProps<LiHTMLAttributes<HTMLLIElement>, HTMLLIElement>;
    link: InulaHTMLProps<LinkHTMLAttributes<HTMLLinkElement>, HTMLLinkElement>;
    main: InulaHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
    map: InulaHTMLProps<MapHTMLAttributes<HTMLMapElement>, HTMLMapElement>;
    mark: InulaHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
    menu: InulaHTMLProps<MenuHTMLAttributes<HTMLElement>, HTMLElement>;
    menuitem: InulaHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
    meta: InulaHTMLProps<MetaHTMLAttributes<HTMLMetaElement>, HTMLMetaElement>;
    meter: InulaHTMLProps<MeterHTMLAttributes<HTMLMeterElement>, HTMLMeterElement>;
    nav: InulaHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
    noindex: InulaHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
    noscript: InulaHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
    object: InulaHTMLProps<ObjectHTMLAttributes<HTMLObjectElement>, HTMLObjectElement>;
    ol: InulaHTMLProps<OlHTMLAttributes<HTMLOListElement>, HTMLOListElement>;
    optgroup: InulaHTMLProps<OptgroupHTMLAttributes<HTMLOptGroupElement>, HTMLOptGroupElement>;
    option: InulaHTMLProps<OptionHTMLAttributes<HTMLOptionElement>, HTMLOptionElement>;
    output: InulaHTMLProps<OutputHTMLAttributes<HTMLOutputElement>, HTMLOutputElement>;
    p: InulaHTMLProps<HTMLAttributes<HTMLParagraphElement>, HTMLParagraphElement>;
    param: InulaHTMLProps<ParamHTMLAttributes<HTMLParamElement>, HTMLParamElement>;
    picture: InulaHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
    pre: InulaHTMLProps<HTMLAttributes<HTMLPreElement>, HTMLPreElement>;
    progress: InulaHTMLProps<ProgressHTMLAttributes<HTMLProgressElement>, HTMLProgressElement>;
    q: InulaHTMLProps<QuoteHTMLAttributes<HTMLQuoteElement>, HTMLQuoteElement>;
    rp: InulaHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
    rt: InulaHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
    ruby: InulaHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
    s: InulaHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
    samp: InulaHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
    slot: InulaHTMLProps<SlotHTMLAttributes<HTMLSlotElement>, HTMLSlotElement>;
    script: InulaHTMLProps<ScriptHTMLAttributes<HTMLScriptElement>, HTMLScriptElement>;
    section: InulaHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
    select: InulaHTMLProps<SelectHTMLAttributes<HTMLSelectElement>, HTMLSelectElement>;
    small: InulaHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
    source: InulaHTMLProps<SourceHTMLAttributes<HTMLSourceElement>, HTMLSourceElement>;
    span: InulaHTMLProps<HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>;
    strong: InulaHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
    style: InulaHTMLProps<StyleHTMLAttributes<HTMLStyleElement>, HTMLStyleElement>;
    sub: InulaHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
    summary: InulaHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
    sup: InulaHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
    table: InulaHTMLProps<TableHTMLAttributes<HTMLTableElement>, HTMLTableElement>;
    template: InulaHTMLProps<HTMLAttributes<HTMLTemplateElement>, HTMLTemplateElement>;
    tbody: InulaHTMLProps<HTMLAttributes<HTMLTableSectionElement>, HTMLTableSectionElement>;
    td: InulaHTMLProps<TdHTMLAttributes<HTMLTableDataCellElement>, HTMLTableDataCellElement>;
    textarea: InulaHTMLProps<TextareaHTMLAttributes<HTMLTextAreaElement>, HTMLTextAreaElement>;
    tfoot: InulaHTMLProps<HTMLAttributes<HTMLTableSectionElement>, HTMLTableSectionElement>;
    th: InulaHTMLProps<ThHTMLAttributes<HTMLTableHeaderCellElement>, HTMLTableHeaderCellElement>;
    thead: InulaHTMLProps<HTMLAttributes<HTMLTableSectionElement>, HTMLTableSectionElement>;
    time: InulaHTMLProps<TimeHTMLAttributes<HTMLTimeElement>, HTMLTimeElement>;
    title: InulaHTMLProps<HTMLAttributes<HTMLTitleElement>, HTMLTitleElement>;
    tr: InulaHTMLProps<HTMLAttributes<HTMLTableRowElement>, HTMLTableRowElement>;
    track: InulaHTMLProps<TrackHTMLAttributes<HTMLTrackElement>, HTMLTrackElement>;
    u: InulaHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
    ul: InulaHTMLProps<HTMLAttributes<HTMLUListElement>, HTMLUListElement>;
    var: InulaHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
    video: InulaHTMLProps<VideoHTMLAttributes<HTMLVideoElement>, HTMLVideoElement>;
    wbr: InulaHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
    webview: InulaHTMLProps<WebViewHTMLAttributes<HTMLWebViewElement>, HTMLWebViewElement>;
    svg: InulaSVGProps<SVGSVGElement>;
    animate: InulaSVGProps<SVGElement>;
    animateMotion: InulaSVGProps<SVGElement>;
    animateTransform: InulaSVGProps<SVGElement>;
    circle: InulaSVGProps<SVGCircleElement>;
    clipPath: InulaSVGProps<SVGClipPathElement>;
    defs: InulaSVGProps<SVGDefsElement>;
    desc: InulaSVGProps<SVGDescElement>;
    ellipse: InulaSVGProps<SVGEllipseElement>;
    feBlend: InulaSVGProps<SVGFEBlendElement>;
    feColorMatrix: InulaSVGProps<SVGFEColorMatrixElement>;
    feComponentTransfer: InulaSVGProps<SVGFEComponentTransferElement>;
    feComposite: InulaSVGProps<SVGFECompositeElement>;
    feConvolveMatrix: InulaSVGProps<SVGFEConvolveMatrixElement>;
    feDiffuseLighting: InulaSVGProps<SVGFEDiffuseLightingElement>;
    feDisplacementMap: InulaSVGProps<SVGFEDisplacementMapElement>;
    feDistantLight: InulaSVGProps<SVGFEDistantLightElement>;
    feDropShadow: InulaSVGProps<SVGFEDropShadowElement>;
    feFlood: InulaSVGProps<SVGFEFloodElement>;
    feFuncA: InulaSVGProps<SVGFEFuncAElement>;
    feFuncB: InulaSVGProps<SVGFEFuncBElement>;
    feFuncG: InulaSVGProps<SVGFEFuncGElement>;
    feFuncR: InulaSVGProps<SVGFEFuncRElement>;
    feGaussianBlur: InulaSVGProps<SVGFEGaussianBlurElement>;
    feImage: InulaSVGProps<SVGFEImageElement>;
    feMerge: InulaSVGProps<SVGFEMergeElement>;
    feMergeNode: InulaSVGProps<SVGFEMergeNodeElement>;
    feMorphology: InulaSVGProps<SVGFEMorphologyElement>;
    feOffset: InulaSVGProps<SVGFEOffsetElement>;
    fePointLight: InulaSVGProps<SVGFEPointLightElement>;
    feSpecularLighting: InulaSVGProps<SVGFESpecularLightingElement>;
    feSpotLight: InulaSVGProps<SVGFESpotLightElement>;
    feTile: InulaSVGProps<SVGFETileElement>;
    feTurbulence: InulaSVGProps<SVGFETurbulenceElement>;
    filter: InulaSVGProps<SVGFilterElement>;
    foreignObject: InulaSVGProps<SVGForeignObjectElement>;
    g: InulaSVGProps<SVGGElement>;
    image: InulaSVGProps<SVGImageElement>;
    line: InulaSVGProps<SVGLineElement>;
    linearGradient: InulaSVGProps<SVGLinearGradientElement>;
    marker: InulaSVGProps<SVGMarkerElement>;
    mask: InulaSVGProps<SVGMaskElement>;
    metadata: InulaSVGProps<SVGMetadataElement>;
    mpath: InulaSVGProps<SVGElement>;
    path: InulaSVGProps<SVGPathElement>;
    pattern: InulaSVGProps<SVGPatternElement>;
    polygon: InulaSVGProps<SVGPolygonElement>;
    polyline: InulaSVGProps<SVGPolylineElement>;
    radialGradient: InulaSVGProps<SVGRadialGradientElement>;
    rect: InulaSVGProps<SVGRectElement>;
    stop: InulaSVGProps<SVGStopElement>;
    switch: InulaSVGProps<SVGSwitchElement>;
    symbol: InulaSVGProps<SVGSymbolElement>;
    text: InulaSVGProps<SVGTextElement>;
    textPath: InulaSVGProps<SVGTextPathElement>;
    tspan: InulaSVGProps<SVGTSpanElement>;
    use: InulaSVGProps<SVGUseElement>;
    view: InulaSVGProps<SVGViewElement>;
}

export type Key = string | number;
export interface InulaElement<P = any, T extends string | JSXElementConstructor<any> = string | JSXElementConstructor<any>> {
    type: T;
    props: P;
    key: Key | null;
}
export interface InulaPortal extends InulaElement {
    key: Key | null;
    children: InulaNode;
}
interface InulaErrorInfo {
    componentStack: string;
}
export type KVObject = Record<any, any>;
export type InulaFragment = Iterable<InulaNode>;
export type ComponentState = any;
export type InulaNode = string | number | null | boolean | undefined | InulaElement | InulaFragment | InulaPortal;
export interface ExoticComponent<P = KVObject> {
    (props: P): InulaElement | null;
}
export interface ProviderProps<T> {
    value: T;
    children?: InulaNode | undefined;
}
interface ConsumerProps<T> {
    children: (value: T) => InulaNode;
}
interface Context$1<T> {
    Provider: ExoticComponent<ProviderProps<T>>;
    Consumer: ExoticComponent<ConsumerProps<T>>;
    displayName?: string | undefined;
}
export interface FunctionComponent<P = KVObject> {
    (props: P, context?: any): InulaElement<any, any> | null;
    displayName?: string;
}
export type ClassType<P, T extends Component<P, ComponentState>, C extends ComponentClass<P>> = C & (new (props: P, context?: any) => T);
export interface ClassicComponent<P = KVObject, S = KVObject> extends Component<P, S> {
    replaceState(nextState: S, callback?: () => void): void;
    isMounted(): boolean;
    getInitialState?(): S;
}
export type InulaCElement<P, T extends Component<P, ComponentState>> = ComponentElement<P, T>;
interface ComponentElement<P, T extends Component<P, ComponentState>> extends InulaElement<P, ComponentClass<P>> {
    ref?: LegacyRef<T> | undefined;
}
export interface ClassicComponentClass<P = KVObject> extends ComponentClass<P> {
    new (props: P, context?: any): ClassicComponent<P, ComponentState>;
    getDefaultProps?(): P;
}
export interface FunctionComponentElement<P> extends InulaElement<P, FunctionComponent<P>> {
    ref?: ('ref' extends keyof P ? (P extends {
        ref?: infer R | undefined;
    } ? R : never) : never) | undefined;
}
export interface ComponentClass<P = KVObject, S = ComponentState> extends StaticLifecycle<P, S> {
    new (props: P, context?: unknown): Component<P, S>;
    displayName?: string;
}
export type FC<P = KVObject> = FunctionComponent<P>;
export type ComponentType<P = KVObject> = ComponentClass<P> | FunctionComponent<P>;
export interface ChildrenType {
    map<T, C>(children: C | Array<C>, fn: (child: C, index: number) => T, context?: any): C extends null | undefined ? C : Array<Exclude<T, boolean | null | undefined>>;
    forEach<C>(children: C | Array<C>, fn: (child: C, index: number) => void): void;
    count(children: any): number;
    only<C>(children: C): C extends unknown[] ? never : C;
    toArray(children: InulaNode | InulaNode[]): Array<Exclude<InulaNode, boolean | null | undefined>>;
}
type ForwardRef<T> = ((inst: T | null) => void) | MutableRef<T | null> | null;
export interface ForwardRefRenderFunc<T, P = KVObject> {
    (props: P, ref: ForwardRef<T>): InulaElement | null;
}
export type PropsOmitRef<P> = 'ref' extends keyof P ? Omit<P, 'ref'> : P;
export type PropsWithRef<P> = 'ref' extends keyof P ? P extends {
    ref?: infer R | undefined;
} ? string extends R ? PropsOmitRef<P> & {
    ref?: Exclude<R, string>;
} : P : P : P;
export type Attributes = {
    key?: Key | null | undefined;
};





export type Ref<T> = RefCallBack<T> | RefObject<T> | null;
export type RefAttributes<T> = Attributes & {
    ref?: Ref<T> | null;
};
export type ComponentPropsWithRef<T> = T extends new (props: infer P) => Component<any, any> ? PropsOmitRef<P> & RefAttributes<InstanceType<T>> : T extends (props: infer P, legacyContext?: any) => InulaNode ? PropsWithRef<P> : never;
export type LazyComponent<T extends ComponentType<any>> = ExoticComponent<ComponentPropsWithRef<T>> & {
    readonly _result: T;
};
export type MemoComponent<T extends ComponentType<any>> = ExoticComponent<ComponentPropsWithRef<T>> & {
    readonly type: T;
    displayName?: string;
};
type Suspense = ExoticComponent<{
    children?: InulaNode;
    fallback: InulaNode;
}>;
type Fragment = ExoticComponent<{
    children?: InulaNode;
}>;
type StrictMode = ExoticComponent<{
    children?: InulaNode;
}>;
export type InulaProfiler = ExoticComponent<{
    children?: InulaNode;
    id: string;
    onRender: any;
}>;
interface OutDateLifecycle<P, S> {
    /**
     * @deprecated
     * @see componentDidMount
     */
    componentWillMount?(): void;
    /**
     * @deprecated
     * @alias componentWillMount
     */
    UNSAFE_componentWillMount?(): void;
    /**
     * @deprecated
     * @see getDerivedStateFromProps
     */
    componentWillReceiveProps?(nextProps: Readonly<P>, nextContext: any): void;
    /**
     * @deprecated
     * @alias componentWillReceiveProps
     */
    UNSAFE_componentWillReceiveProps?(nextProps: Readonly<P>, nextContext: any): void;
    /**
     * @deprecated
     * @alias getSnapshotBeforeUpdate
     */
    componentWillUpdate?(nextProps: Readonly<P>, nextState: Readonly<S>, nextContext: any): void;
    /**
     * @deprecated
     * @alias componentWillUpdate
     */
    UNSAFE_componentWillUpdate?(nextProps: Readonly<P>, nextState: Readonly<S>, nextContext: any): void;
}
interface StaticLifecycle<P, S> {
    getDerivedStateFromProps?(nextProps: Readonly<P>, prevState: S): Partial<S> | null;
    getDerivedStateFromError?(error: any): Partial<S> | null;
}
export interface ComponentLifecycle<P, S, SS> extends OutDateLifecycle<P, S>, StaticLifecycle<P, S> {
    componentDidMount?(): void;
    getSnapshotBeforeUpdate?(prevProps: Readonly<P>, prevState: Readonly<S>): SS | null;
    componentDidUpdate?(prevProps: Readonly<P>, prevState: Readonly<S>, snapshot?: SS): void;
    shouldComponentUpdate?(nextProps: Readonly<P>, nextState: Readonly<S>, nextContext: any): boolean;
    componentWillUnmount?(): void;
    componentDidCatch?(error: Error, errorInfo: InulaErrorInfo): void;
}
export type BasicStateAction<S> = S | ((prevState: S) => S);
type Dispatch$1<A> = (value: A) => void;
export type DispatchVoid = () => void;
type Reducer$1<S, A> = (prevState: S, action: A) => S;
export type ReducerVoid<S> = (prevState: S) => S;
export type ReducerStateVoid<R extends ReducerVoid<any>> = R extends ReducerVoid<infer S> ? S : never;
export type ReducerState<R extends Reducer$1<any, any>> = R extends Reducer$1<infer S, any> ? S : never;
export type ReducerAction<R extends Reducer$1<any, any>> = R extends Reducer$1<any, infer A> ? A : never;
export type DependencyList = Array<unknown>;
export type EffectCallBack = () => void | (() => void);
export type JSXElementConstructor<P> = ((props: P) => InulaElement<any, any> | null) | (new (props: P) => Component<any, any>);
interface InulaBaseEvent<E = unknown, Tr = unknown, Ta = unknown> {
    nativeEvent: E;
    trigger: Tr;
    target: Ta;
    bubbles: boolean;
    cancelable: boolean;
    defaultPrevented: boolean;
    eventPhase: number;
    isTrusted: boolean;
    preventDefault(): void;
    isDefaultPrevented(): boolean;
    stopPropagation(): void;
    isPropagationStopped(): boolean;
    persist(): void;
    timeStamp: number;
    type: string;
}
export interface SyntheticEvent<T = Element, E = Event> extends InulaBaseEvent<E, EventTarget & T, EventTarget> {
}
interface ClipboardEvent$1<T = Element> extends SyntheticEvent<T, DomClipboardEvent> {
    clipboardData: DataTransfer;
}
interface CompositionEvent$1<T = Element> extends SyntheticEvent<T, DomCompositionEvent> {
    data: string;
}
interface DragEvent$1<T = Element> extends MouseEvent$1<T, DomDragEvent> {
    dataTransfer: DataTransfer;
}
interface PointerEvent$1<T = Element> extends MouseEvent$1<T, DomPointerEvent> {
    pointerId: number;
    pressure: number;
    tangentialPressure: number;
    tiltX: number;
    tiltY: number;
    twist: number;
    width: number;
    height: number;
    pointerType: 'mouse' | 'pen' | 'touch';
    isPrimary: boolean;
}
interface FocusEvent$1<Target = Element, RelatedTarget = Element> extends SyntheticEvent<Target, DomFocusEvent> {
    relatedTarget: (EventTarget & RelatedTarget) | null;
    target: EventTarget & Target;
}
export type FormEvent<T = Element> = SyntheticEvent<T>;
export interface InvalidEvent<T = Element> extends SyntheticEvent<T> {
    target: EventTarget & T;
}
export interface ChangeEvent<T = Element> extends SyntheticEvent<T> {
    target: EventTarget & T;
}
interface WheelEvent$1<T = Element> extends MouseEvent$1<T, DomWheelEvent> {
    deltaMode: number;
    deltaX: number;
    deltaY: number;
    deltaZ: number;
}
interface AnimationEvent$1<T = Element> extends SyntheticEvent<T, DomAnimationEvent> {
    animationName: string;
    elapsedTime: number;
    pseudoElement: string;
}
interface TransitionEvent$1<T = Element> extends SyntheticEvent<T, DomTransitionEvent> {
    elapsedTime: number;
    propertyName: string;
    pseudoElement: string;
}
interface UIEvent$1<T = Element, E = DomUIEvent> extends SyntheticEvent<T, E> {
    detail: number;
}
export type ModifierKey = 'Alt' | 'AltGraph' | 'CapsLock' | 'Control' | 'Fn' | 'FnLock' | 'Meta' | 'NumLock' | 'ScrollLock' | 'Shift' | 'Symbol' | 'SymbolLock';
interface KeyboardEvent$1<T = Element> extends UIEvent$1<T, DomKeyboardEvent> {
    altKey: boolean;
    /** @deprecated */
    charCode: number;
    ctrlKey: boolean;
    code: string;
    key: string;
    /** @deprecated */
    keyCode: number;
    locale: string;
    location: number;
    metaKey: boolean;
    repeat: boolean;
    shiftKey: boolean;
    /** @deprecated */
    which: number;
    getModifierState(key: ModifierKey): boolean;
}
interface TouchEvent$1<T = Element> extends UIEvent$1<T, DomTouchEvent> {
    altKey: boolean;
    changedTouches: TouchList;
    ctrlKey: boolean;
    metaKey: boolean;
    shiftKey: boolean;
    targetTouches: TouchList;
    touches: TouchList;
    getModifierState(key: ModifierKey): boolean;
}
interface MouseEvent$1<T = Element, E = DomMouseEvent> extends UIEvent$1<T, E> {
    altKey: boolean;
    button: number;
    buttons: number;
    clientX: number;
    clientY: number;
    ctrlKey: boolean;
    metaKey: boolean;
    movementX: number;
    movementY: number;
    pageX: number;
    pageY: number;
    relatedTarget: EventTarget | null;
    screenX: number;
    screenY: number;
    shiftKey: boolean;
    getModifierState(key: ModifierKey): boolean;
}
export type EventHandler<E extends SyntheticEvent<unknown>> = {
    bivarianceHack(event: E): void;
}['bivarianceHack'];
export type InulaClipboardEventHandler<T = Element> = EventHandler<ClipboardEvent$1<T>>;
export type InulaCompositionEventHandler<T = Element> = EventHandler<CompositionEvent$1<T>>;
export type InulaDragEventHandler<T = Element> = EventHandler<DragEvent$1<T>>;
export type InulaFocusEventHandler<T = Element> = EventHandler<FocusEvent$1<T>>;
export type InulaFormEventHandler<T = Element> = EventHandler<FormEvent<T>>;
export type InulaChangeEventHandler<T = Element> = EventHandler<ChangeEvent<T>>;
export type InulaKeyboardEventHandler<T = Element> = EventHandler<KeyboardEvent$1<T>>;
export type InulaMouseEventHandler<T = Element> = EventHandler<MouseEvent$1<T>>;
export type InulaTouchEventHandler<T = Element> = EventHandler<TouchEvent$1<T>>;
export type InulaPointerEventHandler<T = Element> = EventHandler<PointerEvent$1<T>>;
export type InulaUIEventHandler<T = Element> = EventHandler<UIEvent$1<T>>;
export type InulaWheelEventHandler<T = Element> = EventHandler<WheelEvent$1<T>>;
export type InulaAnimationEventHandler<T = Element> = EventHandler<AnimationEvent$1<T>>;
export type InulaTransitionEventHandler<T = Element> = EventHandler<TransitionEvent$1<T>>;
export type CSSProperties = Record<string | number, any>;
export type LegacyRef<T> = string | Ref<T>;
export interface ClassAttributes<T> extends Attributes {
    ref?: LegacyRef<T> | undefined;
}
export interface InulaCSSProperties extends CSSProperties {
}
export type InulaBoolean = boolean | 'true' | 'false';
export type InulaEventHandler<T = Element> = EventHandler<SyntheticEvent<T>>;
declare global {
    namespace JSX {
        interface IntrinsicAttributes extends Attributes {
        }
        interface Element extends InulaElement<any, any> {
        }
        interface ElementClass extends Component<any> {
            render(): InulaNode;
        }
        interface ElementAttributesProperty {
            props: KVObject;
        }
        interface ElementChildrenAttribute {
            children: KVObject;
        }
        interface IntrinsicClassAttributes<T> extends ClassAttributes<T> {
        }
        type IntrinsicElements = BaseElement;
    }
}

declare const TYPE_FRAGMENT: Fragment;
declare const TYPE_STRICT_MODE: StrictMode;
declare const TYPE_FORWARD_REF = 7;
declare const TYPE_SUSPENSE: Suspense;
declare const TYPE_PROFILER: InulaProfiler;
declare const TYPE_MEMO = 10;

export declare function createRef<T>(): RefObject<T>;



export declare const Children: ChildrenType;

export declare function createElement(type: 'input', props?: (InputHTMLAttributes<HTMLInputElement> & ClassAttributes<HTMLInputElement>) | null, ...children: InulaNode[]): DetailedInulaHTMLElement<InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>;
export declare function createElement<P extends HTMLAttributes<T>, T extends HTMLElement>(type: keyof InulaHTML, props?: (ClassAttributes<T> & P) | null, ...children: InulaNode[]): DetailedInulaHTMLElement<P, T>;
export declare function createElement<P extends SVGAttributes<T>, T extends SVGElement>(type: keyof InulaSVG, props?: (ClassAttributes<T> & P) | null, ...children: InulaNode[]): InulaSVGElement;
export declare function createElement<P extends DOMAttributes<T>, T extends Element>(type: string, props?: (ClassAttributes<T> & P) | null, ...children: InulaNode[]): DOMElement<P, T>;
export declare function createElement<P extends KVObject>(type: FunctionComponent<P>, props?: (Attributes & P) | null, ...children: InulaNode[]): FunctionComponentElement<P>;
export declare function createElement<P extends KVObject>(type: ClassType<P, ClassicComponent<P, ComponentState>, ClassicComponentClass<P>>, props?: (ClassAttributes<ClassicComponent<P, ComponentState>> & P) | null, ...children: InulaNode[]): InulaCElement<P, ClassicComponent<P, ComponentState>>;
export declare function createElement<P extends KVObject, T extends Component<P, ComponentState>, C extends ComponentClass<P>>(type: ClassType<P, T, C>, props?: (ClassAttributes<T> & P) | null, ...children: InulaNode[]): InulaCElement<P, T>;
export declare function createElement<P extends KVObject>(type: FunctionComponent<P> | ComponentClass<P> | string, props?: (Attributes & P) | null, ...children: InulaNode[]): InulaElement<P>;
export declare function cloneElement<P extends HTMLAttributes<T>, T extends HTMLElement>(element: DetailedInulaHTMLElement<P, T>, props?: P, ...children: InulaNode[]): DetailedInulaHTMLElement<P, T>;
export declare function cloneElement<P extends HTMLAttributes<T>, T extends HTMLElement>(element: InulaHTMLElement<T>, props?: P, ...children: InulaNode[]): InulaHTMLElement<T>;
export declare function cloneElement<P extends SVGAttributes<T>, T extends SVGElement>(element: InulaSVGElement, props?: P, ...children: InulaNode[]): InulaSVGElement;
export declare function cloneElement<P extends DOMAttributes<T>, T extends Element>(element: DOMElement<P, T>, props?: DOMAttributes<T> & P, ...children: InulaNode[]): DOMElement<P, T>;
export declare function cloneElement<P>(element: FunctionComponentElement<P>, props?: Partial<P> & Attributes, ...children: InulaNode[]): FunctionComponentElement<P>;
export declare function cloneElement<P, T extends Component<P, ComponentState>>(element: InulaCElement<P, T>, props?: Partial<P> & ClassAttributes<T>, ...children: InulaNode[]): InulaCElement<P, T>;
export declare function cloneElement<P>(element: InulaElement<P>, props?: Partial<P> & Attributes, ...children: InulaNode[]): InulaElement<P>;
export declare function isValidElement<P>(element: {} | null | undefined): element is InulaElement<P>;

export declare function createContext<T>(val: T): Context$1<T>;

export declare function lazy<T extends ComponentType<any>>(promiseCtor: () => Promise<{
    default: T;
}>): LazyComponent<T>;

export declare function forwardRef<T, P = any>(render: ForwardRefRenderFunc<T, P>): ExoticComponent<PropsOmitRef<P>> & RefAttributes<T>;

export declare function memo<Props extends Record<string, any>>(type: FunctionComponent<Props>, compare?: (oldProps: Readonly<Props>, newProps: Readonly<Props>) => boolean): ExoticComponent<Props>;
export declare function memo<T extends ComponentType<any>>(type: T, compare?: (oldProps: any, newProps: any) => boolean): MemoComponent<T>;

export declare const version: any;




















export declare function useContext<T>(Context: Context$1<T>): T;
export declare function useState<S>(initialState: (() => S) | S): [S, Dispatch$1<BasicStateAction<S>>];
export declare function useState<S = undefined>(): [S | undefined, Dispatch$1<BasicStateAction<S | undefined>>];
export declare function useReducer<R extends ReducerVoid<any>, I>(reducer: R, initialArg: I, init: (arg: I) => ReducerVoid<R>): [ReducerStateVoid<R>, DispatchVoid];
export declare function useReducer<R extends ReducerVoid<any>>(reducer: R, initialArg: ReducerStateVoid<R>, init?: undefined): [ReducerStateVoid<R>, DispatchVoid];
export declare function useReducer<R extends Reducer$1<any, any>, I>(reducer: R, initialArg: I & ReducerState<R>, init?: (arg: I & ReducerState<R>) => ReducerState<R>): [ReducerState<R>, Dispatch$1<ReducerAction<R>>];
export declare function useReducer<R extends Reducer$1<any, any>, I>(reducer: R, initialArg: I, init?: (arg: I) => ReducerState<R>): [ReducerState<R>, Dispatch$1<ReducerAction<R>>];
export declare function useReducer<R extends Reducer$1<any, any>>(reducer: R, initialArg: ReducerState<R>, init?: undefined): [ReducerState<R>, Dispatch$1<ReducerAction<R>>];
export declare function useRef<T>(initialValue: T): MutableRef<T>;
export declare function useRef<T>(initialValue: T | null): RefObject<T>;
export declare function useRef<T = undefined>(): MutableRef<T | undefined>;
export declare function useEffect(create: EffectCallBack, deps?: DependencyList): void;
export declare function useLayoutEffect(create: EffectCallBack, deps?: DependencyList): void;
export declare function useCallback<T>(callback: T, deps: DependencyList): T;
export declare function useMemo<T>(create: () => T, deps: DependencyList | undefined): T;
export declare function useImperativeHandle<T, R extends T>(ref: RefObject<T> | RefCallBack<T> | null | undefined, create: () => R, deps?: DependencyList): void;
export declare const useDebugValue: () => void;

export declare function isElement(ele: any): ele is InulaElement;
export declare function isFragment(ele: any): ele is InulaElement;
export declare function isForwardRef(ele: any): ele is InulaElement;
export declare function isLazy(ele: any): ele is LazyComponent<any>;
export declare function isMemo(ele: any): ele is MemoComponent<any>;
export declare function isPortal(ele: any): ele is InulaElement;
export declare function isContextProvider(ele: any): ele is InulaElement;
export declare function isContextConsumer(ele: any): ele is InulaElement;
export declare function isValidElementType(type: any): boolean;

type StoreConfig<S extends Record<string, unknown>, A extends UserActions<S>, C extends UserComputedValues<S>> = {
    id?: string;
    state?: S;
    actions?: A;
    computed?: C;
    options?: {
        isReduxAdapter?: boolean;
    };
};
type UserActions<S extends Record<string, unknown>> = {
    [K: string]: ActionFunction<S>;
};
type ActionFunction<S extends Record<string, unknown>> = (this: StoreObj<S, any, any>, state: S, ...args: any[]) => any;
type StoreActions<S extends Record<string, unknown>, A extends UserActions<S>> = {
    [K in keyof A]: Action<A[K], S>;
};
type Action<T extends ActionFunction<any>, S extends Record<string, unknown>> = (this: StoreObj<S, any, any>, ...args: RemoveFirstFromTuple<Parameters<T>>) => ReturnType<T>;
type StoreObj<S extends Record<string, unknown>, A extends UserActions<S>, C extends UserComputedValues<S>> = {
    $s: S;
    $a: StoreActions<S, A>;
    $c: UserComputedValues<S>;
    $queue: QueuedStoreActions<S, A>;
    $listeners: any;
    $subscribe: (listener: (mutation: any) => void) => void;
    $unsubscribe: (listener: (mutation: any) => void) => void;
} & {
    [K in keyof S]: S[K];
} & {
    [K in keyof A]: Action<A[K], S>;
} & {
    [K in keyof C]: ReturnType<C[K]>;
};
type RemoveFirstFromTuple<T extends any[]> = T['length'] extends 0 ? [] : ((...b: T) => void) extends (a: any, ...b: infer I) => void ? I : [];
type UserComputedValues<S extends Record<string, unknown>> = {
    [K: string]: ComputedFunction<S>;
};
type ComputedFunction<S extends Record<string, unknown>> = (state: S) => any;
type AsyncAction<T extends ActionFunction<any>, S extends Record<string, unknown>> = (this: StoreObj<S, any, any>, ...args: RemoveFirstFromTuple<Parameters<T>>) => Promise<ReturnType<T>>;
type QueuedStoreActions<S extends Record<string, unknown>, A extends UserActions<S>> = {
    [K in keyof A]: AsyncAction<A[K], S>;
};









declare function createStore$1<S extends Record<string, any>, A extends UserActions<S>, C extends UserComputedValues<S>>(config: StoreConfig<S, A, C>): () => StoreObj<S, A, C>;
declare function useStore$1<S extends Record<string, unknown>, A extends UserActions<S>, C extends UserComputedValues<S>>(id: string): StoreObj<S, A, C>;
export declare function clearStore(id: string): void;

declare const thunk: ReduxMiddleware;

type Callback = () => void;
interface Subscription {
    stateChange?: () => any;
    addNestedSub(listener: Callback): Callback;
    triggerNestedSubs(): void;
    trySubscribe(): void;
    tryUnsubscribe(): void;
}








declare const ReduxAdapterContext: Context$1<{
    store: ReduxStoreHandler;
    subscription: Subscription;
}>;
type Context = typeof ReduxAdapterContext;
type Selector = (state: unknown) => unknown;
declare function Provider({ store, context, children, }: {
    store: ReduxStoreHandler;
    context?: Context;
    children?: any[];
}): FunctionComponentElement<ProviderProps<{
    store: ReduxStoreHandler<any>;
    subscription: Subscription;
}>>;
declare function createSelectorHook(context: Context): (selector?: Selector) => any;
declare function createDispatchHook(context: Context): () => BoundActionCreator;
declare const useSelector: (selector?: Selector) => any;
declare const useDispatch: () => BoundActionCreator;
declare const useStore: () => ReduxStoreHandler<any>;
type MapStateToPropsP<StateProps, OwnProps> = (state: any, ownProps: OwnProps) => StateProps;
type MapDispatchToPropsP<DispatchProps, OwnProps> = {
    [key: string]: (...args: any[]) => ReduxAction;
} | ((dispatch: (action: ReduxAction) => any, ownProps: OwnProps) => DispatchProps);
type MergePropsP<StateProps, DispatchProps, OwnProps, MergedProps> = (stateProps: StateProps, dispatchProps: DispatchProps, ownProps: OwnProps) => MergedProps;
type OriginalComponent<MergedProps> = (props: MergedProps) => ReturnType<typeof createElement>;
type Connector<OwnProps, MergedProps> = (Component: OriginalComponent<MergedProps>) => ComponentType<OwnProps>;
type ConnectOption<State, StateProps, OwnProps> = {
    /** @deprecated */
    prue?: boolean;
    forwardRef?: boolean;
    context?: Context;
    areOwnPropsEqual?: (newOwnProps: OwnProps, oldOwnProps: OwnProps) => boolean;
    areStatePropsEqual?: (newStateProps: StateProps, oldStateProps: StateProps) => boolean;
    areStatesEqual?: (newState: State, oldState: State) => boolean;
};
declare function connect<StateProps, DispatchProps, OwnProps, MergedProps>(mapStateToProps?: MapStateToPropsP<StateProps, OwnProps>, mapDispatchToProps?: MapDispatchToPropsP<DispatchProps, OwnProps>, mergeProps?: MergePropsP<StateProps, DispatchProps, OwnProps, MergedProps>, options?: ConnectOption<any, StateProps, OwnProps>): Connector<OwnProps, MergedProps>;

type ReduxStoreHandler<T = any> = {
    dispatch(action: {
        type: string;
    }): void;
    getState(): T;
    subscribe(listener: () => void): () => void;
    replaceReducer(reducer: (state: T, action: {
        type: string;
    }) => any): void;
};
type ReduxAction = {
    type: string;
    [key: string]: any;
};
type ReduxMiddleware = (store: ReduxStoreHandler, extraArgument?: any) => (next: (action: ReduxAction) => any) => (action: ReduxAction | ((dispatch: (action: ReduxAction) => void, store: ReduxStoreHandler, extraArgument?: any) => any)) => ReduxStoreHandler;
type Reducer = (state: any, action: ReduxAction) => any;
type StoreCreator = (reducer: Reducer, preloadedState?: any) => ReduxStoreHandler;
type StoreEnhancer = (next: StoreCreator) => StoreCreator;
declare function createStore(reducer: Reducer, preloadedState?: any, enhancer?: StoreEnhancer): ReduxStoreHandler;
declare function combineReducers(reducers: Record<string, Reducer>): Reducer;
declare function applyMiddleware(...middlewares: ReduxMiddleware[]): (createStore: StoreCreator) => StoreCreator;
type ActionCreator = (...params: any[]) => ReduxAction;
type ActionCreators = {
    [key: string]: ActionCreator;
};
type BoundActionCreator = (...params: any[]) => void;
type BoundActionCreators = {
    [key: string]: BoundActionCreator;
};
type Dispatch = (action: ReduxAction) => any;
declare function bindActionCreators(actionCreators: ActionCreators, dispatch: Dispatch): BoundActionCreators;
declare function compose<T = StoreCreator>(...middlewares: ((...args: any[]) => any)[]): (...args: any[]) => T;
declare function batch(fn: () => void): void;

type reduxAdapter_ReduxStoreHandler<T = any> = ReduxStoreHandler<T>;
type reduxAdapter_ReduxAction = ReduxAction;
type reduxAdapter_ReduxMiddleware = ReduxMiddleware;
declare const reduxAdapter_createStore: typeof createStore;
declare const reduxAdapter_combineReducers: typeof combineReducers;
declare const reduxAdapter_applyMiddleware: typeof applyMiddleware;
type reduxAdapter_BoundActionCreator = BoundActionCreator;
type reduxAdapter_Dispatch = Dispatch;
declare const reduxAdapter_bindActionCreators: typeof bindActionCreators;
declare const reduxAdapter_compose: typeof compose;
declare const reduxAdapter_batch: typeof batch;
declare const reduxAdapter_thunk: typeof thunk;
declare const reduxAdapter_Provider: typeof Provider;
declare const reduxAdapter_useSelector: typeof useSelector;
declare const reduxAdapter_useStore: typeof useStore;
declare const reduxAdapter_useDispatch: typeof useDispatch;
declare const reduxAdapter_connect: typeof connect;
declare const reduxAdapter_createSelectorHook: typeof createSelectorHook;
declare const reduxAdapter_createDispatchHook: typeof createDispatchHook;
declare const reduxAdapter_ReduxAdapterContext: typeof ReduxAdapterContext;
export declare namespace reduxAdapter {
  export { reduxAdapter_createStore as createStore, reduxAdapter_combineReducers as combineReducers, reduxAdapter_applyMiddleware as applyMiddleware, reduxAdapter_bindActionCreators as bindActionCreators, reduxAdapter_compose as compose, reduxAdapter_batch as batch, reduxAdapter_thunk as thunk, reduxAdapter_Provider as Provider, reduxAdapter_useSelector as useSelector, reduxAdapter_useStore as useStore, reduxAdapter_useDispatch as useDispatch, reduxAdapter_connect as connect, reduxAdapter_createSelectorHook as createSelectorHook, reduxAdapter_createDispatchHook as createDispatchHook, reduxAdapter_ReduxAdapterContext as ReduxAdapterContext };
  export type { reduxAdapter_ReduxStoreHandler as ReduxStoreHandler, reduxAdapter_ReduxAction as ReduxAction, reduxAdapter_ReduxMiddleware as ReduxMiddleware, reduxAdapter_BoundActionCreator as BoundActionCreator, reduxAdapter_Dispatch as Dispatch };
}

export declare function watch(stateVariable: any, listener: (state: any) => void): () => void;

interface Thenable {
    then(resolve: (val?: any) => void, reject: (err: any) => void): void;
}
export declare function act(fun: () => void | Thenable): Thenable;


declare function asyncUpdates<P, R>(fn: (a: P) => R, a: P): R;
declare function asyncUpdates<R>(fn: () => R): R;
declare function syncUpdates<P, R>(fn: (a: P) => R, a: P): R;
declare function syncUpdates<R>(fn: () => R): R;

/**
 * useEffect 和 useLayoutEffect的执行逻辑
 */




export declare function createPortal(children: InulaNode, realNode: Element | DocumentFragment, key?: null | string): InulaPortal;






type Container = Element | Document;



declare function executeRender(children: any, container: Container, callback?: Callback$1): Element | Text;
export declare function findDOMNode(domOrEle?: Element): null | Element | Text;
declare function destroy(container: Element | DocumentFragment | Document): boolean;
interface RootElement {
    render(component: InulaNode): void;
    unmount(): void;
}
declare function createRootElement(container: Container, option?: Record<string, any>): RootElement;

export declare function toRaw<T>(observed: T): T;




declare namespace Inula {
  export { Children };
  export { Component };
  export { TYPE_FORWARD_REF as ForwardRef };
  export { TYPE_FRAGMENT as Fragment };
  export { TYPE_MEMO as Memo };
  export { TYPE_PROFILER as Profiler };
  export { PureComponent };
  export { TYPE_STRICT_MODE as StrictMode };
  export { TYPE_SUSPENSE as Suspense };
  export { act };
  export { clearStore };
  export { cloneElement };
  export { createContext };
  export { createElement };
  export { createPortal };
  export { createRef };
  export { createRootElement as createRoot };
  export { createStore$1 as createStore };
  export { findDOMNode };
  export { syncUpdates as flushSync };
  export { forwardRef };
  export { isContextConsumer };
  export { isContextProvider };
  export { isElement };
  export { isForwardRef };
  export { isFragment };
  export { isLazy };
  export { isMemo };
  export { isPortal };
  export { isValidElement };
  export { isValidElementType };
  export { lazy };
  export { memo };
  export { executeRender as render };
  export { toRaw };
  export { destroy as unmountComponentAtNode };
  export { asyncUpdates as unstable_batchedUpdates };
  export { useCallback };
  export { useContext };
  export { useDebugValue };
  export { useEffect };
  export { useImperativeHandle };
  export { useLayoutEffect };
  export { useMemo };
  export { useReducer };
  export { useRef };
  export { useState };
  export { useStore$1 as useStore };
  export { version };
  export { watch };
  export { AnimationEvent$1 as AnimationEvent };
  export { Attributes };
  export { BasicStateAction };
  export { CSSProperties };
  export { ChangeEvent };
  export { ChildrenType };
  export { ClassAttributes };
  export { ClassType };
  export { ClassicComponent };
  export { ClassicComponentClass };
  export { ClipboardEvent$1 as ClipboardEvent };
  export { ComponentClass };
  export { ComponentLifecycle };
  export { ComponentPropsWithRef };
  export { ComponentState };
  export { ComponentType };
  export { CompositionEvent$1 as CompositionEvent };
  export { Context$1 as Context };
  export { DependencyList };
  export { Dispatch$1 as Dispatch };
  export { DispatchVoid };
  export { DragEvent$1 as DragEvent };
  export { EffectCallBack };
  export { EventHandler };
  export { ExoticComponent };
  export { FC };
  export { FocusEvent$1 as FocusEvent };
  export { FormEvent };
  export { ForwardRefRenderFunc };
  export { FunctionComponent };
  export { FunctionComponentElement };
  export { InulaAnimationEventHandler };
  export { InulaBoolean };
  export { InulaCElement };
  export { InulaCSSProperties };
  export { InulaChangeEventHandler };
  export { InulaClipboardEventHandler };
  export { InulaCompositionEventHandler };
  export { InulaDragEventHandler };
  export { InulaElement };
  export { InulaEventHandler };
  export { InulaFocusEventHandler };
  export { InulaFormEventHandler };
  export { InulaFragment };
  export { InulaKeyboardEventHandler };
  export { InulaMouseEventHandler };
  export { InulaNode };
  export { InulaPointerEventHandler };
  export { InulaPortal };
  export { InulaProfiler };
  export { InulaTouchEventHandler };
  export { InulaTransitionEventHandler };
  export { InulaUIEventHandler };
  export { InulaWheelEventHandler };
  export { InvalidEvent };
  export { JSXElementConstructor };
  export { KVObject };
  export { Key };
  export { KeyboardEvent$1 as KeyboardEvent };
  export { LazyComponent };
  export { LegacyRef };
  export { MemoComponent };
  export { ModifierKey };
  export { MouseEvent$1 as MouseEvent };
  export { PointerEvent$1 as PointerEvent };
  export { PropsOmitRef };
  export { PropsWithRef };
  export { ProviderProps };
  export { Reducer$1 as Reducer };
  export { ReducerAction };
  export { ReducerState };
  export { ReducerStateVoid };
  export { ReducerVoid };
  export { Ref };
  export { RefAttributes };
  export { RefCallBack };
  export { RefObject };
  export { SyntheticEvent };
  export { TouchEvent$1 as TouchEvent };
  export { TransitionEvent$1 as TransitionEvent };
  export { UIEvent$1 as UIEvent };
  export { WheelEvent$1 as WheelEvent };
}
export { TYPE_FORWARD_REF as ForwardRef };
export { TYPE_FRAGMENT as Fragment };
export { TYPE_MEMO as Memo };
export { TYPE_PROFILER as Profiler };
export { TYPE_STRICT_MODE as StrictMode };
export { TYPE_SUSPENSE as Suspense };
export { createRootElement as createRoot };
export { createStore$1 as createStore };
export { syncUpdates as flushSync };
export { executeRender as render };
export { destroy as unmountComponentAtNode };
export { asyncUpdates as unstable_batchedUpdates };
export { useStore$1 as useStore };
export { AnimationEvent$1 as AnimationEvent };
export { ClipboardEvent$1 as ClipboardEvent };
export { CompositionEvent$1 as CompositionEvent };
export { Context$1 as Context };
export { Dispatch$1 as Dispatch };
export { DragEvent$1 as DragEvent };
export { FocusEvent$1 as FocusEvent };
export { KeyboardEvent$1 as KeyboardEvent };
export { MouseEvent$1 as MouseEvent };
export { PointerEvent$1 as PointerEvent };
export { Reducer$1 as Reducer };
export { TouchEvent$1 as TouchEvent };
export { TransitionEvent$1 as TransitionEvent };
export { UIEvent$1 as UIEvent };
export { WheelEvent$1 as WheelEvent };
export default Inula;