type Sheet = CSSStyleSheet | HTMLStyleElement;

type Sheets = Sheet | Sheet[] | Sheets[];

type DOMFormElements =
    | HTMLInputElement
    | HTMLTextAreaElement
    | HTMLButtonElement
    | HTMLSelectElement;

/** A <form> element in the DOM; it allows access to and in some cases modification of aspects of the form, as well as access to its component elements. */
interface DOMFormElement extends HTMLElement {
    /**
     * Sets or retrieves a list of character encodings for input data that must be accepted by the server processing the form.
     */
    acceptCharset: string;
    /**
     * Sets or retrieves the URL to which the form content is sent for processing.
     */
    action: string;
    /**
     * Specifies whether autocomplete is applied to an editable text field.
     */
    autocomplete: string;
    /**
     * Retrieves a collection, in source order, of all controls in a given form.
     */
    readonly elements: HTMLFormControlsCollection;
    /**
     * Sets or retrieves the MIME encoding for the form.
     */
    encoding: string;
    /**
     * Sets or retrieves the encoding type for the form.
     */
    enctype: string;
    /**
     * Sets or retrieves the number of objects in a collection.
     */
    readonly length: number;
    /**
     * Sets or retrieves how to send the form data to the server.
     */
    method: string;
    /**
     * Sets or retrieves the name of the object.
     */
    name: string;
    /**
     * Designates a form that is not validated when submitted.
     */
    noValidate: boolean;
    /**
     * Sets or retrieves the window or frame at which to target content.
     */
    target: string;
    /**
     * Returns whether a form will validate when it is submitted, without having to submit it.
     */
    checkValidity(): boolean;
    reportValidity(): boolean;
    /**
     * Fires when the user resets a form.
     */
    reset(): void;
    /**
     * Fires when a FORM is about to be submitted.
     */
    submit(): void;
    [index: number]: Element;
}

interface SVGProperties {
    type: 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?: number | string;
    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;
    clipPath?: string;
    clipPathUnits?: number | string;
    clipRule?: number | string;
    colorInterpolation?: number | string;
    colorInterpolationFilters?: "auto" | "sRGB" | "linearRGB" | "inherit";
    colorProfile?: number | string;
    colorRendering?: number | string;
    contentScriptType?: number | string;
    contentStyleType?: number | string;
    cursor?: number | string;
    cx?: number | string;
    cy?: number | string;
    d?: string;
    decelerate?: number | string;
    descent?: number | string;
    diffuseConstant?: number | string;
    direction?: number | string;
    display?: 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?: number | string;
    fill?: string;
    fillOpacity?: number | string;
    fillRule?: "nonzero" | "evenodd" | "inherit";
    filter?: string;
    filterRes?: number | string;
    filterUnits?: number | string;
    floodColor?: number | string;
    floodOpacity?: number | string;
    focusable?: number | string;
    fontFamily?: string;
    fontSize?: number | string;
    fontSizeAdjust?: number | string;
    fontStretch?: number | string;
    fontStyle?: number | string;
    fontVariant?: number | string;
    fontWeight?: number | string;
    format?: number | string;
    from?: number | string;
    fx?: number | string;
    fy?: number | string;
    g1?: number | string;
    g2?: number | string;
    glyphName?: number | string;
    glyphOrientationHorizontal?: number | string;
    glyphOrientationVertical?: number | string;
    glyphRef?: number | string;
    gradientTransform?: string;
    gradientUnits?: string;
    hanging?: number | string;
    horizAdvX?: number | string;
    horizOriginX?: number | string;
    ideographic?: number | string;
    imageRendering?: number | string;
    in2?: number | string;
    in?: string;
    intercept?: number | string;
    k1?: number | string;
    k2?: number | string;
    k3?: number | string;
    k4?: number | string;
    k?: 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;
    mask?: string;
    maskContentUnits?: number | string;
    maskUnits?: number | string;
    mathematical?: number | string;
    mode?: number | string;
    numOctaves?: number | string;
    offset?: number | string;
    opacity?: 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;
    pathLength?: number | string;
    patternContentUnits?: string;
    patternTransform?: number | string;
    patternUnits?: string;
    pointerEvents?: number | string;
    points?: string;
    pointsAtX?: number | string;
    pointsAtY?: number | string;
    pointsAtZ?: number | string;
    preserveAlpha?: number | string;
    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;
    restart?: number | string;
    result?: string;
    rotate?: number | string;
    rx?: number | string;
    ry?: number | string;
    scale?: number | string;
    seed?: number | string;
    shapeRendering?: number | string;
    slope?: number | string;
    spacing?: number | string;
    specularConstant?: number | string;
    specularExponent?: number | string;
    speed?: number | string;
    spreadMethod?: string;
    startOffset?: number | string;
    stdDeviation?: number | string;
    stemh?: number | string;
    stemv?: number | string;
    stitchTiles?: number | string;
    stopColor?: string;
    stopOpacity?: number | string;
    strikethroughPosition?: number | string;
    strikethroughThickness?: number | string;
    string?: number | string;
    stroke?: string;
    strokeDasharray?: string | number;
    strokeDashoffset?: string | number;
    strokeLinecap?: "butt" | "round" | "square" | "inherit";
    strokeLinejoin?: "miter" | "round" | "bevel" | "inherit";
    strokeMiterlimit?: string | number;
    strokeOpacity?: number | string;
    strokeWidth?: number | string;
    surfaceScale?: number | string;
    systemLanguage?: number | string;
    tableValues?: number | string;
    targetX?: number | string;
    targetY?: number | string;
    textAnchor?: string;
    textDecoration?: number | string;
    textLength?: number | string;
    textRendering?: number | string;
    to?: number | string;
    transform?: string;
    u1?: number | string;
    u2?: number | string;
    underlinePosition?: number | string;
    underlineThickness?: number | string;
    unicode?: number | string;
    unicodeBidi?: number | string;
    unicodeRange?: number | string;
    unitsPerEm?: number | string;
    vAlphabetic?: number | string;
    values?: string;
    vectorEffect?: number | string;
    version?: string;
    vertAdvY?: number | string;
    vertOriginX?: number | string;
    vertOriginY?: number | string;
    vHanging?: number | string;
    vIdeographic?: number | string;
    viewBox?: string;
    viewTarget?: number | string;
    visibility?: number | string;
    vMathematical?: number | string;
    widths?: number | string;
    wordSpacing?: number | string;
    writingMode?: number | string;
    x1?: number | string;
    x2?: number | string;
    x?: 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;
    y?: number | string;
    yChannelSelector?: string;
    z?: number | string;
    zoomAndPan?: string;
}

