isomorfeus-preact 10.5.8 → 10.6.0

data/node_modules/preact/dist/index.d.ts

@@ -0,0 +1,1295 @@
+// Generated by dts-bundle v0.7.3
+
+declare module 'preact' {
+    export as namespace preact;
+    
+    import { JSXInternal } from 'preact/jsx';
+    
+    export import JSX = JSXInternal;
+    
+    
+    export interface VNode<P = {}> {
+        type: ComponentType<P> | string;
+        props: P & { children: ComponentChildren };
+        key: Key;
+        /**
+          * ref is not guaranteed by React.ReactElement, for compatibility reasons
+          * with popular react libs we define it as optional too
+          */
+        ref?: Ref<any> | null;
+        /**
+          * The time this `vnode` started rendering. Will only be set when
+          * the devtools are attached.
+          * Default value: `0`
+          */
+        startTime?: number;
+        /**
+          * The time that the rendering of this `vnode` was completed. Will only be
+          * set when the devtools are attached.
+          * Default value: `-1`
+          */
+        endTime?: number;
+    }
+    
+    
+    export type Key = string | number | any;
+    
+    export type RefObject<T> = { current: T | null };
+    export type RefCallback<T> = (instance: T | null) => void;
+    export type Ref<T> = RefObject<T> | RefCallback<T>;
+    
+    export type ComponentChild =
+        | VNode<any>
+        | object
+        | string
+        | number
+        | bigint
+        | boolean
+        | null
+        | undefined;
+    export type ComponentChildren = ComponentChild[] | ComponentChild;
+    
+    export interface Attributes {
+        key?: Key;
+        jsx?: boolean;
+    }
+    
+    export interface ClassAttributes<T> extends Attributes {
+        ref?: Ref<T>;
+    }
+    
+    export interface PreactDOMAttributes {
+        children?: ComponentChildren;
+        dangerouslySetInnerHTML?: {
+            __html: string;
+        };
+    }
+    
+    export type RenderableProps<P, RefType = any> = P &
+        Readonly<Attributes & { children?: ComponentChildren; ref?: Ref<RefType> }>;
+    
+    export type ComponentType<P = {}> = ComponentClass<P> | FunctionComponent<P>;
+    export type ComponentFactory<P = {}> = ComponentType<P>;
+    
+    export type ComponentProps<
+        C extends ComponentType<any> | keyof JSXInternal.IntrinsicElements
+    > = C extends ComponentType<infer P>
+        ? P
+        : C extends keyof JSXInternal.IntrinsicElements
+        ? JSXInternal.IntrinsicElements[C]
+        : never;
+    
+    export interface FunctionComponent<P = {}> {
+        (props: RenderableProps<P>, context?: any): VNode<any> | null;
+        displayName?: string;
+        defaultProps?: Partial<P>;
+    }
+    export interface FunctionalComponent<P = {}> extends FunctionComponent<P> {}
+    
+    export interface ComponentClass<P = {}, S = {}> {
+        new (props: P, context?: any): Component<P, S>;
+        displayName?: string;
+        defaultProps?: Partial<P>;
+        contextType?: Context<any>;
+        getDerivedStateFromProps?(
+            props: Readonly<P>,
+            state: Readonly<S>
+        ): Partial<S> | null;
+        getDerivedStateFromError?(error: any): Partial<S> | null;
+    }
+    export interface ComponentConstructor<P = {}, S = {}>
+        extends ComponentClass<P, S> {}
+    
+    export type AnyComponent<P = {}, S = {}> =
+        | FunctionComponent<P>
+        | Component<P, S>;
+    
+    export interface Component<P = {}, S = {}> {
+        componentWillMount?(): void;
+        componentDidMount?(): void;
+        componentWillUnmount?(): void;
+        getChildContext?(): object;
+        componentWillReceiveProps?(nextProps: Readonly<P>, nextContext: any): void;
+        shouldComponentUpdate?(
+            nextProps: Readonly<P>,
+            nextState: Readonly<S>,
+            nextContext: any
+        ): boolean;
+        componentWillUpdate?(
+            nextProps: Readonly<P>,
+            nextState: Readonly<S>,
+            nextContext: any
+        ): void;
+        getSnapshotBeforeUpdate?(oldProps: Readonly<P>, oldState: Readonly<S>): any;
+        componentDidUpdate?(
+            previousProps: Readonly<P>,
+            previousState: Readonly<S>,
+            snapshot: any
+        ): void;
+        componentDidCatch?(error: any, errorInfo: any): void;
+    }
+    
+    export abstract class Component<P, S> {
+        constructor(props?: P, context?: any);
+    
+        static displayName?: string;
+        static defaultProps?: any;
+        static contextType?: Context<any>;
+    
+        // Static members cannot reference class type parameters. This is not
+        // supported in TypeScript. Reusing the same type arguments from `Component`
+        // will lead to an impossible state where one cannot satisfy the type
+        // constraint under no circumstances, see #1356.In general type arguments
+        // seem to be a bit buggy and not supported well at the time of this
+        // writing with TS 3.3.3333.
+        static getDerivedStateFromProps?(
+            props: Readonly<object>,
+            state: Readonly<object>
+        ): object | null;
+        static getDerivedStateFromError?(error: any): object | null;
+    
+        state: Readonly<S>;
+        props: RenderableProps<P>;
+        context: any;
+        base?: Element | Text;
+    
+        // From https://github.com/DefinitelyTyped/DefinitelyTyped/blob/e836acc75a78cf0655b5dfdbe81d69fdd4d8a252/types/react/index.d.ts#L402
+        // // We MUST keep setState() as a unified signature because it allows proper checking of the method return type.
+        // // See: https://github.com/DefinitelyTyped/DefinitelyTyped/issues/18365#issuecomment-351013257
+        setState<K extends keyof S>(
+            state:
+                | ((
+                        prevState: Readonly<S>,
+                        props: Readonly<P>
+                  ) => Pick<S, K> | Partial<S> | null)
+                | (Pick<S, K> | Partial<S> | null),
+            callback?: () => void
+        ): void;
+    
+        forceUpdate(callback?: () => void): void;
+    
+        abstract render(
+            props?: RenderableProps<P>,
+            state?: Readonly<S>,
+            context?: any
+        ): ComponentChild;
+    }
+    
+    
+    export function createElement(
+        type: string,
+        props:
+            | (JSXInternal.HTMLAttributes &
+                    JSXInternal.SVGAttributes &
+                    Record<string, any>)
+            | null,
+        ...children: ComponentChildren[]
+    ): VNode<any>;
+    export function createElement<P>(
+        type: ComponentType<P>,
+        props: (Attributes & P) | null,
+        ...children: ComponentChildren[]
+    ): VNode<any>;
+    export namespace createElement {
+        export import JSX = JSXInternal;
+    }
+    
+    export function h(
+        type: string,
+        props:
+            | (JSXInternal.HTMLAttributes &
+                    JSXInternal.SVGAttributes &
+                    Record<string, any>)
+            | null,
+        ...children: ComponentChildren[]
+    ): VNode<any>;
+    export function h<P>(
+        type: ComponentType<P>,
+        props: (Attributes & P) | null,
+        ...children: ComponentChildren[]
+    ): VNode<any>;
+    export namespace h {
+        export import JSX = JSXInternal;
+    }
+    
+    
+    export function render(
+        vnode: ComponentChild,
+        parent: Element | Document | ShadowRoot | DocumentFragment,
+        replaceNode?: Element | Text
+    ): void;
+    export function hydrate(
+        vnode: ComponentChild,
+        parent: Element | Document | ShadowRoot | DocumentFragment
+    ): void;
+    export function cloneElement(
+        vnode: VNode<any>,
+        props?: any,
+        ...children: ComponentChildren[]
+    ): VNode<any>;
+    export function cloneElement<P>(
+        vnode: VNode<P>,
+        props?: any,
+        ...children: ComponentChildren[]
+    ): VNode<P>;
+    
+    
+    export const Fragment: ComponentClass<{}, {}>;
+    
+    
+    /**
+      * Global options for preact
+      */
+    export interface Options {
+        /** Attach a hook that is invoked whenever a VNode is created. */
+        vnode?(vnode: VNode): void;
+        /** Attach a hook that is invoked immediately before a vnode is unmounted. */
+        unmount?(vnode: VNode): void;
+        /** Attach a hook that is invoked after a vnode has rendered. */
+        diffed?(vnode: VNode): void;
+        event?(e: Event): any;
+        requestAnimationFrame?: typeof requestAnimationFrame;
+        debounceRendering?(cb: () => void): void;
+        useDebugValue?(value: string | number): void;
+        _addHookName?(name: string | number): void;
+        __suspenseDidResolve?(vnode: VNode, cb: () => void): void;
+        // __canSuspenseResolve?(vnode: VNode, cb: () => void): void;
+    }
+    
+    export const options: Options;
+    
+    export function createRef<T = any>(): RefObject<T>;
+    export function toChildArray(
+        children: ComponentChildren
+    ): Array<VNode | string | number>;
+    export function isValidElement(vnode: any): vnode is VNode;
+    
+    export interface Consumer<T>
+        extends FunctionComponent<{
+            children: (value: T) => ComponentChildren;
+        }> {}
+    export interface PreactConsumer<T> extends Consumer<T> {}
+    
+    export interface Provider<T>
+        extends FunctionComponent<{
+            value: T;
+            children: ComponentChildren;
+        }> {}
+    export interface PreactProvider<T> extends Provider<T> {}
+    
+    export interface Context<T> {
+        Consumer: Consumer<T>;
+        Provider: Provider<T>;
+        displayName?: string;
+    }
+    export interface PreactContext<T> extends Context<T> {}
+    
+    export function createContext<T>(defaultValue: T): Context<T>;
+}
+
+declare module 'preact/jsx' {
+    
+    import {
+        ClassAttributes,
+        Component,
+        PreactDOMAttributes,
+        VNode
+    } from './';
+    
+    type Defaultize<Props, Defaults> =
+        // Distribute over unions
+        Props extends any // Make any properties included in Default optional
+            ? Partial<Pick<Props, Extract<keyof Props, keyof Defaults>>> & // Include the remaining properties from Props
+                    Pick<Props, Exclude<keyof Props, keyof Defaults>>
+            : never;
+    
+    export namespace JSXInternal {
+        export type LibraryManagedAttributes<Component, Props> = Component extends {
+            defaultProps: infer Defaults;
+        }
+            ? Defaultize<Props, Defaults>
+            : Props;
+    
+        export interface IntrinsicAttributes {
+            key?: any;
+        }
+    
+        export interface Element extends VNode<any> {}
+    
+        export interface ElementClass extends Component<any, any> {}
+    
+        export interface ElementAttributesProperty {
+            props: any;
+        }
+    
+        export interface ElementChildrenAttribute {
+            children: any;
+        }
+    
+        export type DOMCSSProperties = {
+            [key in keyof Omit<
+                CSSStyleDeclaration,
+                | 'item'
+                | 'setProperty'
+                | 'removeProperty'
+                | 'getPropertyValue'
+                | 'getPropertyPriority'
+            >]?: string | number | null | undefined;
+        };
+        export type AllCSSProperties = {
+            [key: string]: string | number | null | undefined;
+        };
+        export interface CSSProperties extends AllCSSProperties, DOMCSSProperties {
+            cssText?: string | null;
+        }
+    
+        export interface SVGAttributes<Target extends EventTarget = SVGElement>
+            extends HTMLAttributes<Target> {
+            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;
+        }
+    
+        export interface PathAttributes {
+            d: string;
+        }
+    
+        export type TargetedEvent<
+            Target extends EventTarget = EventTarget,
+            TypedEvent extends Event = Event
+        > = Omit<TypedEvent, 'currentTarget'> & {
+            readonly currentTarget: Target;
+        };
+    
+        export type TargetedAnimationEvent<
+            Target extends EventTarget
+        > = TargetedEvent<Target, AnimationEvent>;
+        export type TargetedClipboardEvent<
+            Target extends EventTarget
+        > = TargetedEvent<Target, ClipboardEvent>;
+        export type TargetedCompositionEvent<
+            Target extends EventTarget
+        > = TargetedEvent<Target, CompositionEvent>;
+        export type TargetedDragEvent<Target extends EventTarget> = TargetedEvent<
+            Target,
+            DragEvent
+        >;
+        export type TargetedFocusEvent<Target extends EventTarget> = TargetedEvent<
+            Target,
+            FocusEvent
+        >;
+        export type TargetedKeyboardEvent<Target extends EventTarget> = TargetedEvent<
+            Target,
+            KeyboardEvent
+        >;
+        export type TargetedMouseEvent<Target extends EventTarget> = TargetedEvent<
+            Target,
+            MouseEvent
+        >;
+        export type TargetedPointerEvent<Target extends EventTarget> = TargetedEvent<
+            Target,
+            PointerEvent
+        >;
+        export type TargetedTouchEvent<Target extends EventTarget> = TargetedEvent<
+            Target,
+            TouchEvent
+        >;
+        export type TargetedTransitionEvent<
+            Target extends EventTarget
+        > = TargetedEvent<Target, TransitionEvent>;
+        export type TargetedUIEvent<Target extends EventTarget> = TargetedEvent<
+            Target,
+            UIEvent
+        >;
+        export type TargetedWheelEvent<Target extends EventTarget> = TargetedEvent<
+            Target,
+            WheelEvent
+        >;
+    
+        export interface EventHandler<E extends TargetedEvent> {
+            /**
+              * The `this` keyword always points to the DOM element the event handler
+              * was invoked on. See: https://developer.mozilla.org/en-US/docs/Web/Guide/Events/Event_handlers#Event_handlers_parameters_this_binding_and_the_return_value
+              */
+            (this: never, event: E): void;
+        }
+    
+        export type AnimationEventHandler<Target extends EventTarget> = EventHandler<
+            TargetedAnimationEvent<Target>
+        >;
+        export type ClipboardEventHandler<Target extends EventTarget> = EventHandler<
+            TargetedClipboardEvent<Target>
+        >;
+        export type CompositionEventHandler<
+            Target extends EventTarget
+        > = EventHandler<TargetedCompositionEvent<Target>>;
+        export type DragEventHandler<Target extends EventTarget> = EventHandler<
+            TargetedDragEvent<Target>
+        >;
+        export type FocusEventHandler<Target extends EventTarget> = EventHandler<
+            TargetedFocusEvent<Target>
+        >;
+        export type GenericEventHandler<Target extends EventTarget> = EventHandler<
+            TargetedEvent<Target>
+        >;
+        export type KeyboardEventHandler<Target extends EventTarget> = EventHandler<
+            TargetedKeyboardEvent<Target>
+        >;
+        export type MouseEventHandler<Target extends EventTarget> = EventHandler<
+            TargetedMouseEvent<Target>
+        >;
+        export type PointerEventHandler<Target extends EventTarget> = EventHandler<
+            TargetedPointerEvent<Target>
+        >;
+        export type TouchEventHandler<Target extends EventTarget> = EventHandler<
+            TargetedTouchEvent<Target>
+        >;
+        export type TransitionEventHandler<Target extends EventTarget> = EventHandler<
+            TargetedTransitionEvent<Target>
+        >;
+        export type UIEventHandler<Target extends EventTarget> = EventHandler<
+            TargetedUIEvent<Target>
+        >;
+        export type WheelEventHandler<Target extends EventTarget> = EventHandler<
+            TargetedWheelEvent<Target>
+        >;
+    
+        export interface DOMAttributes<Target extends EventTarget>
+            extends PreactDOMAttributes {
+            // Image Events
+            onLoad?: GenericEventHandler<Target>;
+            onLoadCapture?: GenericEventHandler<Target>;
+            onError?: GenericEventHandler<Target>;
+            onErrorCapture?: GenericEventHandler<Target>;
+    
+            // Clipboard Events
+            onCopy?: ClipboardEventHandler<Target>;
+            onCopyCapture?: ClipboardEventHandler<Target>;
+            onCut?: ClipboardEventHandler<Target>;
+            onCutCapture?: ClipboardEventHandler<Target>;
+            onPaste?: ClipboardEventHandler<Target>;
+            onPasteCapture?: ClipboardEventHandler<Target>;
+    
+            // Composition Events
+            onCompositionEnd?: CompositionEventHandler<Target>;
+            onCompositionEndCapture?: CompositionEventHandler<Target>;
+            onCompositionStart?: CompositionEventHandler<Target>;
+            onCompositionStartCapture?: CompositionEventHandler<Target>;
+            onCompositionUpdate?: CompositionEventHandler<Target>;
+            onCompositionUpdateCapture?: CompositionEventHandler<Target>;
+    
+            // Details Events
+            onToggle?: GenericEventHandler<Target>;
+    
+            // Focus Events
+            onFocus?: FocusEventHandler<Target>;
+            onFocusCapture?: FocusEventHandler<Target>;
+            onfocusin?: FocusEventHandler<Target>;
+            onfocusinCapture?: FocusEventHandler<Target>;
+            onfocusout?: FocusEventHandler<Target>;
+            onfocusoutCapture?: FocusEventHandler<Target>;
+            onBlur?: FocusEventHandler<Target>;
+            onBlurCapture?: FocusEventHandler<Target>;
+    
+            // Form Events
+            onChange?: GenericEventHandler<Target>;
+            onChangeCapture?: GenericEventHandler<Target>;
+            onInput?: GenericEventHandler<Target>;
+            onInputCapture?: GenericEventHandler<Target>;
+            onBeforeInput?: GenericEventHandler<Target>;
+            onBeforeInputCapture?: GenericEventHandler<Target>;
+            onSearch?: GenericEventHandler<Target>;
+            onSearchCapture?: GenericEventHandler<Target>;
+            onSubmit?: GenericEventHandler<Target>;
+            onSubmitCapture?: GenericEventHandler<Target>;
+            onInvalid?: GenericEventHandler<Target>;
+            onInvalidCapture?: GenericEventHandler<Target>;
+            onReset?: GenericEventHandler<Target>;
+            onResetCapture?: GenericEventHandler<Target>;
+            onFormData?: GenericEventHandler<Target>;
+            onFormDataCapture?: GenericEventHandler<Target>;
+    
+            // Keyboard Events
+            onKeyDown?: KeyboardEventHandler<Target>;
+            onKeyDownCapture?: KeyboardEventHandler<Target>;
+            onKeyPress?: KeyboardEventHandler<Target>;
+            onKeyPressCapture?: KeyboardEventHandler<Target>;
+            onKeyUp?: KeyboardEventHandler<Target>;
+            onKeyUpCapture?: KeyboardEventHandler<Target>;
+    
+            // Media Events
+            onAbort?: GenericEventHandler<Target>;
+            onAbortCapture?: GenericEventHandler<Target>;
+            onCanPlay?: GenericEventHandler<Target>;
+            onCanPlayCapture?: GenericEventHandler<Target>;
+            onCanPlayThrough?: GenericEventHandler<Target>;
+            onCanPlayThroughCapture?: GenericEventHandler<Target>;
+            onDurationChange?: GenericEventHandler<Target>;
+            onDurationChangeCapture?: GenericEventHandler<Target>;
+            onEmptied?: GenericEventHandler<Target>;
+            onEmptiedCapture?: GenericEventHandler<Target>;
+            onEncrypted?: GenericEventHandler<Target>;
+            onEncryptedCapture?: GenericEventHandler<Target>;
+            onEnded?: GenericEventHandler<Target>;
+            onEndedCapture?: GenericEventHandler<Target>;
+            onLoadedData?: GenericEventHandler<Target>;
+            onLoadedDataCapture?: GenericEventHandler<Target>;
+            onLoadedMetadata?: GenericEventHandler<Target>;
+            onLoadedMetadataCapture?: GenericEventHandler<Target>;
+            onLoadStart?: GenericEventHandler<Target>;
+            onLoadStartCapture?: GenericEventHandler<Target>;
+            onPause?: GenericEventHandler<Target>;
+            onPauseCapture?: GenericEventHandler<Target>;
+            onPlay?: GenericEventHandler<Target>;
+            onPlayCapture?: GenericEventHandler<Target>;
+            onPlaying?: GenericEventHandler<Target>;
+            onPlayingCapture?: GenericEventHandler<Target>;
+            onProgress?: GenericEventHandler<Target>;
+            onProgressCapture?: GenericEventHandler<Target>;
+            onRateChange?: GenericEventHandler<Target>;
+            onRateChangeCapture?: GenericEventHandler<Target>;
+            onSeeked?: GenericEventHandler<Target>;
+            onSeekedCapture?: GenericEventHandler<Target>;
+            onSeeking?: GenericEventHandler<Target>;
+            onSeekingCapture?: GenericEventHandler<Target>;
+            onStalled?: GenericEventHandler<Target>;
+            onStalledCapture?: GenericEventHandler<Target>;
+            onSuspend?: GenericEventHandler<Target>;
+            onSuspendCapture?: GenericEventHandler<Target>;
+            onTimeUpdate?: GenericEventHandler<Target>;
+            onTimeUpdateCapture?: GenericEventHandler<Target>;
+            onVolumeChange?: GenericEventHandler<Target>;
+            onVolumeChangeCapture?: GenericEventHandler<Target>;
+            onWaiting?: GenericEventHandler<Target>;
+            onWaitingCapture?: GenericEventHandler<Target>;
+    
+            // MouseEvents
+            onClick?: MouseEventHandler<Target>;
+            onClickCapture?: MouseEventHandler<Target>;
+            onContextMenu?: MouseEventHandler<Target>;
+            onContextMenuCapture?: MouseEventHandler<Target>;
+            onDblClick?: MouseEventHandler<Target>;
+            onDblClickCapture?: MouseEventHandler<Target>;
+            onDrag?: DragEventHandler<Target>;
+            onDragCapture?: DragEventHandler<Target>;
+            onDragEnd?: DragEventHandler<Target>;
+            onDragEndCapture?: DragEventHandler<Target>;
+            onDragEnter?: DragEventHandler<Target>;
+            onDragEnterCapture?: DragEventHandler<Target>;
+            onDragExit?: DragEventHandler<Target>;
+            onDragExitCapture?: DragEventHandler<Target>;
+            onDragLeave?: DragEventHandler<Target>;
+            onDragLeaveCapture?: DragEventHandler<Target>;
+            onDragOver?: DragEventHandler<Target>;
+            onDragOverCapture?: DragEventHandler<Target>;
+            onDragStart?: DragEventHandler<Target>;
+            onDragStartCapture?: DragEventHandler<Target>;
+            onDrop?: DragEventHandler<Target>;
+            onDropCapture?: DragEventHandler<Target>;
+            onMouseDown?: MouseEventHandler<Target>;
+            onMouseDownCapture?: MouseEventHandler<Target>;
+            onMouseEnter?: MouseEventHandler<Target>;
+            onMouseEnterCapture?: MouseEventHandler<Target>;
+            onMouseLeave?: MouseEventHandler<Target>;
+            onMouseLeaveCapture?: MouseEventHandler<Target>;
+            onMouseMove?: MouseEventHandler<Target>;
+            onMouseMoveCapture?: MouseEventHandler<Target>;
+            onMouseOut?: MouseEventHandler<Target>;
+            onMouseOutCapture?: MouseEventHandler<Target>;
+            onMouseOver?: MouseEventHandler<Target>;
+            onMouseOverCapture?: MouseEventHandler<Target>;
+            onMouseUp?: MouseEventHandler<Target>;
+            onMouseUpCapture?: MouseEventHandler<Target>;
+    
+            // Selection Events
+            onSelect?: GenericEventHandler<Target>;
+            onSelectCapture?: GenericEventHandler<Target>;
+    
+            // Touch Events
+            onTouchCancel?: TouchEventHandler<Target>;
+            onTouchCancelCapture?: TouchEventHandler<Target>;
+            onTouchEnd?: TouchEventHandler<Target>;
+            onTouchEndCapture?: TouchEventHandler<Target>;
+            onTouchMove?: TouchEventHandler<Target>;
+            onTouchMoveCapture?: TouchEventHandler<Target>;
+            onTouchStart?: TouchEventHandler<Target>;
+            onTouchStartCapture?: TouchEventHandler<Target>;
+    
+            // Pointer Events
+            onPointerOver?: PointerEventHandler<Target>;
+            onPointerOverCapture?: PointerEventHandler<Target>;
+            onPointerEnter?: PointerEventHandler<Target>;
+            onPointerEnterCapture?: PointerEventHandler<Target>;
+            onPointerDown?: PointerEventHandler<Target>;
+            onPointerDownCapture?: PointerEventHandler<Target>;
+            onPointerMove?: PointerEventHandler<Target>;
+            onPointerMoveCapture?: PointerEventHandler<Target>;
+            onPointerUp?: PointerEventHandler<Target>;
+            onPointerUpCapture?: PointerEventHandler<Target>;
+            onPointerCancel?: PointerEventHandler<Target>;
+            onPointerCancelCapture?: PointerEventHandler<Target>;
+            onPointerOut?: PointerEventHandler<Target>;
+            onPointerOutCapture?: PointerEventHandler<Target>;
+            onPointerLeave?: PointerEventHandler<Target>;
+            onPointerLeaveCapture?: PointerEventHandler<Target>;
+            onGotPointerCapture?: PointerEventHandler<Target>;
+            onGotPointerCaptureCapture?: PointerEventHandler<Target>;
+            onLostPointerCapture?: PointerEventHandler<Target>;
+            onLostPointerCaptureCapture?: PointerEventHandler<Target>;
+    
+            // UI Events
+            onScroll?: UIEventHandler<Target>;
+            onScrollCapture?: UIEventHandler<Target>;
+    
+            // Wheel Events
+            onWheel?: WheelEventHandler<Target>;
+            onWheelCapture?: WheelEventHandler<Target>;
+    
+            // Animation Events
+            onAnimationStart?: AnimationEventHandler<Target>;
+            onAnimationStartCapture?: AnimationEventHandler<Target>;
+            onAnimationEnd?: AnimationEventHandler<Target>;
+            onAnimationEndCapture?: AnimationEventHandler<Target>;
+            onAnimationIteration?: AnimationEventHandler<Target>;
+            onAnimationIterationCapture?: AnimationEventHandler<Target>;
+    
+            // Transition Events
+            onTransitionEnd?: TransitionEventHandler<Target>;
+            onTransitionEndCapture?: TransitionEventHandler<Target>;
+        }
+    
+        export interface HTMLAttributes<RefType extends EventTarget = EventTarget>
+            extends ClassAttributes<RefType>,
+                DOMAttributes<RefType> {
+            // Standard HTML Attributes
+            accept?: string;
+            acceptCharset?: string;
+            accessKey?: string;
+            action?: string;
+            allow?: string;
+            allowFullScreen?: boolean;
+            allowTransparency?: boolean;
+            alt?: string;
+            as?: string;
+            async?: boolean;
+            autocomplete?: string;
+            autoComplete?: string;
+            autocorrect?: string;
+            autoCorrect?: string;
+            autofocus?: boolean;
+            autoFocus?: boolean;
+            autoPlay?: boolean;
+            capture?: boolean | string;
+            cellPadding?: number | string;
+            cellSpacing?: number | string;
+            charSet?: string;
+            challenge?: string;
+            checked?: boolean;
+            cite?: string;
+            class?: string;
+            className?: string;
+            cols?: number;
+            colSpan?: number;
+            content?: string;
+            contentEditable?: boolean;
+            contextMenu?: string;
+            controls?: boolean;
+            controlsList?: string;
+            coords?: string;
+            crossOrigin?: string;
+            data?: string;
+            dateTime?: string;
+            default?: boolean;
+            defer?: boolean;
+            dir?: 'auto' | 'rtl' | 'ltr';
+            disabled?: boolean;
+            disableRemotePlayback?: boolean;
+            download?: any;
+            decoding?: 'sync' | 'async' | 'auto';
+            draggable?: boolean;
+            encType?: string;
+            enterkeyhint?:
+                | 'enter'
+                | 'done'
+                | 'go'
+                | 'next'
+                | 'previous'
+                | 'search'
+                | 'send';
+            form?: string;
+            formAction?: string;
+            formEncType?: string;
+            formMethod?: string;
+            formNoValidate?: boolean;
+            formTarget?: string;
+            frameBorder?: number | string;
+            headers?: string;
+            height?: number | string;
+            hidden?: boolean;
+            high?: number;
+            href?: string;
+            hrefLang?: string;
+            for?: string;
+            htmlFor?: string;
+            httpEquiv?: string;
+            icon?: string;
+            id?: string;
+            inputMode?: string;
+            integrity?: string;
+            is?: string;
+            keyParams?: string;
+            keyType?: string;
+            kind?: string;
+            label?: string;
+            lang?: string;
+            list?: string;
+            loading?: 'eager' | 'lazy';
+            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;
+            nomodule?: boolean;
+            nonce?: string;
+            noValidate?: boolean;
+            open?: boolean;
+            optimum?: number;
+            pattern?: string;
+            ping?: string;
+            placeholder?: string;
+            playsInline?: boolean;
+            poster?: string;
+            preload?: string;
+            radioGroup?: string;
+            readonly?: boolean;
+            readOnly?: boolean;
+            referrerpolicy?:
+                | 'no-referrer'
+                | 'no-referrer-when-downgrade'
+                | 'origin'
+                | 'origin-when-cross-origin'
+                | 'same-origin'
+                | 'strict-origin'
+                | 'strict-origin-when-cross-origin'
+                | 'unsafe-url';
+            rel?: string;
+            required?: boolean;
+            reversed?: boolean;
+            role?: string;
+            rows?: number;
+            rowSpan?: number;
+            sandbox?: string;
+            scope?: string;
+            scoped?: boolean;
+            scrolling?: string;
+            seamless?: boolean;
+            selected?: boolean;
+            shape?: string;
+            size?: number;
+            sizes?: string;
+            slot?: string;
+            span?: number;
+            spellcheck?: boolean;
+            spellCheck?: boolean;
+            src?: string;
+            srcset?: string;
+            srcDoc?: string;
+            srcLang?: string;
+            srcSet?: string;
+            start?: number;
+            step?: number | string;
+            style?: string | CSSProperties;
+            summary?: string;
+            tabIndex?: number;
+            target?: string;
+            title?: string;
+            type?: string;
+            useMap?: string;
+            value?: string | string[] | number;
+            volume?: string | number;
+            width?: number | string;
+            wmode?: string;
+            wrap?: string;
+    
+            // Non-standard Attributes
+            autocapitalize?:
+                | 'off'
+                | 'none'
+                | 'on'
+                | 'sentences'
+                | 'words'
+                | 'characters';
+            autoCapitalize?:
+                | 'off'
+                | 'none'
+                | 'on'
+                | 'sentences'
+                | 'words'
+                | 'characters';
+            disablePictureInPicture?: boolean;
+            results?: number;
+            translate?: 'yes' | 'no';
+    
+            // RDFa Attributes
+            about?: string;
+            datatype?: string;
+            inlist?: any;
+            prefix?: string;
+            property?: string;
+            resource?: string;
+            typeof?: string;
+            vocab?: string;
+    
+            // Microdata Attributes
+            itemProp?: string;
+            itemScope?: boolean;
+            itemType?: string;
+            itemID?: string;
+            itemRef?: string;
+        }
+    
+        export interface HTMLMarqueeElement extends HTMLElement {
+            behavior?: 'scroll' | 'slide' | 'alternate';
+            bgColor?: string;
+            direction?: 'left' | 'right' | 'up' | 'down';
+            height?: number | string;
+            hspace?: number | string;
+            loop?: number | string;
+            scrollAmount?: number | string;
+            scrollDelay?: number | string;
+            trueSpeed?: boolean;
+            vspace?: number | string;
+            width?: number | string;
+        }
+    
+        export interface IntrinsicElements {
+            // HTML
+            a: HTMLAttributes<HTMLAnchorElement>;
+            abbr: HTMLAttributes<HTMLElement>;
+            address: HTMLAttributes<HTMLElement>;
+            area: HTMLAttributes<HTMLAreaElement>;
+            article: HTMLAttributes<HTMLElement>;
+            aside: HTMLAttributes<HTMLElement>;
+            audio: HTMLAttributes<HTMLAudioElement>;
+            b: HTMLAttributes<HTMLElement>;
+            base: HTMLAttributes<HTMLBaseElement>;
+            bdi: HTMLAttributes<HTMLElement>;
+            bdo: HTMLAttributes<HTMLElement>;
+            big: HTMLAttributes<HTMLElement>;
+            blockquote: HTMLAttributes<HTMLQuoteElement>;
+            body: HTMLAttributes<HTMLBodyElement>;
+            br: HTMLAttributes<HTMLBRElement>;
+            button: HTMLAttributes<HTMLButtonElement>;
+            canvas: HTMLAttributes<HTMLCanvasElement>;
+            caption: HTMLAttributes<HTMLTableCaptionElement>;
+            cite: HTMLAttributes<HTMLElement>;
+            code: HTMLAttributes<HTMLElement>;
+            col: HTMLAttributes<HTMLTableColElement>;
+            colgroup: HTMLAttributes<HTMLTableColElement>;
+            data: HTMLAttributes<HTMLDataElement>;
+            datalist: HTMLAttributes<HTMLDataListElement>;
+            dd: HTMLAttributes<HTMLElement>;
+            del: HTMLAttributes<HTMLModElement>;
+            details: HTMLAttributes<HTMLDetailsElement>;
+            dfn: HTMLAttributes<HTMLElement>;
+            dialog: HTMLAttributes<HTMLDialogElement>;
+            div: HTMLAttributes<HTMLDivElement>;
+            dl: HTMLAttributes<HTMLDListElement>;
+            dt: HTMLAttributes<HTMLElement>;
+            em: HTMLAttributes<HTMLElement>;
+            embed: HTMLAttributes<HTMLEmbedElement>;
+            fieldset: HTMLAttributes<HTMLFieldSetElement>;
+            figcaption: HTMLAttributes<HTMLElement>;
+            figure: HTMLAttributes<HTMLElement>;
+            footer: HTMLAttributes<HTMLElement>;
+            form: HTMLAttributes<HTMLFormElement>;
+            h1: HTMLAttributes<HTMLHeadingElement>;
+            h2: HTMLAttributes<HTMLHeadingElement>;
+            h3: HTMLAttributes<HTMLHeadingElement>;
+            h4: HTMLAttributes<HTMLHeadingElement>;
+            h5: HTMLAttributes<HTMLHeadingElement>;
+            h6: HTMLAttributes<HTMLHeadingElement>;
+            head: HTMLAttributes<HTMLHeadElement>;
+            header: HTMLAttributes<HTMLElement>;
+            hgroup: HTMLAttributes<HTMLElement>;
+            hr: HTMLAttributes<HTMLHRElement>;
+            html: HTMLAttributes<HTMLHtmlElement>;
+            i: HTMLAttributes<HTMLElement>;
+            iframe: HTMLAttributes<HTMLIFrameElement>;
+            img: HTMLAttributes<HTMLImageElement>;
+            input: HTMLAttributes<HTMLInputElement>;
+            ins: HTMLAttributes<HTMLModElement>;
+            kbd: HTMLAttributes<HTMLElement>;
+            keygen: HTMLAttributes<HTMLUnknownElement>;
+            label: HTMLAttributes<HTMLLabelElement>;
+            legend: HTMLAttributes<HTMLLegendElement>;
+            li: HTMLAttributes<HTMLLIElement>;
+            link: HTMLAttributes<HTMLLinkElement>;
+            main: HTMLAttributes<HTMLElement>;
+            map: HTMLAttributes<HTMLMapElement>;
+            mark: HTMLAttributes<HTMLElement>;
+            marquee: HTMLAttributes<HTMLMarqueeElement>;
+            menu: HTMLAttributes<HTMLMenuElement>;
+            menuitem: HTMLAttributes<HTMLUnknownElement>;
+            meta: HTMLAttributes<HTMLMetaElement>;
+            meter: HTMLAttributes<HTMLMeterElement>;
+            nav: HTMLAttributes<HTMLElement>;
+            noscript: HTMLAttributes<HTMLElement>;
+            object: HTMLAttributes<HTMLObjectElement>;
+            ol: HTMLAttributes<HTMLOListElement>;
+            optgroup: HTMLAttributes<HTMLOptGroupElement>;
+            option: HTMLAttributes<HTMLOptionElement>;
+            output: HTMLAttributes<HTMLOutputElement>;
+            p: HTMLAttributes<HTMLParagraphElement>;
+            param: HTMLAttributes<HTMLParamElement>;
+            picture: HTMLAttributes<HTMLPictureElement>;
+            pre: HTMLAttributes<HTMLPreElement>;
+            progress: HTMLAttributes<HTMLProgressElement>;
+            q: HTMLAttributes<HTMLQuoteElement>;
+            rp: HTMLAttributes<HTMLElement>;
+            rt: HTMLAttributes<HTMLElement>;
+            ruby: HTMLAttributes<HTMLElement>;
+            s: HTMLAttributes<HTMLElement>;
+            samp: HTMLAttributes<HTMLElement>;
+            script: HTMLAttributes<HTMLScriptElement>;
+            section: HTMLAttributes<HTMLElement>;
+            select: HTMLAttributes<HTMLSelectElement>;
+            slot: HTMLAttributes<HTMLSlotElement>;
+            small: HTMLAttributes<HTMLElement>;
+            source: HTMLAttributes<HTMLSourceElement>;
+            span: HTMLAttributes<HTMLSpanElement>;
+            strong: HTMLAttributes<HTMLElement>;
+            style: HTMLAttributes<HTMLStyleElement>;
+            sub: HTMLAttributes<HTMLElement>;
+            summary: HTMLAttributes<HTMLElement>;
+            sup: HTMLAttributes<HTMLElement>;
+            table: HTMLAttributes<HTMLTableElement>;
+            tbody: HTMLAttributes<HTMLTableSectionElement>;
+            td: HTMLAttributes<HTMLTableCellElement>;
+            textarea: HTMLAttributes<HTMLTextAreaElement>;
+            tfoot: HTMLAttributes<HTMLTableSectionElement>;
+            th: HTMLAttributes<HTMLTableCellElement>;
+            thead: HTMLAttributes<HTMLTableSectionElement>;
+            time: HTMLAttributes<HTMLTimeElement>;
+            title: HTMLAttributes<HTMLTitleElement>;
+            tr: HTMLAttributes<HTMLTableRowElement>;
+            track: HTMLAttributes<HTMLTrackElement>;
+            u: HTMLAttributes<HTMLElement>;
+            ul: HTMLAttributes<HTMLUListElement>;
+            var: HTMLAttributes<HTMLElement>;
+            video: HTMLAttributes<HTMLVideoElement>;
+            wbr: HTMLAttributes<HTMLElement>;
+    
+            //SVG
+            svg: SVGAttributes<SVGSVGElement>;
+            animate: SVGAttributes<SVGAnimateElement>;
+            circle: SVGAttributes<SVGCircleElement>;
+            animateTransform: SVGAttributes<SVGAnimateElement>;
+            clipPath: SVGAttributes<SVGClipPathElement>;
+            defs: SVGAttributes<SVGDefsElement>;
+            desc: SVGAttributes<SVGDescElement>;
+            ellipse: SVGAttributes<SVGEllipseElement>;
+            feBlend: SVGAttributes<SVGFEBlendElement>;
+            feColorMatrix: SVGAttributes<SVGFEColorMatrixElement>;
+            feComponentTransfer: SVGAttributes<SVGFEComponentTransferElement>;
+            feComposite: SVGAttributes<SVGFECompositeElement>;
+            feConvolveMatrix: SVGAttributes<SVGFEConvolveMatrixElement>;
+            feDiffuseLighting: SVGAttributes<SVGFEDiffuseLightingElement>;
+            feDisplacementMap: SVGAttributes<SVGFEDisplacementMapElement>;
+            feDropShadow: SVGAttributes<SVGFEDropShadowElement>;
+            feFlood: SVGAttributes<SVGFEFloodElement>;
+            feFuncA: SVGAttributes<SVGFEFuncAElement>;
+            feFuncB: SVGAttributes<SVGFEFuncBElement>;
+            feFuncG: SVGAttributes<SVGFEFuncGElement>;
+            feFuncR: SVGAttributes<SVGFEFuncRElement>;
+            feGaussianBlur: SVGAttributes<SVGFEGaussianBlurElement>;
+            feImage: SVGAttributes<SVGFEImageElement>;
+            feMerge: SVGAttributes<SVGFEMergeElement>;
+            feMergeNode: SVGAttributes<SVGFEMergeNodeElement>;
+            feMorphology: SVGAttributes<SVGFEMorphologyElement>;
+            feOffset: SVGAttributes<SVGFEOffsetElement>;
+            feSpecularLighting: SVGAttributes<SVGFESpecularLightingElement>;
+            feTile: SVGAttributes<SVGFETileElement>;
+            feTurbulence: SVGAttributes<SVGFETurbulenceElement>;
+            filter: SVGAttributes<SVGFilterElement>;
+            foreignObject: SVGAttributes<SVGForeignObjectElement>;
+            g: SVGAttributes<SVGGElement>;
+            image: SVGAttributes<SVGImageElement>;
+            line: SVGAttributes<SVGLineElement>;
+            linearGradient: SVGAttributes<SVGLinearGradientElement>;
+            marker: SVGAttributes<SVGMarkerElement>;
+            mask: SVGAttributes<SVGMaskElement>;
+            path: SVGAttributes<SVGPathElement>;
+            pattern: SVGAttributes<SVGPatternElement>;
+            polygon: SVGAttributes<SVGPolygonElement>;
+            polyline: SVGAttributes<SVGPolylineElement>;
+            radialGradient: SVGAttributes<SVGRadialGradientElement>;
+            rect: SVGAttributes<SVGRectElement>;
+            stop: SVGAttributes<SVGStopElement>;
+            symbol: SVGAttributes<SVGSymbolElement>;
+            text: SVGAttributes<SVGTextElement>;
+            tspan: SVGAttributes<SVGTSpanElement>;
+            use: SVGAttributes<SVGUseElement>;
+        }
+    }
+}
+