import type { ContentNode, ContentNodeComponent } from 'tungsten/ContentNode.js'
import { TungstenBaseComponent } from 'tungsten/Components.jsx'
import type { FunctionComponent } from 'tungsten/FunctionComponent.js'
import type { TungstenRef } from 'tungsten/createRef.js'

import type { HTMLWebViewElement } from './html.global.js'
import type { 
    AnchorHTMLAttributes, AreaHTMLAttributes, AudioHTMLAttributes, BaseHTMLAttributes,
    BlockquoteHTMLAttributes, ButtonHTMLAttributes, CanvasHTMLAttributes, ColHTMLAttributes, ColgroupHTMLAttributes, DataHTMLAttributes, DelHTMLAttributes, DetailsHTMLAttributes, DialogHTMLAttributes, EmbedHTMLAttributes, FieldsetHTMLAttributes, FormHTMLAttributes, HTMLAttributes, HtmlHTMLAttributes, IframeHTMLAttributes, ImgHTMLAttributes, InputHTMLAttributes, InsHTMLAttributes, KeygenHTMLAttributes, LabelHTMLAttributes, LiHTMLAttributes, LinkHTMLAttributes, MapHTMLAttributes, MenuHTMLAttributes, MetaHTMLAttributes, MeterHTMLAttributes, ObjectHTMLAttributes, OlHTMLAttributes, OptgroupHTMLAttributes, OptionHTMLAttributes, OutputHTMLAttributes, ParamHTMLAttributes, ProgressHTMLAttributes, QuoteHTMLAttributes, SVGAttributes, ScriptHTMLAttributes, SelectHTMLAttributes, SlotHTMLAttributes, SourceHTMLAttributes, StyleHTMLAttributes, TableHTMLAttributes, TdHTMLAttributes, TextareaHTMLAttributes, ThHTMLAttributes, TimeHTMLAttributes, TrackHTMLAttributes, VideoHTMLAttributes, WebViewHTMLAttributes
} from './html.d.js'



interface ErrorInfo {
    componentStack: string;
}


/////////////////////////////////////////////////////
// React types that we are going to replace
/////////////////////////////////////////////////////
interface NewLifecycle<P, S, SS> {
    getSnapshotBeforeUpdate?(prevProps: Readonly<P>, prevState: Readonly<S>): SS | null;
    componentDidUpdate?(prevProps: Readonly<P>, prevState: Readonly<S>, snapshot?: SS): void;
}

interface DeprecatedLifecycle<P, S> {
    componentWillMount?(): void;
    UNSAFE_componentWillMount?(): void;
    componentWillReceiveProps?(nextProps: Readonly<P>, nextContext: any): void;
    UNSAFE_componentWillReceiveProps?(nextProps: Readonly<P>, nextContext: any): void;
    componentWillUpdate?(nextProps: Readonly<P>, nextState: Readonly<S>, nextContext: any): void;
    UNSAFE_componentWillUpdate?(nextProps: Readonly<P>, nextState: Readonly<S>, nextContext: any): void;
}

interface ComponentLifecycle<P, S, SS = any> extends NewLifecycle<P, S, SS>, DeprecatedLifecycle<P, S> {
    componentDidMount?(): void;
    shouldComponentUpdate?(nextProps: Readonly<P>, nextState: Readonly<S>, nextContext: any): boolean;
    componentWillUnmount?(): void;
    componentDidCatch?(error: Error, errorInfo: ErrorInfo): void;
}
interface Component<P = {}, S = {}, SS = any> extends ComponentLifecycle<P, S, SS> { }

type JSXElementConstructor<P> =
    | ((
        props: P,
            /**
             * @deprecated https://legacy.reactjs.org/docs/legacy-context.html#referencing-context-in-stateless-function-components
             */
        deprecatedLegacyContext?: any,
    ) => ContentNode)
    | (new (props: P) => Component<any, any>);

// interface ReactElement<P = any, T extends string | JSXElementConstructor<any> = string | JSXElementConstructor<any>> {
//     type: T;
//     props: P;
//     key: Key | null;
// }
// interface DO_NOT_USE_OR_YOU_WILL_BE_FIRED_EXPERIMENTAL_REACT_NODES {}
// type ReactNode =
//     | ReactElement
//     | string
//     | number
//     | Iterable<ReactNode>
//     | ReactPortal
//     | boolean
//     | null
//     | undefined
//     | DO_NOT_USE_OR_YOU_WILL_BE_FIRED_EXPERIMENTAL_REACT_NODES[keyof DO_NOT_USE_OR_YOU_WILL_BE_FIRED_EXPERIMENTAL_REACT_NODES];