type Nullable<T> = NonNullable<T> | undefined | null;

type PropsNullable<Data> = {
    [I in keyof Data]?: Nullable<Data[I]>;
};

type DOMCustomTag<Base, Props> = Omit<Base, keyof Props> & Props;

type DOMRefValue<Target> = FillObject | ((target: Target) => any);

type DOMRef<Target> = {
    ref?: DOMRefValue<Target>;
};

interface DOMGenericProperties {
    style?: string | Partial<CSSStyleDeclaration> | object;
    class?: string;
    id?: string;
    slot?: string;
    part?: string;
    is?: string;
    tabindex?: string | number;
    role?: string;
    shadowDom?: boolean | Partial<ShadowRootInit>;
    staticNode?: boolean;
    cloneNode?: boolean;
    width?: string | number;
    height?: string | number;
    key?: any;
    children?: any;
}

type DOMCleanKeys =
    | keyof DOMGenericProperties
    | `add${string}`
    | `get${string}`
    | `set${string}`
    | `has${string}`
    | `matches${string}`
    | `remove${string}`
    | `replace${string}`
    | `querySelector${string}`
    | `offset${string}`
    | `append${string}`
    | `request${string}`
    | `scroll${string}`
    | `is${string}`
    | `toggle${string}`
    | `webkit${string}`
    | `insert${string}`
    | `client${string}`
    | `child${string}`
    | `${string}_${string}`
    | `${string}HTML`
    | `${string}Child`
    | `${string}Validity`
    | `${string}Capture`
    | `${string}ElementSibling`
    | "classList"
    | "attributes"
    | "normalize"
    | "closest"
    | "localName"
    | "contains"
    | "animate"
    | "attachShadow"
    | "outerText"
    | "attachInternals"
    | "click"
    | "tagName"
    | "focus"
    | "submit"
    | "accessKeyLabel"
    | "elements"
    | "isContentEditable"
    | "innerText"
    | "prepend"
    | "namespaceURI"
    | "blur"
    | "dataset"
    | "shadowRoot"
    | keyof Omit<ChildNode, "textContent">;

type HTMLTags = HTMLElementTagNameMap;

type SVGTags = Omit<SVGElementTagNameMap, "a">;

type CheckEvent<CurrentEvent, True> = CurrentEvent extends Event ? True : never;

/**
 * @todo Rename Handler to Listener
 */

