@arcgis/lumina 4.31.0-next.84

package/dist/jsx/jsx.d.ts

@@ -0,0 +1,2004 @@
+/**
+ * This reference directive is removed by tsup at compile time. It is only
+ * needed to correctly type-check this package. For consumers of this package,
+ * they should have an `./src/lumina.ts` file like so:
+ * ```ts
+ * /// <reference types="@arcgis/lumina/typings" />
+ * ```
+ */
+/// <reference path="../typings/jsxGlobals.d.ts" />
+import type { Properties as CssProperties } from "csstype";
+import type { TemplateResult } from "lit-html";
+import type { DirectiveResult } from "lit-html/directive.js";
+import type { ClassMapDirective } from "lit-html/directives/class-map.js";
+import type { StyleMapDirective } from "lit-html/directives/style-map.js";
+import type { Ref } from "lit-html/directives/ref.js";
+import type { ClassInfo } from "lit/directives/class-map.js";
+import type { DirectiveClass } from "lit/directive.js";
+/**
+ * The "h" namespace is used to import JSX types for elements and attributes.
+ * It is imported in order to avoid conflicting global JSX issues.
+ */
+export declare namespace h {
+    export function h(sel: any, data?: any, text?: any): TemplateResult;
+    export type { LitJsx as JSX };
+}
+/**
+ * Fragment
+ *
+ * @remarks
+ * This function is not actually defined in the code since references to it will
+ * be removed at build time by the jsxToLitHtml plugin.
+ */
+export declare function Fragment(props: {
+    children?: JsxNode;
+}): TemplateResult;
+/**
+ * @remarks
+ * This function is not actually defined in the code since references to it will
+ * be removed at build time by the jsxToLitHtml plugin.
+ */
+export declare function h(sel: any, data?: any, text?: any): TemplateResult;
+/**
+ * @remarks
+ * This function is not actually defined in the code since references to it will
+ * be removed at build time by the jsxToLitHtml plugin.
+ */
+export declare function jsx(type: string, props: unknown, key?: unknown): JsxNode;
+/**
+ * @remarks
+ * This function is not actually defined in the code since references to it will
+ * be removed at build time by the jsxToLitHtml plugin.
+ */
+export declare function jsxs(type: string, props: unknown, key?: unknown): JsxNode;
+/**
+ * The JSX to lit-html conversion has a heuristic to determine whether a prop
+ * should be converted to a property or attribute at runtime. In cases where
+ * that heuristic is not sufficient, you can use the `bindAttribute()` function to
+ * explicitly tell the conversion to treat the prop as an attribute.
+ *
+ * This function call will be erased at build-time, thus it has no runtime
+ * impact. But that also means you should not call this function anywhere other
+ * than at the top level of a JSX prop value
+ *
+ * @example
+ * ```tsx
+ * <my-component
+ *   name={bindAttribute("Pass name as attribute rather than property")}
+ * />
+ * ```
+ *
+ * Will be converted at build time into:
+ * ```ts
+ * html`<my-component name="Pass name as attribute rather than property"></my-component>`
+ * ```
+ *
+ * @remarks
+ * If you often encounter cases where the JSX to lit-html incorrectly converts
+ * the prop to a property necessitating the use of `bindAttribute()`, please open
+ * an issue for Lumina.
+ */
+export declare const bindAttribute: <T>(value: T) => T;
+/**
+ * The JSX to lit-html conversion has a heuristic to determine whether a prop
+ * should be converted to a property, attribute or boolean attribute at runtime.
+ * In cases where that heuristic is not sufficient, you can use the
+ * `bindBooleanAttribute()` function to explicitly tell the conversion to treat the
+ * prop as a boolean attribute.
+ *
+ * This function call will be erased at build-time, thus it has no runtime
+ * impact. But that also means you should not call this function anywhere other
+ * than at the top level of a JSX prop value
+ *
+ * @see https://lit.dev/docs/templates/expressions/#boolean-attribute-expressions
+ *
+ * @example
+ * ```tsx
+ * <my-component
+ *   checked={bindBooleanAttribute(myBoolean)}
+ * />
+ * ```
+ *
+ * Will be converted at build time into:
+ * ```ts
+ * html`<my-component ?checked=${myBoolean}></my-component>`
+ * ```
+ *
+ * @remarks
+ * If you often encounter cases where the JSX to lit-html incorrectly converts
+ * the prop necessitating the use of `bindBooleanAttribute()`, please open
+ * an issue for Lumina.
+ */
+export declare const bindBooleanAttribute: <T>(value: T) => T;
+/**
+ * The JSX to lit-html conversion has a heuristic to determine whether a prop
+ * should be converted to a property or attribute at runtime. In cases where
+ * that heuristic is not sufficient, you can use the `bindProperty()` function to
+ * explicitly tell the conversion to treat the prop as a property.
+ *
+ * This function call will be erased at build-time, thus it has no runtime
+ * impact. But that also means you should not call this function anywhere other
+ * than at the top level of a JSX prop value
+ *
+ * @example
+ * ```tsx
+ * <my-component
+ *   my-prop={bindProperty("Pass my-prop as a property rather than attribute")}
+ * />
+ * ```
+ *
+ * Will be converted at build time into:
+ * ```ts
+ * html`<my-component .my-prop="Pass my-prop as a property rather than attribute"></my-component>`
+ * ```
+ *
+ * @remarks
+ * If you often encounter cases where the JSX to lit-html incorrectly converts
+ * the prop to an attribute necessitating the use of `bindProperty()`, please open
+ * an issue for Lumina.
+ *
+ * @remarks
+ * This function is not named `property()` because that is already taken by
+ * Lit's \@property() decorator
+ */
+export declare const bindProperty: <T>(value: T) => T;
+/**
+ * The `bindEvent()` function lets you customize the event binding behavior by
+ * providing options like passive, capture, once and other options that you
+ * normally can provide to `addEventListener`
+ *
+ * This function call will be erased at build-time, thus it has no runtime
+ * impact.
+ *
+ * @example
+ * ```tsx
+ * <my-component
+ *   onScroll={bindEvent({ handleEvent: console.log, passive:true })}
+ * />
+ * ```tsx
+ *
+ * ```ts
+ * html`<my-component onScroll=${{ handleEvent: console.log, passive:true }}></my-component>`
+ * ```
+ *
+ * @remarks
+ * This function is a _JSX to lit-html_ adaptation of the Lit's event listener
+ * customization syntax.
+ * See https://lit.dev/docs/components/events/#event-options-decorator
+ *
+ *
+ * @remarks
+ * This function is not named `event` because there is a legacy `window.event`
+ * global that was interfering with auto-imports of this function.
+ */
+export declare const bindEvent: <T>(descriptor: T | (AddEventListenerOptions & {
+    handleEvent: T;
+})) => T;
+export type JsxNode = DirectiveResult<any> | JsxNodeArray | Node | TemplateResult | boolean | number | (NonNullable<unknown> & string) | null | undefined;
+/**
+ * Equivalent to Lit's "nothing", but has type "never" to allow it to be set as a
+ * value for any JSX attribute.
+ *
+ * By default in Lit, nullish attribute value renders to an attribute without a
+ * value (which is interpreted by HTML as "true"). To tell Lit that you don't
+ * want the attribute to be present, use the `nothing` value.
+ *
+ * @example
+ * ```tsx
+ * <a href={this.href ?? nothing}>{this.label}</a>
+ * ```
+ *
+ * @remarks
+ * This is not a concern for properties as they are passed as is without
+ * serialization. For this reason, during _JSX to lit-html_ conversion, most JSX
+ * props are converted properties, except for the few cases when an attribute
+ * has no equivalent property.
+ */
+export declare const nothing: never;
+/**
+ * A sentinel value that signals that a value was handled by a directive and
+ * should not be written to the DOM.
+ *
+ * @remarks
+ * This is equivalent to Lit's native "noChange", but has type "never" to allow
+ * it be set as a value for any JSX attribute.
+ */
+export declare const noChange: never;
+/**
+ * Creates a user-facing directive function from a Directive class. This
+ * function has the same parameters as the directive's render() method.
+ *
+ * @remarks
+ * This is equivalent to Lit's native "directive()", but has return type
+ * "never" to allow it be set as a value for any JSX attribute.
+ */
+export declare const directive: <C extends DirectiveClass>(c: C) => (...values: Parameters<InstanceType<C>["render"]>) => never;
+interface JsxNodeArray extends Array<JsxNode> {
+}
+/**
+ * These typings are based on dom-expressions typings:
+ * https://github.com/ryansolid/dom-expressions/blob/main/packages/dom-expressions/src/jsx.d.ts
+ *
+ * They in turn based the typings on Surplus and Inferno:
+ * - https://github.com/adamhaile/surplus/blob/master/index.d.ts
+ * - https://github.com/infernojs/inferno/blob/master/packages/inferno/src/core/types.ts
+ *
+ * Documentation about how to type JSX in TypeScript:
+ * https://www.typescriptlang.org/docs/handbook/jsx.html
+ */
+type DOMElement = Element;
+export declare namespace LitJsx {
+    /**
+     * Whether to pick TemplateResult or JsxNode here is a compromise.
+     *
+     * - If I tell it Lit JSX type is JsxNode, then even <a /> expression will
+     *   have a very broad JsxNode type (union of template results, null,
+     *   undefined, false, and more). This may slow down type-checking and may be
+     *   too-broad for certain use cases.
+     *   - Since <a /> would be typed very broad, you won't be able to declare
+     *     your function as receiving just TemplateResult
+     *   - Also, this makes TypeScript not allow you to return undefined from
+     *     your functional component
+     *   - This is what React did and what I am going with
+     * - If I tell TypeScript that JSX type is TemplateResult, then my function
+     *   component is no longer allowed to return undefined or string or etc.
+     *
+     * This is mainly a TypeScript limitation. Issues tracking this:
+     * - https://github.com/microsoft/TypeScript/issues/21699
+     * - https://github.com/DefinitelyTyped/DefinitelyTyped/issues/18912
+     *
+     */
+    type Element = TemplateResult;
+    interface ElementClass {
+    }
+    interface ElementAttributesProperty {
+    }
+    interface IntrinsicClassAttributes {
+    }
+    interface ElementChildrenAttribute {
+        children: JsxNode;
+    }
+    interface IntrinsicAttributes {
+        /**
+         * The `key` is a special attribute that can be set on any element.
+         *
+         * At build-time it is translated into the `keyed()` directive:
+         * https://lit.dev/docs/templates/directives/#keyed
+         *
+         * @remarks
+         * Unlike in React or Stencil, any JavaScript value is acceptable as a key
+         */
+        key?: unknown;
+    }
+    interface IntrinsicElements extends HTMLElementTags, SVGElementTags, ReMappedComponents<globalThis.DeclareElements>, Omit<ReMapStencilComponents<globalThis.ImportStencilElements>, keyof HTMLElementTags | keyof SVGElementTags> {
+    }
+    /**
+     * By not requiring to have some sort of typings generation watcher to run
+     * in the background and generate types for the components based on the
+     * exposed properties, we improve developer experience a lot.
+     * (no need to run a watcher in the background, no need to commit an
+     * autogenerated file, fewer merge conflicts...)
+     *
+     * The trade-off is that we can't tell in TypeScript if component's public
+     * properties have a `@property()` decorator or not, so have to expose them
+     * all. To reduce the noise, we exclude some properties that we know are
+     * definitely not props (as they are coming from LitElement)
+     *
+     * An ESLint rule that mandates all properties to be private/protected or else
+     * to have a `@property()` decorator would mitigate the issue to a large
+     * extent.
+     *
+     * This does not impact the typings we publish - at build time we have all the
+     * information and can generate the typings that expose only the actual
+     * properties component declared.
+     */
+    type ExcludedProperties = "renderRoot" | "isUpdatePending" | "hasUpdated" | "addController" | "removeController" | "connectedCallback" | "disconnectedCallback" | "attributeChangedCallback" | "requestUpdate" | "updateComplete" | "el" | "manager" | "componentOnReady" | "listen" | "load" | "loaded" | "willUpdate" | "updated" | "render" | "renderOptions";
+    type ReMappedComponents<Components> = {
+        [Key in keyof Components]: ComponentProps<Components[Key]>;
+    };
+    /**
+     *  * A utility type for getting the JSX prop types for a given component
+     *
+     * - Exclude LitElement properties that should not be exposed to the end-user
+     * - Convert event .emit() properties into event callbacks
+     * - Replace original HTMLElement property typings with the ones we provide for
+     *   greater type-safety and control
+     * - For native events listeners, make currentTarget equal to the component's
+     *   HTML instance
+     *
+     * We mark all component properties as optional because there is no easy
+     * way for us to differentiate between public component properties and just
+     * regular members that don't have `@property()` decorator (presence or
+     * absence of decorator does not change the type). Thus, if we don't mark all
+     * properties as optional, TypeScript will force us to provide a value for all
+     * methods, and regular properties component may have.
+     */
+    type ComponentProps<Component> = Partial<Omit<Component, FindEventProperties<Component> | ExcludedProperties | keyof HTMLElement>> & {
+        [Key in FindEventProperties<Component> as `on${Key & string}`]?: (event: Omit<Component[Key], "emit"> & {
+            currentTarget: Component;
+        }) => void;
+    } & HTMLAttributes<Component>;
+    type FindEventProperties<Component> = {
+        [Key in keyof Component]: Component[Key] extends CustomEvent ? unknown extends Component[Key] ? never : Key : never;
+    }[keyof Component];
+    /**
+     * - Make ref prop return HTMLElement rather than Stencil element type
+     * - Uncapitalize the event properties to match the syntax of React 19,
+     *   Preact and Lumina
+     * - Replace Stencil's HTMLElement property typings with the ones we provide
+     *   for greater type-safety, better documentation and more control
+     */
+    type ReMapStencilComponents<Components> = {
+        [Key in keyof Pick<Components, keyof Components & keyof HTMLElementTagNameMap>]: ReMapStencilComponent<Components[Key]> & HTMLAttributes<HTMLElementTagNameMap[Key]>;
+    };
+    type ReMapStencilComponent<Component> = {
+        [Key in keyof Component as Key extends "ref" | keyof HTMLElement ? never : FixupStencilEventCasing<Key>]: Component[Key];
+    };
+    type FixupStencilEventCasing<PropertyName extends PropertyKey> = PropertyName extends `on${infer EventName}` ? `on${Uncapitalize<EventName>}` : PropertyName;
+    type EventHandlerUnion<T, E extends Event> = (e: E & {
+        currentTarget: T;
+        target: DOMElement;
+    }) => void;
+    type InputEventHandlerUnion<T, E extends InputEvent> = (e: E & {
+        currentTarget: T;
+        target: T extends HTMLInputElement | HTMLSelectElement | HTMLTextAreaElement ? T : DOMElement;
+    }) => void;
+    type ChangeEventHandlerUnion<T, E extends Event> = (e: E & {
+        currentTarget: T;
+        target: T extends HTMLInputElement | HTMLSelectElement | HTMLTextAreaElement ? T : DOMElement;
+    }) => void;
+    type FocusEventHandlerUnion<T, E extends FocusEvent> = (e: E & {
+        currentTarget: T;
+        target: T extends HTMLInputElement | HTMLSelectElement | HTMLTextAreaElement ? T : DOMElement;
+    }) => void;
+    type RefCallback<T> = {
+        bivarianceHack(instance: T | undefined): void;
+    }["bivarianceHack"];
+    interface CustomAttributes<T = HTMLElement> {
+        /**
+         * The `key` is a special attribute that can be set on any element.
+         *
+         * At build-time it is translated into the `keyed()` directive:
+         * https://lit.dev/docs/templates/directives/#keyed
+         *
+         * @remarks
+         * Unlike in React or Stencil, any JavaScript value is acceptable as a key
+         */
+        key?: unknown;
+        ref?: RefCallback<T> | Ref<T>;
+        directives?: readonly DirectiveResult[];
+    }
+    interface DOMAttributes<T = HTMLElement> extends CustomAttributes<T>, GlobalEventHandlersCamelCase<T> {
+        children?: JsxNode;
+        innerHTML?: string;
+        innerText?: string | number;
+        textContent?: string | number;
+        class?: string | ClassInfo | DirectiveResult<typeof ClassMapDirective>;
+    }
+    interface GlobalEventHandlersCamelCase<T = HTMLElement> {
+        /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Element/animationcancel_event) */
+        onAnimationCancel?: EventHandlerUnion<T, AnimationEvent>;
+        /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Element/animationend_event) */
+        onAnimationEnd?: EventHandlerUnion<T, AnimationEvent>;
+        /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Element/animationiteration_event) */
+        onAnimationIteration?: EventHandlerUnion<T, AnimationEvent>;
+        /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Element/animationstart_event) */
+        onAnimationStart?: EventHandlerUnion<T, AnimationEvent>;
+        /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Element/auxclick_event) */
+        onAuxClick?: EventHandlerUnion<T, MouseEvent>;
+        /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLElement/beforeinput_event) */
+        onBeforeInput?: InputEventHandlerUnion<T, InputEvent>;
+        /**
+         * Fires when the object loses the input focus.
+         *
+         * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Element/blur_event)
+         */
+        onBlur?: FocusEventHandlerUnion<T, FocusEvent>;
+        /**
+         * Fires when the contents of the object or selection have changed.
+         *
+         * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLElement/change_event)
+         */
+        onChange?: ChangeEventHandlerUnion<T, Event>;
+        /**
+         * Fires when the user clicks the left mouse button on the object
+         *
+         * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Element/click_event)
+         */
+        onClick?: EventHandlerUnion<T, MouseEvent>;
+        /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Element/compositionend_event) */
+        onCompositionEnd?: EventHandlerUnion<T, CompositionEvent>;
+        /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Element/compositionstart_event) */
+        onCompositionStart?: EventHandlerUnion<T, CompositionEvent>;
+        /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Element/compositionupdate_event) */
+        onCompositionUpdate?: EventHandlerUnion<T, CompositionEvent>;
+        /**
+         * Fires when the user clicks the right mouse button in the client area, opening the context menu.
+         *
+         * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Element/contextmenu_event)
+         */
+        onContextMenu?: EventHandlerUnion<T, MouseEvent>;
+        /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Element/copy_event) */
+        onCopy?: EventHandlerUnion<T, ClipboardEvent>;
+        /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Element/cut_event) */
+        onCut?: EventHandlerUnion<T, ClipboardEvent>;
+        /**
+         * Fires when the user double-clicks the object.
+         *
+         * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Element/dblclick_event)
+         */
+        onDblClick?: EventHandlerUnion<T, MouseEvent>;
+        /**
+         * Fires on the source object continuously during a drag operation.
+         *
+         * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLElement/drag_event)
+         */
+        onDrag?: EventHandlerUnion<T, DragEvent>;
+        /**
+         * Fires on the source object when the user releases the mouse at the close of a drag operation.
+         *
+         * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLElement/dragend_event)
+         */
+        onDragEnd?: EventHandlerUnion<T, DragEvent>;
+        /**
+         * Fires on the target element when the user drags the object to a valid drop target.
+         *
+         * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLElement/dragenter_event)
+         */
+        onDragEnter?: EventHandlerUnion<T, DragEvent>;
+        /**
+         * Fires on the target object when the user moves the mouse out of a valid drop target during a drag operation.
+         *
+         * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLElement/dragleave_event)
+         */
+        onDragLeave?: EventHandlerUnion<T, DragEvent>;
+        /**
+         * Fires on the target element continuously while the user drags the object over a valid drop target.
+         *
+         * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLElement/dragover_event)
+         */
+        onDragOver?: EventHandlerUnion<T, DragEvent>;
+        /**
+         * Fires on the source object when the user starts to drag a text selection or selected object.
+         *
+         * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLElement/dragstart_event)
+         */
+        onDragStart?: EventHandlerUnion<T, DragEvent>;
+        /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLElement/drop_event) */
+        onDrop?: EventHandlerUnion<T, DragEvent>;
+        onEncrypted?: EventHandlerUnion<T, Event>;
+        /**
+         * Fires when an error occurs during object loading.
+         *
+         * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLElement/error_event)
+         */
+        onError?: EventHandlerUnion<T, Event>;
+        /**
+         * Fires when the object receives focus.
+         *
+         * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Element/focus_event)
+         */
+        onFocus?: FocusEventHandlerUnion<T, FocusEvent>;
+        /** [MDN Reference](https://developer.mozilla.org/en-US/docs/Web/API/Element/focusout_event) */
+        onFocusOut?: FocusEventHandlerUnion<T, FocusEvent>;
+        /** [MDN Reference](https://developer.mozilla.org/en-US/docs/Web/API/Element/focusin_event) */
+        onFocusIn?: FocusEventHandlerUnion<T, FocusEvent>;
+        /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Element/fullscreenchange_event) */
+        onFullscreenChange?: EventHandlerUnion<T, Event>;
+        /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Element/fullscreenerror_event) */
+        onFullscreenError?: EventHandlerUnion<T, Event>;
+        /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Element/gotpointercapture_event) */
+        onGotPointerCapture?: EventHandlerUnion<T, PointerEvent>;
+        /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLElement/input_event) */
+        onInput?: InputEventHandlerUnion<T, InputEvent>;
+        /**
+         * Fires when the user presses a key.
+         *
+         * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Element/keydown_event)
+         */
+        onKeyDown?: EventHandlerUnion<T, KeyboardEvent>;
+        /**
+         * Fires when the user releases a key.
+         *
+         * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Element/keyup_event)
+         */
+        onKeyUp?: EventHandlerUnion<T, KeyboardEvent>;
+        /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Document/lostpointercapture_event) */
+        onLostPointerCapture?: EventHandlerUnion<T, PointerEvent>;
+        /**
+         * Fires when the user clicks the object with either mouse button.
+         *
+         * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Element/mousedown_event)
+         */
+        onMouseDown?: EventHandlerUnion<T, MouseEvent>;
+        /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Element/mouseenter_event) */
+        onMouseEnter?: EventHandlerUnion<T, MouseEvent>;
+        /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Element/mouseleave_event) */
+        onMouseLeave?: EventHandlerUnion<T, MouseEvent>;
+        /**
+         * Fires when the user moves the mouse over the object.
+         *
+         * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Element/mousemove_event)
+         */
+        onMouseMove?: EventHandlerUnion<T, MouseEvent>;
+        /**
+         * Fires when the user moves the mouse pointer outside the boundaries of the object.
+         *
+         * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Element/mouseout_event)
+         */
+        onMouseOut?: EventHandlerUnion<T, MouseEvent>;
+        /**
+         * Fires when the user moves the mouse pointer into the object.
+         *
+         * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Element/mouseover_event)
+         */
+        onMouseOver?: EventHandlerUnion<T, MouseEvent>;
+        /**
+         * Fires when the user releases a mouse button while the mouse is over the object.
+         *
+         * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Element/mouseup_event)
+         */
+        onMouseUp?: EventHandlerUnion<T, MouseEvent>;
+        /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Element/paste_event) */
+        onPaste?: EventHandlerUnion<T, ClipboardEvent>;
+        /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Element/pointercancel_event) */
+        onPointerCancel?: EventHandlerUnion<T, PointerEvent>;
+        /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Element/pointerdown_event) */
+        onPointerDown?: EventHandlerUnion<T, PointerEvent>;
+        /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Element/pointerenter_event) */
+        onPointerEnter?: EventHandlerUnion<T, PointerEvent>;
+        /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Element/pointerleave_event) */
+        onPointerLeave?: EventHandlerUnion<T, PointerEvent>;
+        /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Element/pointermove_event) */
+        onPointerMove?: EventHandlerUnion<T, PointerEvent>;
+        /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Element/pointerout_event) */
+        onPointerOut?: EventHandlerUnion<T, PointerEvent>;
+        /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Element/pointerover_event) */
+        onPointerOver?: EventHandlerUnion<T, PointerEvent>;
+        /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Element/pointerup_event) */
+        onPointerUp?: EventHandlerUnion<T, PointerEvent>;
+        /**
+         * Fires when the user repositions the scroll box in the scroll bar on the object.
+         *
+         * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Document/scroll_event)
+         */
+        onScroll?: EventHandlerUnion<T, Event>;
+        /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Document/scrollend_event) */
+        onScrollEnd?: EventHandlerUnion<T, Event>;
+        /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Document/securitypolicyviolation_event) */
+        onSecurityPolicyViolation?: EventHandlerUnion<T, SecurityPolicyViolationEvent>;
+        /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Node/selectstart_event) */
+        onSelectStart?: EventHandlerUnion<T, Event>;
+        /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Element/touchcancel_event) */
+        onTouchCancel?: EventHandlerUnion<T, TouchEvent>;
+        /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Element/touchend_event) */
+        onTouchEnd?: EventHandlerUnion<T, TouchEvent>;
+        /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Element/touchmove_event) */
+        onTouchMove?: EventHandlerUnion<T, TouchEvent>;
+        /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Element/touchstart_event) */
+        onTouchStart?: EventHandlerUnion<T, TouchEvent>;
+        /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Element/transitioncancel_event) */
+        onTransitionCancel?: EventHandlerUnion<T, TransitionEvent>;
+        /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Element/transitionend_event) */
+        onTransitionEnd?: EventHandlerUnion<T, TransitionEvent>;
+        /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Element/transitionrun_event) */
+        onTransitionRun?: EventHandlerUnion<T, TransitionEvent>;
+        /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Element/transitionstart_event) */
+        onTransitionStart?: EventHandlerUnion<T, TransitionEvent>;
+        /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Element/wheel_event) */
+        onWheel?: EventHandlerUnion<T, WheelEvent>;
+    }
+    type HTMLAutocapitalize = "off" | "none" | "on" | "sentences" | "words" | "characters";
+    type HTMLDir = "ltr" | "rtl" | "auto";
+    type HTMLFormEncType = "application/x-www-form-urlencoded" | "multipart/form-data" | "text/plain";
+    type HTMLFormMethod = "post" | "get" | "dialog";
+    type HTMLCrossOrigin = "anonymous" | "use-credentials" | "";
+    type HTMLReferrerPolicy = "no-referrer" | "no-referrer-when-downgrade" | "origin" | "origin-when-cross-origin" | "same-origin" | "strict-origin" | "strict-origin-when-cross-origin" | "unsafe-url";
+    type HTMLIframeSandbox = "allow-downloads-without-user-activation" | "allow-downloads" | "allow-forms" | "allow-modals" | "allow-orientation-lock" | "allow-pointer-lock" | "allow-popups" | "allow-popups-to-escape-sandbox" | "allow-presentation" | "allow-same-origin" | "allow-scripts" | "allow-storage-access-by-user-activation" | "allow-top-navigation" | "allow-top-navigation-by-user-activation" | "allow-top-navigation-to-custom-protocols";
+    type HTMLLinkAs = "audio" | "document" | "embed" | "fetch" | "font" | "image" | "object" | "script" | "style" | "track" | "video" | "worker";
+    /**
+     * All the WAI-ARIA 1.1 attributes from https://www.w3.org/TR/wai-aria-1.1/
+     *
+     * @remarks
+     * If attribute is settable as a property, that is preferred - such aria
+     * attributes are in camelCase in this interface. Some are settable as
+     * DOM attribute only - such names are in kebab-case.
+     */
+    interface AriaAttributes {
+        /**
+         * Identifies the currently active element when DOM focus is on a composite widget, textbox, group, or application.
+         *
+         * @remarks
+         * While HTML attributes on regular HTML elements are case-insensitive, when
+         * the same common attributes are set on a foreign HTML elements (SVG/Math),
+         * they are case sensitive. Thus, we can't author this as
+         * "aria-activeDescendant"
+         */
+        ["aria-activedescendant"]?: string;
+        ariaActiveDescendantElement?: HTMLElement;
+        /** Indicates whether assistive technologies will present all, or only parts of, the changed region based on the change notifications defined by the aria-relevant attribute. */
+        ariaAtomic?: boolean | "false" | "true";
+        /**
+         * Indicates whether inputting text could trigger display of one or more predictions of the user's intended value for an input and specifies how predictions would be
+         * presented if they are made.
+         */
+        ariaAutoComplete?: "none" | "inline" | "list" | "both";
+        /** Indicates an element is being modified and that assistive technologies MAY want to wait until the modifications are complete before exposing them to the user. */
+        ariaBusy?: boolean | "false" | "true";
+        /**
+         * Indicates the current "checked" state of checkboxes, radio buttons, and other widgets.
+         * @see ariaPressed
+         * @see ariaSelected
+         */
+        ariaChecked?: boolean | "false" | "mixed" | "true";
+        /**
+         * Defines the total number of columns in a table, grid, or treegrid.
+         * @see ariaColIndex
+         */
+        ariaColCount?: number | string;
+        /**
+         * Defines an element's column index or position with respect to the total number of columns within a table, grid, or treegrid.
+         * @see ariaColCount
+         * @see ariaColSpan
+         */
+        ariaColIndex?: number | string;
+        /**
+         * Defines the number of columns spanned by a cell or gridcell within a table, grid, or treegrid.
+         * @see ariaColIndex
+         * @see ariaRowSpan
+         */
+        ariaColSpan?: number | string;
+        /**
+         * Identifies the element (or elements) whose contents or presence are controlled by the current element.
+         * @see ariaOwns.
+         */
+        ["aria-controls"]?: string;
+        ariaControlsElements?: HTMLElement[];
+        /** Indicates the element that represents the current item within a container or set of related elements. */
+        ariaCurrent?: boolean | "false" | "true" | "page" | "step" | "location" | "date" | "time";
+        /**
+         * Identifies the element (or elements) that describes the object.
+         * @see aria-labelledby
+         */
+        ["aria-describedby"]?: string;
+        ariaDescribedByElements?: HTMLElement;
+        /**
+         * Identifies the element that provides a detailed, extended description for the object.
+         * @see aria-describedby
+         */
+        ["aria-details"]?: string;
+        ariaDetailsElements?: HTMLElement;
+        /**
+         * Indicates that the element is perceivable but disabled, so it is not editable or otherwise operable.
+         * @see ariaHidden
+         * @see ariaReadonly
+         */
+        ariaDisabled?: boolean | "false" | "true";
+        /**
+         * Identifies the element that provides an error message for the object.
+         * @see ariaInvalid
+         * @see aria-describedby
+         */
+        ["aria-errormessage"]?: string;
+        ariaErrorMessageElements?: HTMLElement;
+        /** Indicates whether the element, or another grouping element it controls, is currently expanded or collapsed. */
+        ariaExpanded?: boolean | "false" | "true";
+        /**
+         * Identifies the next element (or elements) in an alternate reading order of content which, at the user's discretion,
+         * allows assistive technology to override the general default of reading in document source order.
+         */
+        ["aria-flowto"]?: string;
+        ariaFlowToElements?: HTMLElement;
+        /** Indicates the availability and type of interactive popup element, such as menu or dialog, that can be triggered by an element. */
+        ariaHasPopup?: boolean | "false" | "true" | "menu" | "listbox" | "tree" | "grid" | "dialog";
+        /**
+         * Indicates whether the element is exposed to an accessibility API.
+         * @see ariaDisabled
+         */
+        ariaHidden?: boolean | "false" | "true";
+        /**
+         * Indicates the entered value does not conform to the format expected by the application.
+         * @see aria-errormessage
+         */
+        ariaInvalid?: boolean | "false" | "true" | "grammar" | "spelling";
+        /** Indicates keyboard shortcuts that an author has implemented to activate or give focus to an element. */
+        ariaKeyShortcuts?: string;
+        /**
+         * Defines a string value that labels the current element.
+         * @see aria-labelledby
+         */
+        ariaLabel?: string;
+        /**
+         * Identifies the element (or elements) that labels the current element.
+         * @see aria-describedby
+         */
+        ["aria-labelledby"]?: string;
+        ariaLabelledByElements?: HTMLElement;
+        /** Defines the hierarchical level of an element within a structure. */
+        ariaLevel?: number | string;
+        /** Indicates that an element will be updated, and describes the types of updates the user agents, assistive technologies, and user can expect from the live region. */
+        ariaLive?: "off" | "assertive" | "polite";
+        /** Indicates whether an element is modal when displayed. */
+        ariaModal?: boolean | "false" | "true";
+        /** Indicates whether a text box accepts multiple lines of input or only a single line. */
+        ariaMultiLine?: boolean | "false" | "true";
+        /** Indicates that the user may select more than one item from the current selectable descendants. */
+        ariaMultiSelectable?: boolean | "false" | "true";
+        /** Indicates whether the element's orientation is horizontal, vertical, or unknown/ambiguous. */
+        ariaOrientation?: "horizontal" | "vertical";
+        /**
+         * Identifies an element (or elements) in order to define a visual, functional, or contextual parent/child relationship
+         * between DOM elements where the DOM hierarchy cannot be used to represent the relationship.
+         * @see aria-controls
+         */
+        ["aria-owns"]?: string;
+        ariaOwnsElements?: HTMLElement;
+        /**
+         * Defines a short hint (a word or short phrase) intended to aid the user with data entry when the control has no value.
+         * A hint could be a sample value or a brief description of the expected format.
+         */
+        ariaPlaceholder?: string;
+        /**
+         * Defines an element's number or position in the current set of listitems or treeitems. Not required if all elements in the set are present in the DOM.
+         * @see ariaSetSize.
+         */
+        ariaPosInSet?: number | string;
+        /**
+         * Indicates the current "pressed" state of toggle buttons.
+         * @see ariaChecked
+         * @see ariaSelected
+         */
+        ariaPressed?: boolean | "false" | "mixed" | "true";
+        /**
+         * Indicates that the element is not editable, but is otherwise operable.
+         * @see ariaDisabled
+         */
+        ariaReadOnly?: boolean | "false" | "true";
+        /**
+         * Indicates what notifications the user agent will trigger when the accessibility tree within a live region is modified.
+         * @see ariaAtomic
+         */
+        ariaRelevant?: "additions" | "additions removals" | "additions text" | "all" | "removals" | "removals additions" | "removals text" | "text" | "text additions" | "text removals";
+        /** Indicates that user input is required on the element before a form may be submitted. */
+        ariaRequired?: boolean | "false" | "true";
+        /** Defines a human-readable, author-localized description for the role of an element. */
+        ariaRoleDescription?: string;
+        /**
+         * Defines the total number of rows in a table, grid, or treegrid.
+         * @see ariaRowIndex
+         */
+        ariaRowCount?: number | string;
+        /**
+         * Defines an element's row index or position with respect to the total number of rows within a table, grid, or treegrid.
+         * @see ariaRowCount
+         * @see ariaRowSpan
+         */
+        ariaRowIndex?: number | string;
+        /**
+         * Defines the number of rows spanned by a cell or gridcell within a table, grid, or treegrid.
+         * @see ariaRowIndex
+         * @see ariaColSpan
+         */
+        ariaRowSpan?: number | string;
+        /**
+         * Indicates the current "selected" state of various widgets.
+         * @see ariaChecked
+         * @see ariaPressed
+         */
+        ariaSelected?: boolean | "false" | "true";
+        /**
+         * Defines the number of items in the current set of listitems or treeitems. Not required if all elements in the set are present in the DOM.
+         * @see ariaPosInSet
+         */
+        ariaSetSize?: number | string;
+        /** Indicates if items in a table or grid are sorted in ascending or descending order. */
+        ariaSort?: "none" | "ascending" | "descending" | "other";
+        /** Defines the maximum allowed value for a range widget. */
+        ariaValueMax?: number | string;
+        /** Defines the minimum allowed value for a range widget. */
+        ariaValueMin?: number | string;
+        /**
+         * Defines the current value for a range widget.
+         * @see ariaValueText.
+         */
+        ariaValueNow?: number | string;
+        /** Defines the human readable text alternative of ariaValueNow for a range widget. */
+        ariaValueText?: string;
+        role?: "alert" | "alertdialog" | "application" | "article" | "banner" | "button" | "cell" | "checkbox" | "columnheader" | "combobox" | "complementary" | "contentinfo" | "definition" | "dialog" | "directory" | "document" | "feed" | "figure" | "form" | "grid" | "gridcell" | "group" | "heading" | "img" | "link" | "list" | "listbox" | "listitem" | "log" | "main" | "marquee" | "math" | "menu" | "menubar" | "menuitem" | "menuitemcheckbox" | "menuitemradio" | "meter" | "navigation" | "none" | "note" | "option" | "presentation" | "progressbar" | "radio" | "radiogroup" | "region" | "row" | "rowgroup" | "rowheader" | "scrollbar" | "search" | "searchbox" | "separator" | "slider" | "spinbutton" | "status" | "switch" | "tab" | "table" | "tablist" | "tabpanel" | "term" | "textbox" | "timer" | "toolbar" | "tooltip" | "tree" | "treegrid" | "treeitem";
+    }
+    interface HTMLAttributes<T = HTMLElement> extends AriaAttributes, DOMAttributes<T>, RdfaAttributes {
+        accessKey?: string;
+        dir?: HTMLDir;
+        draggable?: boolean;
+        hidden?: boolean | "hidden" | "until-found";
+        id?: string;
+        inert?: boolean;
+        lang?: string;
+        spellcheck?: boolean;
+        style?: CssProperties | string | DirectiveResult<typeof StyleMapDirective>;
+        title?: string;
+        translate?: boolean;
+        popover?: boolean | "manual" | "auto";
+        slot?: string;
+        part?: string;
+        contentEditable?: boolean | "plaintext-only" | "inherit";
+        tabIndex?: number | string;
+        autocapitalize?: HTMLAutocapitalize;
+        itemProp?: string;
+        itemScope?: boolean;
+        itemType?: string;
+        itemId?: string;
+        itemRef?: string;
+        exportParts?: string;
+        inputMode?: "none" | "text" | "tel" | "url" | "email" | "numeric" | "decimal" | "search";
+    }
+    interface RdfaAttributes {
+        about?: string;
+        datatype?: string;
+        inList?: string;
+        prefix?: string;
+        property?: string;
+        rel?: string;
+        resource?: string;
+        rev?: string;
+        typeof?: string;
+        vocab?: string;
+    }
+    interface AnchorHTMLAttributes<T> extends HTMLAttributes<T> {
+        /**
+         * Provide empty string, or file name
+         *
+         * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/a#download
+         */
+        download?: string;
+        href?: string;
+        hreflang?: string;
+        media?: string;
+        ping?: string;
+        rel?: string;
+        target?: string;
+        type?: string;
+        referrerPolicy?: HTMLReferrerPolicy;
+    }
+    interface AudioHTMLAttributes<T> extends MediaHTMLAttributes<T> {
+    }
+    interface AreaHTMLAttributes<T> extends HTMLAttributes<T> {
+        alt?: string;
+        coords?: string;
+        /**
+         * Provide empty string, or file name
+         *
+         * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/a#download
+         */
+        download?: string;
+        href?: string;
+        hreflang?: string;
+        ping?: string;
+        rel?: string;
+        shape?: "rect" | "circle" | "poly" | "default";
+        target?: string;
+        referrerPolicy?: HTMLReferrerPolicy;
+    }
+    interface BaseHTMLAttributes<T> extends HTMLAttributes<T> {
+        href?: string;
+        target?: string;
+    }
+    interface BlockquoteHTMLAttributes<T> extends HTMLAttributes<T> {
+        cite?: string;
+    }
+    interface ButtonHTMLAttributes<T> extends HTMLAttributes<T> {
+        autofocus?: boolean;
+        disabled?: boolean;
+        form?: string;
+        name?: string;
+        type?: "submit" | "reset" | "button";
+        value?: string;
+        formAction?: string;
+        formEnctype?: HTMLFormEncType;
+        formMethod?: HTMLFormMethod;
+        formNoValidate?: boolean;
+        formTarget?: string;
+        popoverTarget?: string;
+        popoverTargetElement?: HTMLElement;
+        popoverTargetAction?: "hide" | "show" | "toggle";
+    }
+    interface CanvasHTMLAttributes<T> extends HTMLAttributes<T> {
+        width?: number | string;
+        height?: number | string;
+    }
+    interface ColHTMLAttributes<T> extends HTMLAttributes<T> {
+        span?: number | string;
+        width?: number | string;
+    }
+    interface ColgroupHTMLAttributes<T> extends HTMLAttributes<T> {
+        span?: number | string;
+    }
+    interface DataHTMLAttributes<T> extends HTMLAttributes<T> {
+        value?: string | number;
+    }
+    interface DetailsHTMLAttributes<T> extends HTMLAttributes<T> {
+        open?: boolean;
+        /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLDetailsElement/toggle_event) */
+        onToggle?: EventHandlerUnion<T, Event>;
+    }
+    interface DialogHTMLAttributes<T> extends HTMLAttributes<T> {
+        /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLDialogElement/open) */
+        open?: boolean;
+        /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLDialogElement/returnValue) */
+        returnValue?: string;
+        /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLDialogElement/cancel_event) */
+        onCancel?: EventHandlerUnion<T, Event>;
+        /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLDialogElement/close_event) */
+        onClose?: EventHandlerUnion<T, Event>;
+    }
+    interface EmbedHTMLAttributes<T> extends HTMLAttributes<T> {
+        height?: number | string;
+        src?: string;
+        type?: string;
+        width?: number | string;
+    }
+    interface FieldsetHTMLAttributes<T> extends HTMLAttributes<T> {
+        disabled?: boolean;
+        form?: string;
+        name?: string;
+    }
+    interface FormHTMLAttributes<T> extends HTMLAttributes<T> {
+        acceptCharset?: string;
+        action?: string;
+        encoding?: HTMLFormEncType;
+        enctype?: HTMLFormEncType;
+        method?: HTMLFormMethod;
+        name?: string;
+        target?: string;
+        noValidate?: boolean;
+        /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLFormElement/formdata_event) */
+        onFormData?: EventHandlerUnion<T, FormDataEvent>;
+        /**
+         * Fires when the user resets a form.
+         *
+         * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLFormElement/reset_event)
+         */
+        onReset?: EventHandlerUnion<T, Event>;
+        /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLFormElement/submit_event) */
+        onSubmit?: EventHandlerUnion<T, Event & {
+            submitter: HTMLElement;
+        }>;
+    }
+    interface IframeHTMLAttributes<T> extends HTMLAttributes<T> {
+        allow?: string;
+        allowFullscreen?: boolean;
+        height?: number | string;
+        loading?: "eager" | "lazy";
+        name?: string;
+        sandbox?: HTMLIframeSandbox | string;
+        src?: string;
+        srcdoc?: string;
+        width?: number | string;
+        referrerPolicy?: HTMLReferrerPolicy;
+    }
+    interface ImgHTMLAttributes<T> extends HTMLAttributes<T> {
+        alt?: string;
+        decoding?: "sync" | "async" | "auto";
+        height?: number | string;
+        isMap?: boolean;
+        loading?: "eager" | "lazy";
+        referrerPolicy?: HTMLReferrerPolicy;
+        sizes?: string;
+        src?: string;
+        srcset?: string;
+        useMap?: string;
+        width?: number | string;
+        crossOrigin?: HTMLCrossOrigin;
+        elementTiming?: string;
+        fetchPriority?: "high" | "low" | "auto";
+    }
+    interface InputHTMLAttributes<T> extends HTMLAttributes<T> {
+        accept?: string;
+        alt?: string;
+        autofocus?: boolean;
+        capture?: boolean | string;
+        checked?: boolean;
+        disabled?: boolean;
+        enterKeyHint?: "enter" | "done" | "go" | "next" | "previous" | "search" | "send";
+        form?: string;
+        height?: number | string;
+        incremental?: boolean;
+        list?: string;
+        max?: number | string;
+        min?: number | string;
+        multiple?: boolean;
+        name?: string;
+        pattern?: string;
+        placeholder?: string;
+        readOnly?: boolean;
+        results?: number;
+        required?: boolean;
+        size?: number | string;
+        src?: string;
+        step?: number | string;
+        type?: string;
+        value?: string | number;
+        defaultValue?: string | number;
+        width?: number | string;
+        formAction?: string;
+        formEnctype?: HTMLFormEncType;
+        formMethod?: HTMLFormMethod;
+        formNoValidate?: boolean;
+        formTarget?: string;
+        maxLength?: number | string;
+        minLength?: number | string;
+        /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLInputElement/invalid_event) */
+        onInvalid?: EventHandlerUnion<T, Event>;
+        /**
+         * Fires when the current selection changes.
+         *
+         * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLInputElement/select_event)
+         */
+        onSelect?: EventHandlerUnion<T, UIEvent>;
+    }
+    interface InsHTMLAttributes<T> extends HTMLAttributes<T> {
+        cite?: string;
+        dateTime?: string;
+    }
+    interface LabelHTMLAttributes<T> extends HTMLAttributes<T> {
+        htmlFor?: string;
+        form?: string;
+    }
+    interface LiHTMLAttributes<T> extends HTMLAttributes<T> {
+        value?: number | string;
+    }
+    interface LinkHTMLAttributes<T> extends HTMLAttributes<T> {
+        as?: HTMLLinkAs;
+        disabled?: boolean;
+        fetchPriority?: "high" | "low" | "auto";
+        href?: string;
+        hreflang?: string;
+        imageSizes?: string;
+        imageSrcset?: string;
+        integrity?: string;
+        media?: string;
+        rel?: string;
+        sizes?: string;
+        type?: string;
+        crossOrigin?: HTMLCrossOrigin;
+        referrerPolicy?: HTMLReferrerPolicy;
+    }
+    interface MapHTMLAttributes<T> extends HTMLAttributes<T> {
+        name?: string;
+    }
+    interface MathMLAttributes<T = HTMLMathElement> extends HTMLAttributes<T> {
+        dir?: "ltr" | "rtl" | undefined;
+        /**
+         * HTML attributes in foreign elements are case-sensitive
+         */
+        displaystyle?: boolean | undefined;
+        nonce?: string | undefined;
+        /**
+         * HTML attributes in foreign elements are case-sensitive
+         */
+        scriptlevel?: boolean | string | undefined;
+    }
+    interface HTMLMathElement extends MathMLElement {
+        display?: "block" | "inline" | undefined;
+    }
+    interface MediaHTMLAttributes<T> extends HTMLAttributes<T> {
+        autoplay?: boolean;
+        controls?: boolean;
+        loop?: boolean;
+        muted?: boolean;
+        preload?: "none" | "metadata" | "auto" | "";
+        src?: string;
+        crossOrigin?: HTMLCrossOrigin;
+        /**
+         * Fires when the user aborts the download.
+         *
+         * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLMediaElement/abort_event)
+         */
+        onAbort?: EventHandlerUnion<T, Event>;
+        /**
+         * Occurs when playback is possible, but would require further buffering.
+         *
+         * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLMediaElement/canplay_event)
+         */
+        onCanPlay?: EventHandlerUnion<T, Event>;
+        /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLMediaElement/canplaythrough_event) */
+        onCanPlayThrough?: EventHandlerUnion<T, Event>;
+        /**
+         * Occurs when the duration attribute is updated.
+         *
+         * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLMediaElement/durationchange_event)
+         */
+        onDurationChange?: EventHandlerUnion<T, Event>;
+        /**
+         * Occurs when the media element is reset to its initial state.
+         *
+         * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLMediaElement/emptied_event)
+         */
+        onEmptied?: EventHandlerUnion<T, Event>;
+        /**
+         * Occurs when media data is loaded at the current playback position.
+         *
+         * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLMediaElement/loadeddata_event)
+         */
+        onLoadedData?: EventHandlerUnion<T, Event>;
+        /**
+         * Occurs when the duration and dimensions of the media have been determined.
+         *
+         * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLMediaElement/loadedmetadata_event)
+         */
+        onLoadedMetadata?: EventHandlerUnion<T, Event>;
+        /**
+         * Occurs when Internet Explorer begins looking for media data.
+         *
+         * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLMediaElement/loadstart_event)
+         */
+        onLoadStart?: EventHandlerUnion<T, Event>;
+        /**
+         * Occurs when playback is paused.
+         *
+         * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLMediaElement/pause_event)
+         */
+        onPause?: EventHandlerUnion<T, Event>;
+        /**
+         * Occurs when the play method is requested.
+         *
+         * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLMediaElement/play_event)
+         */
+        onPlay?: EventHandlerUnion<T, Event>;
+        /**
+         * Occurs when the audio or video has started playing.
+         *
+         * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLMediaElement/playing_event)
+         */
+        onPlaying?: EventHandlerUnion<T, Event>;
+        /**
+         * Occurs to indicate progress while downloading media data.
+         *
+         * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLMediaElement/progress_event)
+         */
+        onProgress?: EventHandlerUnion<T, Event>;
+        /**
+         * Occurs when the playback rate is increased or decreased.
+         *
+         * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLMediaElement/ratechange_event)
+         */
+        onRateChange?: EventHandlerUnion<T, Event>;
+        /**
+         * Occurs when the seek operation ends.
+         *
+         * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLMediaElement/seeked_event)
+         */
+        onSeeked?: EventHandlerUnion<T, Event>;
+        /**
+         * Occurs when the current playback position is moved.
+         *
+         * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLMediaElement/seeking_event)
+         */
+        onSeeking?: EventHandlerUnion<T, Event>;
+        /**
+         * Occurs when the download has stopped.
+         *
+         * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLMediaElement/stalled_event)
+         */
+        onStalled?: EventHandlerUnion<T, Event>;
+        /**
+         * Occurs if the load operation has been intentionally halted.
+         *
+         * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLMediaElement/suspend_event)
+         */
+        onSuspend?: EventHandlerUnion<T, Event>;
+        /**
+         * Occurs to indicate the current playback position.
+         *
+         * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLMediaElement/timeupdate_event)
+         */
+        onTimeUpdate?: EventHandlerUnion<T, Event>;
+        /**
+         * Occurs when the volume is changed, or playback is muted or unmuted.
+         *
+         * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLMediaElement/volumechange_event)
+         */
+        onVolumeChange?: EventHandlerUnion<T, Event>;
+        /**
+         * Occurs when playback stops because the next frame of a video resource is not available.
+         *
+         * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLMediaElement/waiting_event)
+         */
+        onWaiting?: EventHandlerUnion<T, Event>;
+    }
+    interface MenuHTMLAttributes<T> extends HTMLAttributes<T> {
+        label?: string;
+        type?: "context" | "toolbar";
+    }
+    interface MetaHTMLAttributes<T> extends HTMLAttributes<T> {
+        charset?: string;
+        content?: string;
+        httpEquiv?: string;
+        name?: string;
+        media?: string;
+    }
+    interface MeterHTMLAttributes<T> extends HTMLAttributes<T> {
+        form?: string;
+        high?: number | string;
+        low?: number | string;
+        max?: number | string;
+        min?: number | string;
+        optimum?: number | string;
+        value?: string | number;
+    }
+    interface QuoteHTMLAttributes<T> extends HTMLAttributes<T> {
+        cite?: string;
+    }
+    interface ObjectHTMLAttributes<T> extends HTMLAttributes<T> {
+        data?: string;
+        form?: string;
+        height?: number | string;
+        name?: string;
+        type?: string;
+        width?: number | string;
+        useMap?: string;
+    }
+    interface OlHTMLAttributes<T> extends HTMLAttributes<T> {
+        reversed?: boolean;
+        start?: number | string;
+        type?: "1" | "a" | "A" | "i" | "I";
+    }
+    interface OptgroupHTMLAttributes<T> extends HTMLAttributes<T> {
+        disabled?: boolean;
+        label?: string;
+    }
+    interface OptionHTMLAttributes<T> extends HTMLAttributes<T> {
+        disabled?: boolean;
+        label?: string;
+        selected?: boolean;
+        value?: string | number;
+    }
+    interface OutputHTMLAttributes<T> extends HTMLAttributes<T> {
+        form?: string;
+        for?: string;
+        name?: string;
+    }
+    interface ProgressHTMLAttributes<T> extends HTMLAttributes<T> {
+        max?: number | string;
+        value?: string | number;
+    }
+    interface ScriptHTMLAttributes<T> extends HTMLAttributes<T> {
+        async?: boolean;
+        charset?: string;
+        defer?: boolean;
+        integrity?: string;
+        nonce?: string;
+        src?: string;
+        type?: string;
+        crossOrigin?: HTMLCrossOrigin;
+        noModule?: boolean;
+        referrerPolicy?: HTMLReferrerPolicy;
+    }
+    interface SelectHTMLAttributes<T> extends HTMLAttributes<T> {
+        autofocus?: boolean;
+        disabled?: boolean;
+        form?: string;
+        multiple?: boolean;
+        name?: string;
+        required?: boolean;
+        size?: number | string;
+        value?: string | number;
+    }
+    interface SlotHTMLAttributes<T = HTMLSlotElement> extends HTMLAttributes<T> {
+        name?: string;
+        /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLSlotElement/slotchange_event) */
+        onSlotChange?: EventHandlerUnion<T, Event>;
+    }
+    interface SourceHTMLAttributes<T> extends HTMLAttributes<T> {
+        media?: string;
+        sizes?: string;
+        src?: string;
+        srcset?: string;
+        type?: string;
+    }
+    interface StyleHTMLAttributes<T> extends HTMLAttributes<T> {
+        media?: string;
+        nonce?: string;
+        scoped?: boolean;
+        type?: string;
+    }
+    interface TdHTMLAttributes<T> extends HTMLAttributes<T> {
+        headers?: string;
+        colSpan?: number | string;
+        rowSpan?: number | string;
+    }
+    interface TemplateHTMLAttributes<T extends HTMLTemplateElement> extends HTMLAttributes<T> {
+        content?: DocumentFragment;
+    }
+    interface TextareaHTMLAttributes<T> extends HTMLAttributes<T> {
+        children?: "Error: Use value property instead. See https://lit.dev/docs/templates/expressions/#invalid-locations";
+        autofocus?: boolean;
+        cols?: number | string;
+        dirname?: string;
+        disabled?: boolean;
+        enterKeyHint?: "enter" | "done" | "go" | "next" | "previous" | "search" | "send";
+        form?: string;
+        name?: string;
+        placeholder?: string;
+        readOnly?: boolean;
+        required?: boolean;
+        rows?: number | string;
+        value?: string | number;
+        wrap?: "hard" | "soft" | "off";
+        maxLength?: number | string;
+        minLength?: number | string;
+    }
+    interface ThHTMLAttributes<T> extends HTMLAttributes<T> {
+        headers?: string;
+        colSpan?: number | string;
+        rowSpan?: number | string;
+        scope?: "col" | "row" | "rowgroup" | "colgroup";
+    }
+    interface TimeHTMLAttributes<T> extends HTMLAttributes<T> {
+        dateTime?: string;
+    }
+    interface TrackHTMLAttributes<T> extends HTMLAttributes<T> {
+        default?: boolean;
+        kind?: "subtitles" | "captions" | "descriptions" | "chapters" | "metadata";
+        label?: string;
+        src?: string;
+        srclang?: string;
+        /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLTrackElement/cuechange_event) */
+        onCueChange?: EventHandlerUnion<T, Event>;
+    }
+    interface VideoHTMLAttributes<T> extends MediaHTMLAttributes<T> {
+        height?: number | string;
+        playsInline?: boolean;
+        poster?: string;
+        width?: number | string;
+        /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLVideoElement/resize_event) */
+        onResize?: EventHandlerUnion<T, UIEvent>;
+    }
+    type SVGPreserveAspectRatio = "none" | "xMinYMin" | "xMidYMin" | "xMaxYMin" | "xMinYMid" | "xMidYMid" | "xMaxYMid" | "xMinYMax" | "xMidYMax" | "xMaxYMax" | "xMinYMin meet" | "xMidYMin meet" | "xMaxYMin meet" | "xMinYMid meet" | "xMidYMid meet" | "xMaxYMid meet" | "xMinYMax meet" | "xMidYMax meet" | "xMaxYMax meet" | "xMinYMin slice" | "xMidYMin slice" | "xMaxYMin slice" | "xMinYMid slice" | "xMidYMid slice" | "xMaxYMid slice" | "xMinYMax slice" | "xMidYMax slice" | "xMaxYMax slice";
+    type ImagePreserveAspectRatio = SVGPreserveAspectRatio | "defer none" | "defer xMinYMin" | "defer xMidYMin" | "defer xMaxYMin" | "defer xMinYMid" | "defer xMidYMid" | "defer xMaxYMid" | "defer xMinYMax" | "defer xMidYMax" | "defer xMaxYMax" | "defer xMinYMin meet" | "defer xMidYMin meet" | "defer xMaxYMin meet" | "defer xMinYMid meet" | "defer xMidYMid meet" | "defer xMaxYMid meet" | "defer xMinYMax meet" | "defer xMidYMax meet" | "defer xMaxYMax meet" | "defer xMinYMin slice" | "defer xMidYMin slice" | "defer xMaxYMin slice" | "defer xMinYMid slice" | "defer xMidYMid slice" | "defer xMaxYMid slice" | "defer xMinYMax slice" | "defer xMidYMax slice" | "defer xMaxYMax slice";
+    type SVGUnits = "userSpaceOnUse" | "objectBoundingBox";
+    interface CoreSVGAttributes<T> extends AriaAttributes, DOMAttributes<T> {
+        id?: string;
+        lang?: string;
+        tabIndex?: number | string;
+    }
+    interface StylableSVGAttributes {
+        class?: string | ClassInfo | DirectiveResult<typeof ClassMapDirective>;
+        style?: CssProperties | string | DirectiveResult<typeof StyleMapDirective>;
+    }
+    interface TransformableSVGAttributes {
+        transform?: string | undefined;
+    }
+    interface ConditionalProcessingSVGAttributes {
+        requiredExtensions?: string;
+        requiredFeatures?: string;
+        systemLanguage?: string;
+    }
+    interface ExternalResourceSVGAttributes {
+        externalResourcesRequired?: boolean | "true" | "false";
+    }
+    interface AnimationTimingSVGAttributes {
+        begin?: string | undefined;
+        dur?: string | undefined;
+        end?: string | undefined;
+        min?: string | undefined;
+        max?: string | undefined;
+        restart?: "always" | "whenNotActive" | "never" | undefined;
+        repeatCount?: number | "indefinite" | undefined;
+        repeatDur?: string | undefined;
+        fill?: "freeze" | "remove" | undefined;
+    }
+    interface AnimationValueSVGAttributes {
+        calcMode?: "discrete" | "linear" | "paced" | "spline" | undefined;
+        values?: string | undefined;
+        keyTimes?: string | undefined;
+        keySplines?: string | undefined;
+        from?: number | string | undefined;
+        to?: number | string | undefined;
+        by?: number | string | undefined;
+    }
+    interface AnimationAdditionSVGAttributes {
+        attributeName?: string | undefined;
+        additive?: "replace" | "sum" | undefined;
+        accumulate?: "none" | "sum" | undefined;
+    }
+    interface AnimationAttributeTargetSVGAttributes {
+        attributeName?: string | undefined;
+        attributeType?: "CSS" | "XML" | "auto" | undefined;
+    }
+    interface PresentationSVGAttributes {
+        "alignment-baseline"?: "auto" | "baseline" | "before-edge" | "text-before-edge" | "middle" | "central" | "after-edge" | "text-after-edge" | "ideographic" | "alphabetic" | "hanging" | "mathematical" | "inherit";
+        "baseline-shift"?: number | string;
+        "clip"?: string;
+        "clip-path"?: string;
+        "clip-rule"?: "nonzero" | "evenodd" | "inherit";
+        "color"?: string;
+        "color-interpolation"?: "auto" | "sRGB" | "linearRGB" | "inherit";
+        "color-interpolation-filters"?: "auto" | "sRGB" | "linearRGB" | "inherit";
+        "color-profile"?: string;
+        "color-rendering"?: "auto" | "optimizeSpeed" | "optimizeQuality" | "inherit";
+        "cursor"?: string;
+        "direction"?: "ltr" | "rtl" | "inherit";
+        "display"?: string;
+        "dominant-baseline"?: "auto" | "text-bottom" | "alphabetic" | "ideographic" | "middle" | "central" | "mathematical" | "hanging" | "text-top" | "inherit";
+        "enable-background"?: string;
+        "fill"?: string;
+        "fill-opacity"?: number | string | "inherit";
+        "fill-rule"?: "nonzero" | "evenodd" | "inherit";
+        "filter"?: string;
+        "flood-color"?: string;
+        "flood-opacity"?: number | string | "inherit";
+        "font-family"?: string;
+        "font-size"?: string;
+        "font-size-adjust"?: number | string;
+        "font-stretch"?: string;
+        "font-style"?: "normal" | "italic" | "oblique" | "inherit";
+        "font-variant"?: string;
+        "font-weight"?: number | string;
+        "glyph-orientation-horizontal"?: string;
+        "glyph-orientation-vertical"?: string;
+        "image-rendering"?: "auto" | "optimizeQuality" | "optimizeSpeed" | "inherit";
+        "kerning"?: string;
+        "letter-spacing"?: number | string;
+        "lighting-color"?: string;
+        "marker-end"?: string;
+        "marker-mid"?: string;
+        "marker-start"?: string;
+        "mask"?: string;
+        "opacity"?: number | string | "inherit";
+        "overflow"?: "visible" | "hidden" | "scroll" | "auto" | "inherit";
+        "pathLength"?: string | number;
+        "pointer-events"?: "bounding-box" | "visiblePainted" | "visibleFill" | "visibleStroke" | "visible" | "painted" | "color" | "fill" | "stroke" | "all" | "none" | "inherit";
+        "shape-rendering"?: "auto" | "optimizeSpeed" | "crispEdges" | "geometricPrecision" | "inherit";
+        "stop-color"?: string;
+        "stop-opacity"?: number | string | "inherit";
+        "stroke"?: string;
+        "stroke-dasharray"?: string;
+        "stroke-dashoffset"?: number | string;
+        "stroke-linecap"?: "butt" | "round" | "square" | "inherit";
+        "stroke-linejoin"?: "arcs" | "bevel" | "miter" | "miter-clip" | "round" | "inherit";
+        "stroke-miterlimit"?: number | string | "inherit";
+        "stroke-opacity"?: number | string | "inherit";
+        "stroke-width"?: number | string;
+        "text-anchor"?: "start" | "middle" | "end" | "inherit";
+        "text-decoration"?: "none" | "underline" | "overline" | "line-through" | "blink" | "inherit";
+        "text-rendering"?: "auto" | "optimizeSpeed" | "optimizeLegibility" | "geometricPrecision" | "inherit";
+        "unicode-bidi"?: string;
+        "visibility"?: "visible" | "hidden" | "collapse" | "inherit";
+        "word-spacing"?: number | string;
+        "writing-mode"?: "lr-tb" | "rl-tb" | "tb-rl" | "lr" | "rl" | "tb" | "inherit";
+    }
+    interface AnimationElementSVGAttributes<T> extends CoreSVGAttributes<T>, ExternalResourceSVGAttributes, ConditionalProcessingSVGAttributes {
+    }
+    interface ContainerElementSVGAttributes<T> extends CoreSVGAttributes<T>, ShapeElementSVGAttributes<T>, Pick<PresentationSVGAttributes, "clip-path" | "mask" | "cursor" | "opacity" | "filter" | "enable-background" | "color-interpolation" | "color-rendering"> {
+    }
+    interface FilterPrimitiveElementSVGAttributes<T> extends CoreSVGAttributes<T>, Pick<PresentationSVGAttributes, "color-interpolation-filters"> {
+        x?: number | string | undefined;
+        y?: number | string | undefined;
+        width?: number | string | undefined;
+        height?: number | string | undefined;
+        result?: string | undefined;
+    }
+    interface SingleInputFilterSVGAttributes {
+        in?: string | undefined;
+    }
+    interface DoubleInputFilterSVGAttributes {
+        in?: string | undefined;
+        in2?: string | undefined;
+    }
+    interface FitToViewBoxSVGAttributes {
+        viewBox?: string;
+        preserveAspectRatio?: SVGPreserveAspectRatio;
+    }
+    interface GradientElementSVGAttributes<T> extends CoreSVGAttributes<T>, ExternalResourceSVGAttributes, StylableSVGAttributes {
+        gradientUnits?: SVGUnits | undefined;
+        gradientTransform?: string | undefined;
+        spreadMethod?: "pad" | "reflect" | "repeat" | undefined;
+        href?: string | undefined;
+    }
+    interface GraphicsElementSVGAttributes<T> extends CoreSVGAttributes<T>, Pick<PresentationSVGAttributes, "clip-rule" | "mask" | "pointer-events" | "cursor" | "opacity" | "filter" | "display" | "visibility" | "color-interpolation" | "color-rendering"> {
+    }
+    interface LightSourceElementSVGAttributes<T> extends CoreSVGAttributes<T> {
+    }
+    interface NewViewportSVGAttributes<T> extends CoreSVGAttributes<T>, Pick<PresentationSVGAttributes, "overflow" | "clip"> {
+        viewBox?: string;
+    }
+    interface ShapeElementSVGAttributes<T> extends CoreSVGAttributes<T>, Pick<PresentationSVGAttributes, "color" | "fill" | "fill-rule" | "fill-opacity" | "stroke" | "stroke-width" | "stroke-linecap" | "stroke-linejoin" | "stroke-miterlimit" | "stroke-dasharray" | "stroke-dashoffset" | "stroke-opacity" | "shape-rendering" | "pathLength"> {
+    }
+    interface TextContentElementSVGAttributes<T> extends CoreSVGAttributes<T>, Pick<PresentationSVGAttributes, "font-family" | "font-style" | "font-variant" | "font-weight" | "font-stretch" | "font-size" | "font-size-adjust" | "kerning" | "letter-spacing" | "word-spacing" | "text-decoration" | "glyph-orientation-horizontal" | "glyph-orientation-vertical" | "direction" | "unicode-bidi" | "text-anchor" | "dominant-baseline" | "color" | "fill" | "fill-rule" | "fill-opacity" | "stroke" | "stroke-width" | "stroke-linecap" | "stroke-linejoin" | "stroke-miterlimit" | "stroke-dasharray" | "stroke-dashoffset" | "stroke-opacity"> {
+    }
+    interface ZoomAndPanSVGAttributes {
+        zoomAndPan?: "disable" | "magnify";
+    }
+    interface AnimateSVGAttributes<T> extends AnimationElementSVGAttributes<T>, AnimationAttributeTargetSVGAttributes, AnimationTimingSVGAttributes, AnimationValueSVGAttributes, AnimationAdditionSVGAttributes, Pick<PresentationSVGAttributes, "color-interpolation" | "color-rendering"> {
+    }
+    interface AnimateMotionSVGAttributes<T> extends AnimationElementSVGAttributes<T>, AnimationTimingSVGAttributes, AnimationValueSVGAttributes, AnimationAdditionSVGAttributes {
+        path?: string | undefined;
+        keyPoints?: string | undefined;
+        rotate?: number | string | "auto" | "auto-reverse" | undefined;
+        origin?: "default" | undefined;
+    }
+    interface AnimateTransformSVGAttributes<T> extends AnimationElementSVGAttributes<T>, AnimationAttributeTargetSVGAttributes, AnimationTimingSVGAttributes, AnimationValueSVGAttributes, AnimationAdditionSVGAttributes {
+        type?: "translate" | "scale" | "rotate" | "skewX" | "skewY" | undefined;
+    }
+    interface CircleSVGAttributes<T> extends GraphicsElementSVGAttributes<T>, ShapeElementSVGAttributes<T>, ConditionalProcessingSVGAttributes, StylableSVGAttributes, TransformableSVGAttributes {
+        cx?: number | string | undefined;
+        cy?: number | string | undefined;
+        r?: number | string | undefined;
+    }
+    interface ClipPathSVGAttributes<T> extends CoreSVGAttributes<T>, ConditionalProcessingSVGAttributes, ExternalResourceSVGAttributes, StylableSVGAttributes, TransformableSVGAttributes, Pick<PresentationSVGAttributes, "clip-path"> {
+        clipPathUnits?: SVGUnits | undefined;
+    }
+    interface DefsSVGAttributes<T> extends ContainerElementSVGAttributes<T>, ConditionalProcessingSVGAttributes, ExternalResourceSVGAttributes, StylableSVGAttributes, TransformableSVGAttributes {
+    }
+    interface DescSVGAttributes<T> extends CoreSVGAttributes<T>, StylableSVGAttributes {
+    }
+    interface EllipseSVGAttributes<T> extends GraphicsElementSVGAttributes<T>, ShapeElementSVGAttributes<T>, ConditionalProcessingSVGAttributes, ExternalResourceSVGAttributes, StylableSVGAttributes, TransformableSVGAttributes {
+        cx?: number | string | undefined;
+        cy?: number | string | undefined;
+        rx?: number | string | undefined;
+        ry?: number | string | undefined;
+    }
+    interface FeBlendSVGAttributes<T> extends FilterPrimitiveElementSVGAttributes<T>, DoubleInputFilterSVGAttributes, StylableSVGAttributes {
+        mode?: "normal" | "multiply" | "screen" | "darken" | "lighten" | undefined;
+    }
+    interface FeColorMatrixSVGAttributes<T> extends FilterPrimitiveElementSVGAttributes<T>, SingleInputFilterSVGAttributes, StylableSVGAttributes {
+        type?: "matrix" | "saturate" | "hueRotate" | "luminanceToAlpha" | undefined;
+        values?: string | undefined;
+    }
+    interface FeComponentTransferSVGAttributes<T> extends FilterPrimitiveElementSVGAttributes<T>, SingleInputFilterSVGAttributes, StylableSVGAttributes {
+    }
+    interface FeCompositeSVGAttributes<T> extends FilterPrimitiveElementSVGAttributes<T>, DoubleInputFilterSVGAttributes, StylableSVGAttributes {
+        operator?: "over" | "in" | "out" | "atop" | "xor" | "arithmetic" | undefined;
+        k1?: number | string | undefined;
+        k2?: number | string | undefined;
+        k3?: number | string | undefined;
+        k4?: number | string | undefined;
+    }
+    interface FeConvolveMatrixSVGAttributes<T> extends FilterPrimitiveElementSVGAttributes<T>, SingleInputFilterSVGAttributes, StylableSVGAttributes {
+        order?: number | string | undefined;
+        kernelMatrix?: string | undefined;
+        divisor?: number | string | undefined;
+        bias?: number | string | undefined;
+        targetX?: number | string | undefined;
+        targetY?: number | string | undefined;
+        edgeMode?: "duplicate" | "wrap" | "none" | undefined;
+        kernelUnitLength?: number | string | undefined;
+        preserveAlpha?: boolean | "true" | "false" | undefined;
+    }
+    interface FeDiffuseLightingSVGAttributes<T> extends FilterPrimitiveElementSVGAttributes<T>, SingleInputFilterSVGAttributes, StylableSVGAttributes, Pick<PresentationSVGAttributes, "color" | "lighting-color"> {
+        surfaceScale?: number | string | undefined;
+        diffuseConstant?: number | string | undefined;
+        kernelUnitLength?: number | string | undefined;
+    }
+    interface FeDisplacementMapSVGAttributes<T> extends FilterPrimitiveElementSVGAttributes<T>, DoubleInputFilterSVGAttributes, StylableSVGAttributes {
+        scale?: number | string | undefined;
+        xChannelSelector?: "R" | "G" | "B" | "A" | undefined;
+        yChannelSelector?: "R" | "G" | "B" | "A" | undefined;
+    }
+    interface FeDistantLightSVGAttributes<T> extends LightSourceElementSVGAttributes<T> {
+        azimuth?: number | string | undefined;
+        elevation?: number | string | undefined;
+    }
+    interface FeDropShadowSVGAttributes<T> extends CoreSVGAttributes<T>, FilterPrimitiveElementSVGAttributes<T>, StylableSVGAttributes, Pick<PresentationSVGAttributes, "color" | "flood-color" | "flood-opacity"> {
+        dx?: number | string | undefined;
+        dy?: number | string | undefined;
+        stdDeviation?: number | string | undefined;
+    }
+    interface FeFloodSVGAttributes<T> extends FilterPrimitiveElementSVGAttributes<T>, StylableSVGAttributes, Pick<PresentationSVGAttributes, "color" | "flood-color" | "flood-opacity"> {
+    }
+    interface FeFuncSVGAttributes<T> extends CoreSVGAttributes<T> {
+        type?: "identity" | "table" | "discrete" | "linear" | "gamma" | undefined;
+        tableValues?: string | undefined;
+        slope?: number | string | undefined;
+        intercept?: number | string | undefined;
+        amplitude?: number | string | undefined;
+        exponent?: number | string | undefined;
+        offset?: number | string | undefined;
+    }
+    interface FeGaussianBlurSVGAttributes<T> extends FilterPrimitiveElementSVGAttributes<T>, SingleInputFilterSVGAttributes, StylableSVGAttributes {
+        stdDeviation?: number | string | undefined;
+    }
+    interface FeImageSVGAttributes<T> extends FilterPrimitiveElementSVGAttributes<T>, ExternalResourceSVGAttributes, StylableSVGAttributes {
+        preserveAspectRatio?: SVGPreserveAspectRatio | undefined;
+        href?: string | undefined;
+    }
+    interface FeMergeSVGAttributes<T> extends FilterPrimitiveElementSVGAttributes<T>, StylableSVGAttributes {
+    }
+    interface FeMergeNodeSVGAttributes<T> extends CoreSVGAttributes<T>, SingleInputFilterSVGAttributes {
+    }
+    interface FeMorphologySVGAttributes<T> extends FilterPrimitiveElementSVGAttributes<T>, SingleInputFilterSVGAttributes, StylableSVGAttributes {
+        operator?: "erode" | "dilate" | undefined;
+        radius?: number | string | undefined;
+    }
+    interface FeOffsetSVGAttributes<T> extends FilterPrimitiveElementSVGAttributes<T>, SingleInputFilterSVGAttributes, StylableSVGAttributes {
+        dx?: number | string | undefined;
+        dy?: number | string | undefined;
+    }
+    interface FePointLightSVGAttributes<T> extends LightSourceElementSVGAttributes<T> {
+        x?: number | string | undefined;
+        y?: number | string | undefined;
+        z?: number | string | undefined;
+    }
+    interface FeSpecularLightingSVGAttributes<T> extends FilterPrimitiveElementSVGAttributes<T>, SingleInputFilterSVGAttributes, StylableSVGAttributes, Pick<PresentationSVGAttributes, "color" | "lighting-color"> {
+        surfaceScale?: string | undefined;
+        specularConstant?: string | undefined;
+        specularExponent?: string | undefined;
+        kernelUnitLength?: number | string | undefined;
+    }
+    interface FeSpotLightSVGAttributes<T> extends LightSourceElementSVGAttributes<T> {
+        x?: number | string | undefined;
+        y?: number | string | undefined;
+        z?: number | string | undefined;
+        pointsAtX?: number | string | undefined;
+        pointsAtY?: number | string | undefined;
+        pointsAtZ?: number | string | undefined;
+        specularExponent?: number | string | undefined;
+        limitingConeAngle?: number | string | undefined;
+    }
+    interface FeTileSVGAttributes<T> extends FilterPrimitiveElementSVGAttributes<T>, SingleInputFilterSVGAttributes, StylableSVGAttributes {
+    }
+    interface FeTurbulanceSVGAttributes<T> extends FilterPrimitiveElementSVGAttributes<T>, StylableSVGAttributes {
+        baseFrequency?: number | string | undefined;
+        numOctaves?: number | string | undefined;
+        seed?: number | string | undefined;
+        stitchTiles?: "stitch" | "noStitch" | undefined;
+        type?: "fractalNoise" | "turbulence" | undefined;
+    }
+    interface FilterSVGAttributes<T> extends CoreSVGAttributes<T>, ExternalResourceSVGAttributes, StylableSVGAttributes {
+        filterUnits?: SVGUnits | undefined;
+        primitiveUnits?: SVGUnits | undefined;
+        x?: number | string | undefined;
+        y?: number | string | undefined;
+        width?: number | string | undefined;
+        height?: number | string | undefined;
+        filterRes?: number | string | undefined;
+    }
+    interface ForeignObjectSVGAttributes<T> extends NewViewportSVGAttributes<T>, ConditionalProcessingSVGAttributes, ExternalResourceSVGAttributes, StylableSVGAttributes, TransformableSVGAttributes, Pick<PresentationSVGAttributes, "display" | "visibility"> {
+        x?: number | string | undefined;
+        y?: number | string | undefined;
+        width?: number | string | undefined;
+        height?: number | string | undefined;
+    }
+    interface GSVGAttributes<T> extends ContainerElementSVGAttributes<T>, ConditionalProcessingSVGAttributes, ExternalResourceSVGAttributes, StylableSVGAttributes, TransformableSVGAttributes, Pick<PresentationSVGAttributes, "display" | "visibility"> {
+    }
+    interface ImageSVGAttributes<T> extends NewViewportSVGAttributes<T>, GraphicsElementSVGAttributes<T>, ConditionalProcessingSVGAttributes, StylableSVGAttributes, TransformableSVGAttributes, Pick<PresentationSVGAttributes, "color-profile" | "image-rendering"> {
+        x?: number | string | undefined;
+        y?: number | string | undefined;
+        width?: number | string | undefined;
+        height?: number | string | undefined;
+        preserveAspectRatio?: ImagePreserveAspectRatio | undefined;
+        href?: string | undefined;
+    }
+    interface LineSVGAttributes<T> extends GraphicsElementSVGAttributes<T>, ShapeElementSVGAttributes<T>, ConditionalProcessingSVGAttributes, ExternalResourceSVGAttributes, StylableSVGAttributes, TransformableSVGAttributes, Pick<PresentationSVGAttributes, "marker-start" | "marker-mid" | "marker-end"> {
+        x1?: number | string | undefined;
+        y1?: number | string | undefined;
+        x2?: number | string | undefined;
+        y2?: number | string | undefined;
+    }
+    interface LinearGradientSVGAttributes<T> extends GradientElementSVGAttributes<T> {
+        x1?: number | string | undefined;
+        x2?: number | string | undefined;
+        y1?: number | string | undefined;
+        y2?: number | string | undefined;
+    }
+    interface MarkerSVGAttributes<T> extends ContainerElementSVGAttributes<T>, ExternalResourceSVGAttributes, StylableSVGAttributes, FitToViewBoxSVGAttributes, Pick<PresentationSVGAttributes, "overflow" | "clip"> {
+        markerUnits?: "strokeWidth" | "userSpaceOnUse" | undefined;
+        refX?: number | string | undefined;
+        refY?: number | string | undefined;
+        markerWidth?: number | string | undefined;
+        markerHeight?: number | string | undefined;
+        orient?: string | undefined;
+    }
+    interface MaskSVGAttributes<T> extends Omit<ContainerElementSVGAttributes<T>, "opacity" | "filter">, ConditionalProcessingSVGAttributes, ExternalResourceSVGAttributes, StylableSVGAttributes {
+        maskUnits?: SVGUnits | undefined;
+        maskContentUnits?: SVGUnits | undefined;
+        x?: number | string | undefined;
+        y?: number | string | undefined;
+        width?: number | string | undefined;
+        height?: number | string | undefined;
+    }
+    interface MetadataSVGAttributes<T> extends CoreSVGAttributes<T> {
+    }
+    interface MPathSVGAttributes<T> extends CoreSVGAttributes<T> {
+    }
+    interface PathSVGAttributes<T> extends GraphicsElementSVGAttributes<T>, ShapeElementSVGAttributes<T>, ConditionalProcessingSVGAttributes, ExternalResourceSVGAttributes, StylableSVGAttributes, TransformableSVGAttributes, Pick<PresentationSVGAttributes, "marker-start" | "marker-mid" | "marker-end"> {
+        d?: string | undefined;
+        pathLength?: number | string | undefined;
+    }
+    interface PatternSVGAttributes<T> extends ContainerElementSVGAttributes<T>, ConditionalProcessingSVGAttributes, ExternalResourceSVGAttributes, StylableSVGAttributes, FitToViewBoxSVGAttributes, Pick<PresentationSVGAttributes, "overflow" | "clip"> {
+        x?: number | string | undefined;
+        y?: number | string | undefined;
+        width?: number | string | undefined;
+        height?: number | string | undefined;
+        patternUnits?: SVGUnits | undefined;
+        patternContentUnits?: SVGUnits | undefined;
+        patternTransform?: string | undefined;
+        href?: string | undefined;
+    }
+    interface PolygonSVGAttributes<T> extends GraphicsElementSVGAttributes<T>, ShapeElementSVGAttributes<T>, ConditionalProcessingSVGAttributes, ExternalResourceSVGAttributes, StylableSVGAttributes, TransformableSVGAttributes, Pick<PresentationSVGAttributes, "marker-start" | "marker-mid" | "marker-end"> {
+        points?: string | undefined;
+    }
+    interface PolylineSVGAttributes<T> extends GraphicsElementSVGAttributes<T>, ShapeElementSVGAttributes<T>, ConditionalProcessingSVGAttributes, ExternalResourceSVGAttributes, StylableSVGAttributes, TransformableSVGAttributes, Pick<PresentationSVGAttributes, "marker-start" | "marker-mid" | "marker-end"> {
+        points?: string | undefined;
+    }
+    interface RadialGradientSVGAttributes<T> extends GradientElementSVGAttributes<T> {
+        cx?: number | string | undefined;
+        cy?: number | string | undefined;
+        r?: number | string | undefined;
+        fx?: number | string | undefined;
+        fy?: number | string | undefined;
+    }
+    interface RectSVGAttributes<T> extends GraphicsElementSVGAttributes<T>, ShapeElementSVGAttributes<T>, ConditionalProcessingSVGAttributes, ExternalResourceSVGAttributes, StylableSVGAttributes, TransformableSVGAttributes {
+        x?: number | string | undefined;
+        y?: number | string | undefined;
+        width?: number | string | undefined;
+        height?: number | string | undefined;
+        rx?: number | string | undefined;
+        ry?: number | string | undefined;
+    }
+    interface SetSVGAttributes<T> extends CoreSVGAttributes<T>, StylableSVGAttributes, AnimationTimingSVGAttributes {
+    }
+    interface StopSVGAttributes<T> extends CoreSVGAttributes<T>, StylableSVGAttributes, Pick<PresentationSVGAttributes, "color" | "stop-color" | "stop-opacity"> {
+        offset?: number | string | undefined;
+    }
+    interface SvgSVGAttributes<T> extends ContainerElementSVGAttributes<T>, NewViewportSVGAttributes<T>, ConditionalProcessingSVGAttributes, ExternalResourceSVGAttributes, StylableSVGAttributes, FitToViewBoxSVGAttributes, ZoomAndPanSVGAttributes, PresentationSVGAttributes {
+        version?: string;
+        baseProfile?: string;
+        x?: number | string;
+        y?: number | string;
+        width?: number | string;
+        height?: number | string;
+        contentScriptType?: string;
+        contentStyleType?: string;
+        xmlns?: string;
+        /**
+         * Fires immediately after the browser loads the object.
+         *
+         * [MDN Reference](https://developer.mozilla.org/docs/Web/API/SVGElement/load_event)
+         */
+        onLoad?: EventHandlerUnion<T, Event>;
+    }
+    interface SwitchSVGAttributes<T> extends ContainerElementSVGAttributes<T>, ConditionalProcessingSVGAttributes, ExternalResourceSVGAttributes, StylableSVGAttributes, TransformableSVGAttributes, Pick<PresentationSVGAttributes, "display" | "visibility"> {
+    }
+    interface SymbolSVGAttributes<T> extends ContainerElementSVGAttributes<T>, NewViewportSVGAttributes<T>, ExternalResourceSVGAttributes, StylableSVGAttributes, FitToViewBoxSVGAttributes {
+        width?: number | string | undefined;
+        height?: number | string | undefined;
+        preserveAspectRatio?: SVGPreserveAspectRatio | undefined;
+        refX?: number | string | undefined;
+        refY?: number | string | undefined;
+        viewBox?: string | undefined;
+        x?: number | string | undefined;
+        y?: number | string | undefined;
+    }
+    interface TextSVGAttributes<T> extends TextContentElementSVGAttributes<T>, GraphicsElementSVGAttributes<T>, ConditionalProcessingSVGAttributes, ExternalResourceSVGAttributes, StylableSVGAttributes, TransformableSVGAttributes, Pick<PresentationSVGAttributes, "writing-mode" | "text-rendering"> {
+        x?: number | string | undefined;
+        y?: number | string | undefined;
+        dx?: number | string | undefined;
+        dy?: number | string | undefined;
+        rotate?: number | string | undefined;
+        textLength?: number | string | undefined;
+        lengthAdjust?: "spacing" | "spacingAndGlyphs" | undefined;
+    }
+    interface TextPathSVGAttributes<T> extends TextContentElementSVGAttributes<T>, ConditionalProcessingSVGAttributes, ExternalResourceSVGAttributes, StylableSVGAttributes, Pick<PresentationSVGAttributes, "alignment-baseline" | "baseline-shift" | "display" | "visibility"> {
+        startOffset?: number | string | undefined;
+        method?: "align" | "stretch" | undefined;
+        spacing?: "auto" | "exact" | undefined;
+        href?: string | undefined;
+    }
+    interface TSpanSVGAttributes<T> extends TextContentElementSVGAttributes<T>, ConditionalProcessingSVGAttributes, ExternalResourceSVGAttributes, StylableSVGAttributes, Pick<PresentationSVGAttributes, "alignment-baseline" | "baseline-shift" | "display" | "visibility"> {
+        x?: number | string | undefined;
+        y?: number | string | undefined;
+        dx?: number | string | undefined;
+        dy?: number | string | undefined;
+        rotate?: number | string | undefined;
+        textLength?: number | string | undefined;
+        lengthAdjust?: "spacing" | "spacingAndGlyphs" | undefined;
+    }
+    /**
+     * @see https://developer.mozilla.org/en-US/docs/Web/SVG/Element/use
+     */
+    interface UseSVGAttributes<T> extends CoreSVGAttributes<T>, StylableSVGAttributes, ConditionalProcessingSVGAttributes, GraphicsElementSVGAttributes<T>, PresentationSVGAttributes, ExternalResourceSVGAttributes, TransformableSVGAttributes {
+        x?: number | string | undefined;
+        y?: number | string | undefined;
+        width?: number | string | undefined;
+        height?: number | string | undefined;
+        href?: string | undefined;
+    }
+    interface ViewSVGAttributes<T> extends CoreSVGAttributes<T>, ExternalResourceSVGAttributes, FitToViewBoxSVGAttributes, ZoomAndPanSVGAttributes {
+        viewTarget?: string | undefined;
+    }
+    /**
+     * A list of native HTML elements and their props.
+     *
+     * @see {HTMLElementTagNameMap}
+     */
+    interface HTMLElementTags {
+        a: AnchorHTMLAttributes<HTMLAnchorElement>;
+        abbr: HTMLAttributes;
+        address: HTMLAttributes;
+        area: AreaHTMLAttributes<HTMLAreaElement>;
+        article: HTMLAttributes;
+        aside: HTMLAttributes;
+        audio: AudioHTMLAttributes<HTMLAudioElement>;
+        b: HTMLAttributes;
+        base: BaseHTMLAttributes<HTMLBaseElement>;
+        bdi: HTMLAttributes;
+        bdo: HTMLAttributes;
+        blockquote: BlockquoteHTMLAttributes<HTMLElement>;
+        body: HTMLAttributes<HTMLBodyElement>;
+        br: HTMLAttributes<HTMLBRElement>;
+        button: ButtonHTMLAttributes<HTMLButtonElement>;
+        canvas: CanvasHTMLAttributes<HTMLCanvasElement>;
+        caption: HTMLAttributes;
+        cite: HTMLAttributes;
+        code: HTMLAttributes;
+        col: ColHTMLAttributes<HTMLTableColElement>;
+        colgroup: ColgroupHTMLAttributes<HTMLTableColElement>;
+        data: DataHTMLAttributes<HTMLElement>;
+        datalist: HTMLAttributes<HTMLDataListElement>;
+        dd: HTMLAttributes;
+        del: HTMLAttributes;
+        details: DetailsHTMLAttributes<HTMLDetailsElement>;
+        dfn: HTMLAttributes;
+        dialog: DialogHTMLAttributes<HTMLDialogElement>;
+        div: HTMLAttributes<HTMLDivElement>;
+        dl: HTMLAttributes<HTMLDListElement>;
+        dt: HTMLAttributes;
+        em: HTMLAttributes;
+        embed: EmbedHTMLAttributes<HTMLEmbedElement>;
+        fieldset: FieldsetHTMLAttributes<HTMLFieldSetElement>;
+        figcaption: HTMLAttributes;
+        figure: HTMLAttributes;
+        footer: HTMLAttributes;
+        form: FormHTMLAttributes<HTMLFormElement>;
+        h1: HTMLAttributes<HTMLHeadingElement>;
+        h2: HTMLAttributes<HTMLHeadingElement>;
+        h3: HTMLAttributes<HTMLHeadingElement>;
+        h4: HTMLAttributes<HTMLHeadingElement>;
+        h5: HTMLAttributes<HTMLHeadingElement>;
+        h6: HTMLAttributes<HTMLHeadingElement>;
+        head: HTMLAttributes<HTMLHeadElement>;
+        header: HTMLAttributes;
+        hgroup: HTMLAttributes;
+        hr: HTMLAttributes<HTMLHRElement>;
+        html: HTMLAttributes<HTMLHtmlElement>;
+        i: HTMLAttributes;
+        iframe: IframeHTMLAttributes<HTMLIFrameElement>;
+        img: ImgHTMLAttributes<HTMLImageElement>;
+        input: InputHTMLAttributes<HTMLInputElement>;
+        ins: InsHTMLAttributes<HTMLModElement>;
+        kbd: HTMLAttributes;
+        label: LabelHTMLAttributes<HTMLLabelElement>;
+        legend: HTMLAttributes<HTMLLegendElement>;
+        li: LiHTMLAttributes<HTMLLIElement>;
+        link: LinkHTMLAttributes<HTMLLinkElement>;
+        main: HTMLAttributes;
+        map: MapHTMLAttributes<HTMLMapElement>;
+        math: MathMLAttributes;
+        mark: HTMLAttributes;
+        menu: MenuHTMLAttributes<HTMLElement>;
+        meta: MetaHTMLAttributes<HTMLMetaElement>;
+        meter: MeterHTMLAttributes<HTMLElement>;
+        nav: HTMLAttributes;
+        noscript: HTMLAttributes;
+        object: ObjectHTMLAttributes<HTMLObjectElement>;
+        ol: OlHTMLAttributes<HTMLOListElement>;
+        optgroup: OptgroupHTMLAttributes<HTMLOptGroupElement>;
+        option: OptionHTMLAttributes<HTMLOptionElement>;
+        output: OutputHTMLAttributes<HTMLElement>;
+        p: HTMLAttributes<HTMLParagraphElement>;
+        picture: HTMLAttributes;
+        pre: HTMLAttributes<HTMLPreElement>;
+        progress: ProgressHTMLAttributes<HTMLProgressElement>;
+        q: QuoteHTMLAttributes<HTMLQuoteElement>;
+        rp: HTMLAttributes;
+        rt: HTMLAttributes;
+        ruby: HTMLAttributes;
+        s: HTMLAttributes;
+        samp: HTMLAttributes;
+        script: ScriptHTMLAttributes<HTMLScriptElement>;
+        search: HTMLAttributes;
+        section: HTMLAttributes;
+        select: SelectHTMLAttributes<HTMLSelectElement>;
+        slot: SlotHTMLAttributes;
+        small: HTMLAttributes;
+        source: SourceHTMLAttributes<HTMLSourceElement>;
+        span: HTMLAttributes<HTMLSpanElement>;
+        strong: HTMLAttributes;
+        /**
+         * For use when you have a dynamic CSS string that needs to be added as a
+         * style. If you have a static string, use Lit's "styles" property instead
+         * for better performance.
+         */
+        style: StyleHTMLAttributes<HTMLStyleElement>;
+        svg: SvgSVGAttributes<SVGSVGElement>;
+        sub: HTMLAttributes;
+        summary: HTMLAttributes;
+        sup: HTMLAttributes;
+        table: HTMLAttributes<HTMLTableElement>;
+        tbody: HTMLAttributes<HTMLTableSectionElement>;
+        td: TdHTMLAttributes<HTMLTableCellElement>;
+        template: TemplateHTMLAttributes<HTMLTemplateElement>;
+        textarea: TextareaHTMLAttributes<HTMLTextAreaElement>;
+        tfoot: HTMLAttributes<HTMLTableSectionElement>;
+        th: ThHTMLAttributes<HTMLTableCellElement>;
+        thead: HTMLAttributes<HTMLTableSectionElement>;
+        time: TimeHTMLAttributes<HTMLElement>;
+        title: HTMLAttributes<HTMLTitleElement>;
+        tr: HTMLAttributes<HTMLTableRowElement>;
+        track: TrackHTMLAttributes<HTMLTrackElement>;
+        u: HTMLAttributes;
+        ul: HTMLAttributes<HTMLUListElement>;
+        var: HTMLAttributes;
+        video: VideoHTMLAttributes<HTMLVideoElement>;
+        wbr: HTMLAttributes;
+    }
+    /**
+     * A list of native SVG elements and their props.
+     *
+     * @type {SVGElementTagNameMap}
+     */
+    interface SVGElementTags {
+        animate: AnimateSVGAttributes<SVGAnimateElement>;
+        animateMotion: AnimateMotionSVGAttributes<SVGAnimateMotionElement>;
+        animateTransform: AnimateTransformSVGAttributes<SVGAnimateTransformElement>;
+        circle: CircleSVGAttributes<SVGCircleElement>;
+        clipPath: ClipPathSVGAttributes<SVGClipPathElement>;
+        defs: DefsSVGAttributes<SVGDefsElement>;
+        desc: DescSVGAttributes<SVGDescElement>;
+        ellipse: EllipseSVGAttributes<SVGEllipseElement>;
+        feBlend: FeBlendSVGAttributes<SVGFEBlendElement>;
+        feColorMatrix: FeColorMatrixSVGAttributes<SVGFEColorMatrixElement>;
+        feComponentTransfer: FeComponentTransferSVGAttributes<SVGFEComponentTransferElement>;
+        feComposite: FeCompositeSVGAttributes<SVGFECompositeElement>;
+        feConvolveMatrix: FeConvolveMatrixSVGAttributes<SVGFEConvolveMatrixElement>;
+        feDiffuseLighting: FeDiffuseLightingSVGAttributes<SVGFEDiffuseLightingElement>;
+        feDisplacementMap: FeDisplacementMapSVGAttributes<SVGFEDisplacementMapElement>;
+        feDistantLight: FeDistantLightSVGAttributes<SVGFEDistantLightElement>;
+        feDropShadow: FeDropShadowSVGAttributes<SVGFEDropShadowElement>;
+        feFlood: FeFloodSVGAttributes<SVGFEFloodElement>;
+        feFuncA: FeFuncSVGAttributes<SVGFEFuncAElement>;
+        feFuncB: FeFuncSVGAttributes<SVGFEFuncBElement>;
+        feFuncG: FeFuncSVGAttributes<SVGFEFuncGElement>;
+        feFuncR: FeFuncSVGAttributes<SVGFEFuncRElement>;
+        feGaussianBlur: FeGaussianBlurSVGAttributes<SVGFEGaussianBlurElement>;
+        feImage: FeImageSVGAttributes<SVGFEImageElement>;
+        feMerge: FeMergeSVGAttributes<SVGFEMergeElement>;
+        feMergeNode: FeMergeNodeSVGAttributes<SVGFEMergeNodeElement>;
+        feMorphology: FeMorphologySVGAttributes<SVGFEMorphologyElement>;
+        feOffset: FeOffsetSVGAttributes<SVGFEOffsetElement>;
+        fePointLight: FePointLightSVGAttributes<SVGFEPointLightElement>;
+        feSpecularLighting: FeSpecularLightingSVGAttributes<SVGFESpecularLightingElement>;
+        feSpotLight: FeSpotLightSVGAttributes<SVGFESpotLightElement>;
+        feTile: FeTileSVGAttributes<SVGFETileElement>;
+        feTurbulence: FeTurbulanceSVGAttributes<SVGFETurbulenceElement>;
+        filter: FilterSVGAttributes<SVGFilterElement>;
+        foreignObject: ForeignObjectSVGAttributes<SVGForeignObjectElement>;
+        g: GSVGAttributes<SVGGElement>;
+        image: ImageSVGAttributes<SVGImageElement>;
+        line: LineSVGAttributes<SVGLineElement>;
+        linearGradient: LinearGradientSVGAttributes<SVGLinearGradientElement>;
+        marker: MarkerSVGAttributes<SVGMarkerElement>;
+        mask: MaskSVGAttributes<SVGMaskElement>;
+        metadata: MetadataSVGAttributes<SVGMetadataElement>;
+        mpath: MPathSVGAttributes<SVGMPathElement>;
+        path: PathSVGAttributes<SVGPathElement>;
+        pattern: PatternSVGAttributes<SVGPatternElement>;
+        polygon: PolygonSVGAttributes<SVGPolygonElement>;
+        polyline: PolylineSVGAttributes<SVGPolylineElement>;
+        radialGradient: RadialGradientSVGAttributes<SVGRadialGradientElement>;
+        rect: RectSVGAttributes<SVGRectElement>;
+        set: SetSVGAttributes<SVGSetElement>;
+        stop: StopSVGAttributes<SVGStopElement>;
+        svg: SvgSVGAttributes<SVGSVGElement>;
+        switch: SwitchSVGAttributes<SVGSwitchElement>;
+        symbol: SymbolSVGAttributes<SVGSymbolElement>;
+        text: TextSVGAttributes<SVGTextElement>;
+        textPath: TextPathSVGAttributes<SVGTextPathElement>;
+        tspan: TSpanSVGAttributes<SVGTSpanElement>;
+        use: UseSVGAttributes<SVGUseElement>;
+        view: ViewSVGAttributes<SVGViewElement>;
+    }
+}
+export {};