// interface ReactPortal extends ReactElement {
//     key: Key | null;
//     children: ReactNode;
// }

/////////////////////////////////////////////////////
// End: React types that we are going to replace
/////////////////////////////////////////////////////


type Key = string | number;

interface RefObject<T> {
    readonly current: T | null;
}

// Bivariance hack for consistent unsoundness with RefObject
// type RefCallback<T> = { bivarianceHack(instance: T | null): void }['bivarianceHack'];
// type Ref<T> = RefCallback<T> | RefObject<T> | null;

//type LegacyRef<T> = string | Ref<T>;

interface Attributes {
    key?: Key | null | undefined;
}
interface RefAttributes<T> extends Attributes {
    /**
     * Allows getting a ref to the component instance.
     * Once the component unmounts, React will set `ref.current` to `null` (or call the ref with `null` if you passed a callback ref).
     * @see https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom
     */
    ref?: TungstenRef<T> | undefined;
}
interface ClassAttributes<T> extends Attributes {
    /**
     * Allows getting a ref to the component instance.
     * Once the component unmounts, React will set `ref.current` to `null` (or call the ref with `null` if you passed a callback ref).
     * @see https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom
     */
    ref?: TungstenRef<T> | undefined;
}

interface ClassAttributes<T> extends Attributes {
    /**
     * Allows getting a ref to the component instance.
     * Once the component unmounts, React will set `ref.current` to `null` (or call the ref with `null` if you passed a callback ref).
     * @see https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom
     */
    ref?: TungstenRef<T> | undefined;
}

type DetailedHTMLProps<E extends HTMLAttributes<T>, T> = ClassAttributes<T> & E;

interface SVGProps<T> extends SVGAttributes<T>, ClassAttributes<T> { }
interface SVGLineElementAttributes<T> extends SVGProps<T> {}
interface SVGTextElementAttributes<T> extends SVGProps<T> {}


/*
// We can't recurse forever because `type` can't be self-referential;
// let's assume it's reasonable to do a single React.lazy() around a single React.memo() / vice-versa
type LibraryManagedAttributes<C, P> = C extends React.MemoExoticComponent<infer T> | React.LazyExoticComponent<infer T>
    ? T extends React.MemoExoticComponent<infer U> | React.LazyExoticComponent<infer U>
        ? ReactManagedAttributes<U, P>
        : ReactManagedAttributes<T, P>
    : ReactManagedAttributes<C, P>;
*/

export interface TungstenIntrinsicAttributes extends Attributes { }
export interface TungstenIntrinsicClassAttributes<T> extends ClassAttributes<T> { }