type DOMEventHandlerKeys<P> = {
    [I in keyof P]-?: NonNullable<P[I]> extends DOMEventHandlerValue<infer E>
        ? CheckEvent<E, I>
        : P[I] extends { value: DOMEventHandlerValue<infer E> }
          ? CheckEvent<E, I>
          : never;
}[keyof P];

interface DOMEventHandlerType extends FunctionConstructor {}

interface DOMEventHandlerValue<CurrentEvent> {
    (event: CurrentEvent): any;
}

type DOMEventType<Type extends string, CurrentEvent> = {
    [I in keyof "0" as `on${Type}`]: {
        type: DOMEventHandlerType;
        value: DOMEventHandlerValue<CurrentEvent>;
    };
};

interface DOM$Attrs {
    [prop: `\$${string}`]: Nullable<string>;
}

interface DOMUnknown {
    [prop: string]: any;
}

type DOMEventTarget<CurrentEvent, CurrentTarget, Target> = {
    [I in keyof CurrentEvent]: I extends "currentTarget"
        ? CurrentTarget
        : I extends "target"
          ? Target
          : CurrentEvent[I];
};

type DOMTarget<
    Target,
    CurrentEvent,
    Targets = Element | Node
> = CurrentEvent extends {
    customTarget: infer EventTarget;
}
    ? DOMTarget<Target, Omit<CurrentEvent, "customTarget">, EventTarget>
    : DOMEventTarget<CurrentEvent, Target, Targets>;

type DOMGetEventBefore<Value, Target> = Value extends DOMEventHandlerValue<
    infer Event
>
    ? DOMEvent<HTMLElement, Event & DOMCustomTarget<Target>>
    : null;

type DOMGetEvent<
    Type extends string,
    Element extends AtomicoStatic<any>
> = Element extends {
    "##props": infer Props;
}
    ? `on${Type}` extends keyof Props
        ? DOMGetEventBefore<NonNullable<Props[`on${Type}`]>, DOMThis<Element>>
        : Event
    : Event;

type DOMEvent<
    Target = HTMLElement,
    CurrentEvent = Event
> = Target extends string
    ? CurrentEvent extends AtomicoStatic<any>
        ? DOMGetEvent<Target, CurrentEvent>
        : DOMEventType<Target, CurrentEvent>
    : DOMTarget<DOMThis<Target>, CurrentEvent>;

type DOMEventHandler<Target, Handler> = Handler extends (
    ev: infer CurrentEvent
) => any
    ? CurrentEvent extends Event
        ? (ev: DOMEvent<Target, CurrentEvent>) => any
        : Handler
    : Handler;

type DOMEvents<Target> = {
    [Prop in keyof Target]?: Prop extends `on${string}`
        ? DOMEventHandler<Target, Target[Prop]>
        : Target[Prop];
};

type DOMCustomTarget<Target> = { customTarget: Target };

type DOMTag<Element, Props = null> = Props extends null
    ? PropsNullable<
          Omit<DOMEvents<Element>, DOMCleanKeys> &
              DOMGenericProperties &
              DOMRef<Element>
      > &
          DOM$Attrs &
          DOMUnknown
    : PropsNullable<
          Props &
              Omit<DOMEvents<Element & Props>, keyof Props | DOMCleanKeys> &
              DOMGenericProperties &
              DOMRef<Element & Props>
      > &
          DOM$Attrs &
          DOMUnknown;

type DOMTags<HTMLTags, CustomProps = null, HTMLMerge = null> = {
    [Tag in keyof HTMLTags]: Tag extends keyof HTMLMerge
        ? DOMTag<HTMLMerge[Tag], CustomProps>
        : DOMTag<HTMLTags[Tag], CustomProps>;
};

type DOMThis<Element> = Element extends new (
    ...args: any[]
) => infer This
    ? This
    : Element;

interface AtomicoElements {
    host: HTMLElement;
}

interface DOMCustomTags {
    slot: HTMLSlotElement & {
        onslotchange: (event: Event & DOMCustomTarget<HTMLSlotElement>) => void;
        assignNode: ChildNode;
    };
    form: DOMFormElement & {
        onsubmit: (
            event: SubmitEvent & DOMCustomTarget<DOMFormElements>
        ) => any;
        onchange: (event: Event & DOMCustomTarget<DOMFormElements>) => any;
        oninput: (event: Event & DOMCustomTarget<DOMFormElements>) => any;
    };
    input: DOMCustomTag<
        HTMLInputElement,
        {
            min: string | number;
            max: string | number;
            step: string | number;
            value: string | number;
        }
    >;
}

type JSXElements = DOMTags<AtomicoElements> &
    DOMTags<HTMLTags, null, DOMCustomTags> &
    DOMTags<SVGTags, SVGProperties>;