export interface TungstenIntrinsicElements {
    // HTML
    a: DetailedHTMLProps<AnchorHTMLAttributes<HTMLAnchorElement>, HTMLAnchorElement>;
    abbr: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
    address: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
    area: DetailedHTMLProps<AreaHTMLAttributes<HTMLAreaElement>, HTMLAreaElement>;
    article: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
    aside: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
    audio: DetailedHTMLProps<AudioHTMLAttributes<HTMLAudioElement>, HTMLAudioElement>;
    b: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
    base: DetailedHTMLProps<BaseHTMLAttributes<HTMLBaseElement>, HTMLBaseElement>;
    bdi: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
    bdo: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
    big: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
    blockquote: DetailedHTMLProps<BlockquoteHTMLAttributes<HTMLQuoteElement>, HTMLQuoteElement>;
    body: DetailedHTMLProps<HTMLAttributes<HTMLBodyElement>, HTMLBodyElement>;
    br: DetailedHTMLProps<HTMLAttributes<HTMLBRElement>, HTMLBRElement>;
    button: DetailedHTMLProps<ButtonHTMLAttributes<HTMLButtonElement, any>, HTMLButtonElement>;
    canvas: DetailedHTMLProps<CanvasHTMLAttributes<HTMLCanvasElement>, HTMLCanvasElement>;
    caption: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
    center: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
    cite: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
    code: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
    col: DetailedHTMLProps<ColHTMLAttributes<HTMLTableColElement>, HTMLTableColElement>;
    colgroup: DetailedHTMLProps<ColgroupHTMLAttributes<HTMLTableColElement>, HTMLTableColElement>;
    data: DetailedHTMLProps<DataHTMLAttributes<HTMLDataElement, any>, HTMLDataElement>;
    datalist: DetailedHTMLProps<HTMLAttributes<HTMLDataListElement>, HTMLDataListElement>;
    dd: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
    del: DetailedHTMLProps<DelHTMLAttributes<HTMLModElement>, HTMLModElement>;
    details: DetailedHTMLProps<DetailsHTMLAttributes<HTMLDetailsElement>, HTMLDetailsElement>;
    dfn: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
    dialog: DetailedHTMLProps<DialogHTMLAttributes<HTMLDialogElement>, HTMLDialogElement>;
    div: DetailedHTMLProps<HTMLAttributes<HTMLDivElement>, HTMLDivElement>;
    dl: DetailedHTMLProps<HTMLAttributes<HTMLDListElement>, HTMLDListElement>;
    dt: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
    em: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
    embed: DetailedHTMLProps<EmbedHTMLAttributes<HTMLEmbedElement>, HTMLEmbedElement>;
    fieldset: DetailedHTMLProps<FieldsetHTMLAttributes<HTMLFieldSetElement>, HTMLFieldSetElement>;
    figcaption: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
    figure: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
    footer: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
    form: DetailedHTMLProps<FormHTMLAttributes<HTMLFormElement>, HTMLFormElement>;
    h1: DetailedHTMLProps<HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>;
    h2: DetailedHTMLProps<HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>;
    h3: DetailedHTMLProps<HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>;
    h4: DetailedHTMLProps<HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>;
    h5: DetailedHTMLProps<HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>;
    h6: DetailedHTMLProps<HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>;
    head: DetailedHTMLProps<HTMLAttributes<HTMLHeadElement>, HTMLHeadElement>;
    header: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
    hgroup: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
    hr: DetailedHTMLProps<HTMLAttributes<HTMLHRElement>, HTMLHRElement>;
    html: DetailedHTMLProps<HtmlHTMLAttributes<HTMLHtmlElement>, HTMLHtmlElement>;
    i: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
    iframe: DetailedHTMLProps<IframeHTMLAttributes<HTMLIFrameElement>, HTMLIFrameElement>;
    img: DetailedHTMLProps<ImgHTMLAttributes<HTMLImageElement>, HTMLImageElement>;
    input: DetailedHTMLProps<InputHTMLAttributes<HTMLInputElement, any>, HTMLInputElement>;
    ins: DetailedHTMLProps<InsHTMLAttributes<HTMLModElement>, HTMLModElement>;
    kbd: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
    keygen: DetailedHTMLProps<KeygenHTMLAttributes<HTMLElement>, HTMLElement>;
    label: DetailedHTMLProps<LabelHTMLAttributes<HTMLLabelElement>, HTMLLabelElement>;
    legend: DetailedHTMLProps<HTMLAttributes<HTMLLegendElement>, HTMLLegendElement>;
    li: DetailedHTMLProps<LiHTMLAttributes<HTMLLIElement, any>, HTMLLIElement>;
    link: DetailedHTMLProps<LinkHTMLAttributes<HTMLLinkElement>, HTMLLinkElement>;
    main: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
    map: DetailedHTMLProps<MapHTMLAttributes<HTMLMapElement>, HTMLMapElement>;
    mark: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
    menu: DetailedHTMLProps<MenuHTMLAttributes<HTMLElement>, HTMLElement>;
    menuitem: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
    meta: DetailedHTMLProps<MetaHTMLAttributes<HTMLMetaElement>, HTMLMetaElement>;
    meter: DetailedHTMLProps<MeterHTMLAttributes<HTMLMeterElement, any>, HTMLMeterElement>;
    nav: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
    noindex: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
    noscript: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
    object: DetailedHTMLProps<ObjectHTMLAttributes<HTMLObjectElement>, HTMLObjectElement>;
    ol: DetailedHTMLProps<OlHTMLAttributes<HTMLOListElement>, HTMLOListElement>;
    optgroup: DetailedHTMLProps<OptgroupHTMLAttributes<HTMLOptGroupElement>, HTMLOptGroupElement>;
    option: DetailedHTMLProps<OptionHTMLAttributes<HTMLOptionElement, any>, HTMLOptionElement>;
    output: DetailedHTMLProps<OutputHTMLAttributes<HTMLOutputElement>, HTMLOutputElement>;
    p: DetailedHTMLProps<HTMLAttributes<HTMLParagraphElement>, HTMLParagraphElement>;
    param: DetailedHTMLProps<ParamHTMLAttributes<HTMLParamElement, any>, HTMLParamElement>;
    picture: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
    pre: DetailedHTMLProps<HTMLAttributes<HTMLPreElement>, HTMLPreElement>;
    progress: DetailedHTMLProps<ProgressHTMLAttributes<HTMLProgressElement, any>, HTMLProgressElement>;
    q: DetailedHTMLProps<QuoteHTMLAttributes<HTMLQuoteElement>, HTMLQuoteElement>;
    rp: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
    rt: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
    ruby: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
    s: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
    samp: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
    search: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
    slot: DetailedHTMLProps<SlotHTMLAttributes<HTMLSlotElement>, HTMLSlotElement>;
    script: DetailedHTMLProps<ScriptHTMLAttributes<HTMLScriptElement>, HTMLScriptElement>;
    section: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
    select: DetailedHTMLProps<SelectHTMLAttributes<HTMLSelectElement, any>, HTMLSelectElement>;
    small: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
    source: DetailedHTMLProps<SourceHTMLAttributes<HTMLSourceElement>, HTMLSourceElement>;
    span: DetailedHTMLProps<HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>;
    strong: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
    style: DetailedHTMLProps<StyleHTMLAttributes<HTMLStyleElement>, HTMLStyleElement>;
    sub: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
    summary: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
    sup: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
    table: DetailedHTMLProps<TableHTMLAttributes<HTMLTableElement>, HTMLTableElement>;
    template: DetailedHTMLProps<HTMLAttributes<HTMLTemplateElement>, HTMLTemplateElement>;
    tbody: DetailedHTMLProps<HTMLAttributes<HTMLTableSectionElement>, HTMLTableSectionElement>;
    td: DetailedHTMLProps<TdHTMLAttributes<HTMLTableDataCellElement>, HTMLTableDataCellElement>;
    textarea: DetailedHTMLProps<TextareaHTMLAttributes<HTMLTextAreaElement, any>, HTMLTextAreaElement>;
    tfoot: DetailedHTMLProps<HTMLAttributes<HTMLTableSectionElement>, HTMLTableSectionElement>;
    th: DetailedHTMLProps<ThHTMLAttributes<HTMLTableHeaderCellElement>, HTMLTableHeaderCellElement>;
    thead: DetailedHTMLProps<HTMLAttributes<HTMLTableSectionElement>, HTMLTableSectionElement>;
    time: DetailedHTMLProps<TimeHTMLAttributes<HTMLTimeElement>, HTMLTimeElement>;
    title: DetailedHTMLProps<HTMLAttributes<HTMLTitleElement>, HTMLTitleElement>;
    tr: DetailedHTMLProps<HTMLAttributes<HTMLTableRowElement>, HTMLTableRowElement>;
    track: DetailedHTMLProps<TrackHTMLAttributes<HTMLTrackElement>, HTMLTrackElement>;
    u: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
    ul: DetailedHTMLProps<HTMLAttributes<HTMLUListElement>, HTMLUListElement>;
    'var': DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
    video: DetailedHTMLProps<VideoHTMLAttributes<HTMLVideoElement>, HTMLVideoElement>;
    wbr: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
    webview: DetailedHTMLProps<WebViewHTMLAttributes<HTMLWebViewElement>, HTMLWebViewElement>;

    // SVG
    svg: SVGProps<SVGSVGElement>;

    animate: SVGProps<SVGElement>; // TODO: It is SVGAnimateElement but is not in TypeScript's lib.dom.d.ts for now.
    animateMotion: SVGProps<SVGElement>;
    animateTransform: SVGProps<SVGElement>; // TODO: It is SVGAnimateTransformElement but is not in TypeScript's lib.dom.d.ts for now.
    circle: SVGProps<SVGCircleElement>;
    clipPath: SVGProps<SVGClipPathElement>;
    defs: SVGProps<SVGDefsElement>;
    desc: SVGProps<SVGDescElement>;
    ellipse: SVGProps<SVGEllipseElement>;
    feBlend: SVGProps<SVGFEBlendElement>;
    feColorMatrix: SVGProps<SVGFEColorMatrixElement>;
    feComponentTransfer: SVGProps<SVGFEComponentTransferElement>;
    feComposite: SVGProps<SVGFECompositeElement>;
    feConvolveMatrix: SVGProps<SVGFEConvolveMatrixElement>;
    feDiffuseLighting: SVGProps<SVGFEDiffuseLightingElement>;
    feDisplacementMap: SVGProps<SVGFEDisplacementMapElement>;
    feDistantLight: SVGProps<SVGFEDistantLightElement>;
    feDropShadow: SVGProps<SVGFEDropShadowElement>;
    feFlood: SVGProps<SVGFEFloodElement>;
    feFuncA: SVGProps<SVGFEFuncAElement>;
    feFuncB: SVGProps<SVGFEFuncBElement>;
    feFuncG: SVGProps<SVGFEFuncGElement>;
    feFuncR: SVGProps<SVGFEFuncRElement>;
    feGaussianBlur: SVGProps<SVGFEGaussianBlurElement>;
    feImage: SVGProps<SVGFEImageElement>;
    feMerge: SVGProps<SVGFEMergeElement>;
    feMergeNode: SVGProps<SVGFEMergeNodeElement>;
    feMorphology: SVGProps<SVGFEMorphologyElement>;
    feOffset: SVGProps<SVGFEOffsetElement>;
    fePointLight: SVGProps<SVGFEPointLightElement>;
    feSpecularLighting: SVGProps<SVGFESpecularLightingElement>;
    feSpotLight: SVGProps<SVGFESpotLightElement>;
    feTile: SVGProps<SVGFETileElement>;
    feTurbulence: SVGProps<SVGFETurbulenceElement>;
    filter: SVGProps<SVGFilterElement>;
    foreignObject: SVGProps<SVGForeignObjectElement>;
    g: SVGProps<SVGGElement>;
    image: SVGProps<SVGImageElement>;
    line: SVGLineElementAttributes<SVGLineElement>;
    linearGradient: SVGProps<SVGLinearGradientElement>;
    marker: SVGProps<SVGMarkerElement>;
    mask: SVGProps<SVGMaskElement>;
    metadata: SVGProps<SVGMetadataElement>;
    mpath: SVGProps<SVGElement>;
    path: SVGProps<SVGPathElement>;
    pattern: SVGProps<SVGPatternElement>;
    polygon: SVGProps<SVGPolygonElement>;
    polyline: SVGProps<SVGPolylineElement>;
    radialGradient: SVGProps<SVGRadialGradientElement>;
    rect: SVGProps<SVGRectElement>;
    stop: SVGProps<SVGStopElement>;
    switch: SVGProps<SVGSwitchElement>;
    symbol: SVGProps<SVGSymbolElement>;
    text: SVGTextElementAttributes<SVGTextElement>;
    textPath: SVGProps<SVGTextPathElement>;
    tspan: SVGProps<SVGTSpanElement>;
    use: SVGProps<SVGUseElement>;
    view: SVGProps<SVGViewElement>;
}

type IntrinsicElement = TungstenIntrinsicElements[keyof TungstenIntrinsicElements]

type TungstenElementType = string | JSXElementConstructor<any>;
export type TungstenElement = IntrinsicElement | ContentNodeComponent
export interface TungstenElementAttributesProperty { props: {}; } // eslint-disable-line @typescript-eslint/ban-types
export interface TungstenElementChildrenAttribute { children: {}; } // eslint-disable-line @typescript-eslint/ban-types

declare global {
    namespace JSX {
        export type Element = ContentNode // ContentNode allows an array. Use Core because Element is exclusive of an array of Elements
        export interface ElementAttributesProperty extends TungstenElementAttributesProperty {}
        export interface ElementChildrenAttribute extends TungstenElementChildrenAttribute {}
        export type ElementClass = TungstenBaseComponent<any, any> | FunctionComponent<any, any>
        export interface IntrinsicAttributes extends TungstenIntrinsicAttributes { }
        export interface IntrinsicClassAttributes<T> extends TungstenIntrinsicClassAttributes<T> {}
        export interface IntrinsicElements extends TungstenIntrinsicElements {}
    }
}