type JSXProxy<Props, This> = {
    [I in keyof Props]?: I extends `on${string}`
        ? NonNullable<Props[I]> extends DOMEventHandlerValue<infer CurrentEvent>
            ? Nullable<
                  (
                      ev: DOMEventTarget<CurrentEvent, This, Element | Node>
                  ) => any
              >
            : Props[I]
        : I extends "ref"
          ? DOMRefValue<This>
          : Props[I];
};

type JSXProps<T extends VNodeKeyTypes> = T extends Atomico<any, any, any>
    ? T extends { new (props: infer Props): any }
        ? Props
        : DOMTag<T>
    : T extends keyof JSXElements
      ? JSXElements[T]
      : T extends string
        ? DOMTag<HTMLElement>
        : DOMTag<DOMThis<T>>;

type AtomicoThis<Props = {}, Base = HTMLElement> = Props &
    DOMThis<Base> & {
        update(): Promise<void>;
        updated: Promise<void>;
        mounted: Promise<void>;
        unmounted: Promise<void>;
        readonly symbolId: unique symbol;
    };

interface AtomicoStatic<Props> extends HTMLElement {
    styles: Sheets[];
    props: SchemaInfer<Props>;
    /**
     * Meta property, allows associating the component's
     * props in typescript to external environments.
     */
    readonly "##props": Props;
    /**
     * Allows to identify a constructor created with Atomico
     */
    readonly "##atomico": true;
}

interface Atomico<Props, PropsForInstance, Base>
    extends AtomicoStatic<Props> {
    new (
        props?: JSXProxy<
            DOMTag<DOMThis<Base>, Props>,
            AtomicoThis<PropsForInstance, Base>
        >
    ): AtomicoThis<PropsForInstance, Base>;
}

type EventInit = CustomEventInit<any> & {
    type: string;
    base?: typeof CustomEvent | typeof Event;
};
/**
 * Interface to fill in unknown properties like any | null | undefined
 */
interface FillObject {
    [index: string]: any;
}

type FillArray = any[];

type FillFunction = (...args: any[]) => any;

type FillPromise = Promise<any>;

type FillConstructor = abstract new (...args: any) => any;

type SchemaEvent = {
    event?: EventInit;
};

type SchemaBase = SchemaEvent & {
    attr?: string;
};

type SchemaReflect<type> = SchemaBase & {
    reflect?: boolean;
} & type;

type SchemaProp<type> = SchemaEvent & type;

type SchemaOnlyPropWrapper<Constructor, Type> =
    | SchemaProp<{
          type: Constructor;
      }>
    | SchemaProp<{
          type: Constructor;
          value: Type;
      }>
    | SchemaProp<{
          type: Constructor;
          value: () => Type;
      }>;

type SchemaReflectWrapper<Constructor, Type> =
    | SchemaReflect<{
          type: Constructor;
      }>
    | SchemaReflect<{
          type: Constructor;
          value: Type;
      }>
    | SchemaReflect<{
          type: Constructor;
          value: () => Type;
      }>;

type SchemaAny<Type> =
    | SchemaReflect<{
          value: Type;
      }>
    | SchemaReflect<{
          value: () => Type;
      }>
    | SchemaReflect<{}>;

type SchemaTypeCustom =
    | TypeCustom<FillFunction>
    | SchemaReflectWrapper<TypeCustom<FillFunction>, any>;

type TypeString<type extends string> =
    | StringConstructor
    | SchemaReflectWrapper<StringConstructor, type>;

type TypeBoolean =
    | BooleanConstructor
    | SchemaReflectWrapper<BooleanConstructor, true | false>;

type TypeNumber<type extends number> =
    | NumberConstructor
    | SchemaReflectWrapper<NumberConstructor, type>;

type TypePromise<type extends FillPromise> =
    | PromiseConstructor
    | SchemaOnlyPropWrapper<PromiseConstructor, type>;

type TypeSymbol<type extends symbol> =
    | SymbolConstructor
    | SchemaOnlyPropWrapper<SymbolConstructor, type>;

type TypeFunction<type extends FillFunction> =
    | FunctionConstructor
    | SchemaOnlyPropWrapper<FunctionConstructor, type>;

type TypeArray<type extends FillArray> =
    | ArrayConstructor
    | SchemaReflectWrapper<ArrayConstructor, type>;

type TypeObject<type extends FillObject> =
    | ObjectConstructor
    | SchemaReflectWrapper<ObjectConstructor, type>;

type TypeAny<type = any> = null | SchemaAny<type>;

type Self = typeof window;

type SelfIgnore =
    | StringConstructor
    | NumberConstructor
    | BooleanConstructor
    | FunctionConstructor
    | ObjectConstructor
    | PromiseConstructor
    | SymbolConstructor
    | ArrayConstructor;

type SafeGlobal =
    | "Event"
    | "URL"
    | "Range"
    | "Image"
    | "Crypto"
    | "File"
    | "Date"
    | "Set"
    | "Map"
    | "RegExp"
    | "Animation"
    | `${string}Event`
    | `Event${string}`
    | `Clipboard${string}`
    | `Animation${string}`
    | `Form${string}`
    | `Font${string}`
    | `DOM${string}`
    | `Touch${string}`
    | `Mutation${string}`
    | `Intersection${string}`
    | `Message${string}`
    | `HTML${string}`
    | `SVG${string}`
    | `Audio${string}`
    | `Document${string}`
    | `Weak${string}`
    | `CSS${string}`
    | `File${string}`;

type SelfConstructors = Pick<
    Self,
    {
        [I in keyof Self]-?: I extends string
            ? I extends Capitalize<I>
                ? Self[I] extends FillConstructor
                    ? Self[I] extends SelfIgnore
                        ? never
                        : I extends SafeGlobal
                          ? I
                          : never
                    : never
                : never
            : never;
    }[keyof Self]
>;

type TypeConstructor<type extends FillConstructor> =
    | type
    | SchemaOnlyPropWrapper<type, InstanceType<type>>;

type TypesSelfValues = {
    [I in keyof SelfConstructors]-?: InstanceType<SelfConstructors[I]>;
}[keyof SelfConstructors];

type GetTypeSelf<value extends TypesSelfValues> = {
    [I in keyof SelfConstructors]-?: value extends InstanceType<
        SelfConstructors[I]
    >
        ? keyof value extends keyof InstanceType<SelfConstructors[I]>
            ? SelfConstructors[I]
            : never
        : never;
}[keyof SelfConstructors];

type TypesDiscard<type> = type extends FillFunction
    ? TypeFunction<type>
    : type extends FillObject
      ? TypeObject<type>
      : TypeAny<type>;

type Type<type> = type extends string
    ? TypeString<type>
    : type extends number
      ? TypeNumber<type>
      : type extends boolean
        ? TypeBoolean
        : type extends TypeCustom<FillFunction>
          ? SchemaTypeCustom
          : type extends FillPromise
            ? TypePromise<type>
            : type extends symbol
              ? TypeSymbol<type>
              : type extends FillArray
                ? TypeArray<type>
                : type extends DOMStringMap
                  ? TypeObject<type>
                  : type extends TypesSelfValues
                    ? GetTypeSelf<type> extends never
                        ? TypesDiscard<type>
                        : TypeConstructor<GetTypeSelf<type>>
                    : TypesDiscard<type>;

type SchemaInfer<Props> = Required<
    Omit<
        {
            [I in keyof Props]: Type<Props[I]>;
        },
        DOMEventHandlerKeys<Props>
    >
>;

type TypeCustom<Map extends FillFunction> = {
    name: "Custom";
    map: Map;
    serialize?: (value: ReturnType<Map>) => string;
};

type VnodeKeyTypesRaw = Node | typeof Element | Element | typeof Node;

type VNodeKeyTypes = string | VnodeKeyTypesRaw | null;

type VNodeRender = <T = Element>() => (
    node: T,
    id?: symbol | string,
    hydrate?: boolean
) => T;

interface VNodeGenericSchema {
    [TYPE: symbol]: symbol;
    key?: any;
    shadow?: boolean | Partial<ShadowRootInit>;
    static?: boolean;
    is?: string;
    clone?: boolean;
    render: VNodeRender;
}

interface VNodeSchema<Type, Props, Children, Raw extends number>
    extends VNodeGenericSchema {
    type: Type;
    props: Nullable<Props>;
    children: Children;
    raw: Raw;
}

type VNode<Type, Props = any, Children = any> = Type extends string
    ? VNodeSchema<string, JSXProps<Type>, Children, 0>
    : Type extends HTMLElement
      ? VNodeSchema<InternalElement, Props, Children, 1>
      : Type extends typeof HTMLElement
        ? VNodeSchema<CustomElementConstructor, Props, Children, 2>
        : VNodeSchema<any, Props, Children, number>;

type VNodeAny = VNode<any>;

interface InternalElement extends Element {
    cloneNode(value: boolean): Element;
}

export type { Atomico as A, VNodeAny as V };