// Generated by dts-bundle v0.7.3

declare module 'solid-js' {
  export {
    createRoot,
    createSignal,
    createEffect,
    createRenderEffect,
    createComputed,
    createDeferred,
    createSelector,
    createMemo,
    createResource,
    onMount,
    onCleanup,
    onError,
    untrack,
    batch,
    on,
    useTransition,
    createContext,
    useContext,
    children,
    getListener,
    getOwner,
    runWithOwner,
    equalFn,
    $PROXY,
  } from 'solid-js/reactive/signal';
  export type {
    Accessor,
    Resource,
    ResourceReturn,
    Context,
    ReturnTypes,
  } from 'solid-js/reactive/signal';
  export * from 'solid-js/reactive/observable';
  export * from 'solid-js/reactive/scheduler';
  export * from 'solid-js/reactive/array';
  export * from 'solid-js/render';
  import type { JSX } from 'solid-js/jsx';
  type JSXElement = JSX.Element;
  export type { JSXElement, JSX };
  export function awaitSuspense(): void;
  import { writeSignal, serializeGraph, registerGraph, hashValue } from 'solid-js/reactive/signal';
  let DEV: {
    writeSignal: typeof writeSignal;
    serializeGraph: typeof serializeGraph;
    registerGraph: typeof registerGraph;
    hashValue: typeof hashValue;
  };
  export { DEV };
  global {
    var Solid$$: boolean;
  }
}

declare module 'solid-js/reactive/signal' {
  import type { JSX } from 'solid-js/jsx';
  export type Accessor<T> = () => T;
  export const equalFn: <T>(a: T, b: T) => boolean;
  export const $PROXY: unique symbol;
  export const NOTPENDING: {};
  export var Owner: Owner | null;
  export let Transition: Transition | null;
  global {
    var _$afterUpdate: () => void;
  }
  interface Signal<T> {
    value?: T;
    observers: Computation<any>[] | null;
    observerSlots: number[] | null;
    pending: T | {};
    tValue?: T;
    comparator?: (prev: T, next: T) => boolean;
    name?: string;
  }
  interface Owner {
    owned: Computation<any>[] | null;
    cleanups: (() => void)[] | null;
    owner: Owner | null;
    context: any | null;
    attached?: boolean;
    sourceMap?: Record<
      string,
      {
        value: unknown;
      }
    >;
    name?: string;
    componentName?: string;
  }
  interface Computation<T> extends Owner {
    fn: (v?: T) => T;
    state: number;
    sources: Signal<T>[] | null;
    sourceSlots: number[] | null;
    value?: T;
    updatedAt: number | null;
    pure: boolean;
    user?: boolean;
    suspense?: SuspenseContextType;
  }
  interface Memo<T> extends Signal<T>, Computation<T> {
    tOwned?: Computation<any>[];
  }
  interface Transition {
    sources: Set<Signal<any>>;
    effects: Computation<any>[];
    promises: Set<Promise<any>>;
    disposed: Set<Computation<any>>;
    running: boolean;
    cb: (() => void)[];
  }
  export function createRoot<T>(fn: (dispose: () => void) => T, detachedOwner?: Owner): T;
  export function createSignal<T>(): [
    get: Accessor<T | undefined>,
    set: <U extends T | undefined>(v?: (U extends Function ? never : U) | ((prev: U) => U)) => U,
  ];
  export function createSignal<T>(
    value: T,
    options?: {
      equals?: false | ((prev: T, next: T) => boolean);
      name?: string;
    },
  ): [get: Accessor<T>, set: (v: (T extends Function ? never : T) | ((prev: T) => T)) => T];
  export function createComputed<T>(fn: (v?: T) => T | undefined): void;
  export function createComputed<T>(
    fn: (v: T) => T,
    value: T,
    options?: {
      name?: string;
    },
  ): void;
  export function createRenderEffect<T>(fn: (v?: T) => T | undefined): void;
  export function createRenderEffect<T>(
    fn: (v: T) => T,
    value: T,
    options?: {
      name?: string;
    },
  ): void;
  export function createEffect<T>(fn: (v?: T) => T | undefined): void;
  export function createEffect<T>(
    fn: (v: T) => T,
    value: T,
    options?: {
      name?: string;
    },
  ): void;
  export function createMemo<T>(
    fn: (v?: T) => T,
    value?: undefined,
    options?: {
      equals?: false | ((prev: T, next: T) => boolean);
      name?: string;
    },
  ): Accessor<T>;
  export function createMemo<T>(
    fn: (v: T) => T,
    value: T,
    options?: {
      equals?: false | ((prev: T, next: T) => boolean);
      name?: string;
    },
  ): Accessor<T>;
  export interface Resource<T> extends Accessor<T | undefined> {
    loading: boolean;
    error: any;
  }
  export type ResourceReturn<T> = [
    Resource<T>,
    {
      mutate: (
        v: (T extends Function ? never : T) | ((prev?: T) => T | undefined),
      ) => T | undefined;
      refetch: () => void;
    },
  ];
  export function createResource<T, U = true>(
    fetcher: (k: U, getPrev: Accessor<T | undefined>) => T | Promise<T>,
    options?: {
      initialValue?: T;
      name?: string;
    },
  ): ResourceReturn<T>;
  export function createResource<T, U>(
    source: U | false | null | (() => U | false | null),
    fetcher: (k: U, getPrev: Accessor<T | undefined>) => T | Promise<T>,
    options?: {
      initialValue?: T;
      name?: string;
    },
  ): ResourceReturn<T>;
  export function createDeferred<T>(
    source: Accessor<T>,
    options?: {
      equals?: false | ((prev: T, next: T) => boolean);
      name?: string;
      timeoutMs?: number;
    },
  ): Accessor<T>;
  export function createSelector<T, U>(
    source: Accessor<T>,
    fn?: (a: U, b: T) => boolean,
    options?: {
      name?: string;
    },
  ): (key: U) => boolean;
  export function batch<T>(fn: () => T): T;
  export function untrack<T>(fn: Accessor<T>): T;
  export type ReturnTypes<T> = T extends (() => any)[]
    ? {
        [I in keyof T]: ReturnTypes<T[I]>;
      }
    : T extends () => any
    ? ReturnType<T>
    : never;
  export function on<T extends (() => any)[], U>(
    deps: [...T],
    fn: (input: ReturnTypes<T>, prevInput: ReturnTypes<T>, prevValue?: U) => U,
    options?: {
      defer?: boolean;
    },
  ): (prevValue?: U) => U | undefined;
  export function on<T extends () => any, U>(
    deps: T,
    fn: (input: ReturnType<T>, prevInput: ReturnType<T>, prevValue?: U) => U,
    options?: {
      defer?: boolean;
    },
  ): (prevValue?: U) => U | undefined;
  export function onMount(fn: () => void): void;
  export function onCleanup(fn: () => void): () => void;
  export function onError(fn: (err: any) => void): void;
  export function getListener(): Computation<any> | null;
  export function getOwner(): Owner | null;
  export function runWithOwner(o: Owner, fn: () => any): any;
  export function useTransition(): [Accessor<boolean>, (fn: () => void, cb?: () => void) => void];
  export function resumeEffects(e: Computation<any>[]): void;
  export function devComponent<T>(Comp: (props: T) => JSX.Element, props: T): JSX.Element;
  export function hashValue(v: any): string;
  export function registerGraph(
    name: string,
    value: {
      value: unknown;
    },
  ): string;
  interface GraphRecord {
    [k: string]: GraphRecord | unknown;
  }
  export function serializeGraph(owner?: Owner | null): GraphRecord;
  export interface Context<T> {
    id: symbol;
    Provider: (props: { value: T; children: any }) => any;
    defaultValue: T;
  }
  export function createContext<T>(): Context<T | undefined>;
  export function createContext<T>(defaultValue: T): Context<T>;
  export function useContext<T>(context: Context<T>): T;
  export function children(fn: Accessor<any>): Accessor<unknown>;
  type SuspenseContextType = {
    increment?: () => void;
    decrement?: () => void;
    inFallback?: () => boolean;
    effects?: Computation<any>[];
    resolved?: boolean;
  };
  export function getSuspenseContext(): Context<SuspenseContextType> & {
    active?(): boolean;
    increment?(): void;
    decrement?(): void;
  };
  export function readSignal(this: Signal<any> | Memo<any>): any;
  export function writeSignal(node: Signal<any> | Memo<any>, value: any, isComp?: boolean): any;
  export {};
}

declare module 'solid-js/reactive/observable' {
  import { Accessor } from 'solid-js/reactive/signal';
  export type ObservableObserver<T> =
    | ((v: T) => void)
    | {
        next: (v: T) => void;
        error?: (v: any) => void;
        complete?: (v: boolean) => void;
      };
  export function observable<T>(
    input: Accessor<T>,
  ): {
    [x: number]: () => any;
    subscribe(
      observer: ObservableObserver<T>,
    ): {
      unsubscribe(): void;
    };
  };
}

declare module 'solid-js/reactive/scheduler' {
  export interface Task {
    id: number;
    fn: ((didTimeout: boolean) => void) | null;
    startTime: number;
    expirationTime: number;
  }
  export function requestCallback(
    fn: () => void,
    options?: {
      timeout: number;
    },
  ): Task;
  export function cancelCallback(task: Task): void;
}

declare module 'solid-js/reactive/array' {
  import { Accessor } from 'solid-js/reactive/signal';
  export function mapArray<T, U>(
    list: Accessor<readonly T[]>,
    mapFn: (v: T, i: Accessor<number>) => U,
    options?: {
      fallback?: Accessor<any>;
    },
  ): () => U[];
  export function indexArray<T, U>(
    list: Accessor<readonly T[]>,
    mapFn: (v: Accessor<T>, i: number) => U,
    options?: {
      fallback?: Accessor<any>;
    },
  ): () => U[];
}

declare module 'solid-js/render' {
  export * from 'solid-js/render/component';
  export * from 'solid-js/render/flow';
  export * from 'solid-js/render/Suspense';
  export { sharedConfig } from 'solid-js/render/hydration';
}

declare module 'solid-js/jsx' {
  /**
   * Based on JSX types for Surplus and Inferno and adapted for `dom-expressions`.
   *
   * https://github.com/adamhaile/surplus/blob/master/index.d.ts
   * https://github.com/infernojs/inferno/blob/master/packages/inferno/src/core/types.ts
   */
  type DOMElement = Element;

  export namespace JSX {
    type Element =
      | Node
      | ArrayElement
      | FunctionElement
      | string
      | number
      | boolean
      | null
      | undefined;
    interface ArrayElement extends Array<Element> {}
    interface FunctionElement {
      (): Element;
    }
    interface ElementClass {
      render(props: any): Element;
    }
    type LibraryManagedAttributes<Component, Props> = Props;
    interface ElementChildrenAttribute {
      children: {};
    }
    interface EventHandler<T, E extends Event> {
      (
        e: E & {
          currentTarget: T;
          target: DOMElement;
        },
      ): void;
    }
    interface BoundEventHandler<T, E extends Event> {
      0: (
        data: any,
        e: E & {
          currentTarget: T;
          target: DOMElement;
        },
      ) => void;
      1: any;
    }
    type EventHandlerUnion<T, E extends Event> = EventHandler<T, E> | BoundEventHandler<T, E>;
    interface IntrinsicAttributes {
      ref?: unknown | ((e: unknown) => void);
    }
    interface CustomAttributes<T> {
      ref?: T | ((el: T) => void);
      classList?: {
        [k: string]: boolean | undefined;
      };
      $ServerOnly?: boolean;
    }
    interface Directives {}
    interface ExplicitProperties {}
    interface ExplicitAttributes {}
    interface CustomEvents {}
    interface CustomCaptureEvents {}
    type DirectiveAttributes = {
      [Key in keyof Directives as `use:${Key}`]?: Directives[Key];
    };
    type PropAttributes = {
      [Key in keyof ExplicitProperties as `prop:${Key}`]?: ExplicitProperties[Key];
    };
    type AttrAttributes = {
      [Key in keyof ExplicitAttributes as `attr:${Key}`]?: ExplicitAttributes[Key];
    };
    type OnAttributes<T> = {
      [Key in keyof CustomEvents as `on:${Key}`]?: EventHandler<T, CustomEvents[Key]>;
    };
    type OnCaptureAttributes<T> = {
      [Key in keyof CustomCaptureEvents as `oncapture:${Key}`]?: EventHandler<
        T,
        CustomCaptureEvents[Key]
      >;
    };
    interface DOMAttributes<T>
      extends CustomAttributes<T>,
        DirectiveAttributes,
        PropAttributes,
        AttrAttributes,
        OnAttributes<T>,
        OnCaptureAttributes<T> {
      children?: Element;
      innerHTML?: string;
      innerText?: string;
      textContent?: string;
      onCopy?: EventHandlerUnion<T, ClipboardEvent>;
      onCut?: EventHandlerUnion<T, ClipboardEvent>;
      onPaste?: EventHandlerUnion<T, ClipboardEvent>;
      onCompositionEnd?: EventHandlerUnion<T, CompositionEvent>;
      onCompositionStart?: EventHandlerUnion<T, CompositionEvent>;
      onCompositionUpdate?: EventHandlerUnion<T, CompositionEvent>;
      onFocus?: EventHandlerUnion<T, FocusEvent>;
      onFocusOut?: EventHandlerUnion<T, FocusEvent>;
      onFocusIn?: EventHandlerUnion<T, FocusEvent>;
      onBlur?: EventHandlerUnion<T, FocusEvent>;
      onChange?: EventHandlerUnion<T, Event>;
      onInput?: EventHandlerUnion<T, InputEvent>;
      onReset?: EventHandlerUnion<T, Event>;
      onSubmit?: EventHandlerUnion<
        T,
        Event & {
          submitter: HTMLElement;
        }
      >;
      onLoad?: EventHandlerUnion<T, Event>;
      onError?: EventHandlerUnion<T, Event>;
      onKeyDown?: EventHandlerUnion<T, KeyboardEvent>;
      onKeyPress?: EventHandlerUnion<T, KeyboardEvent>;
      onKeyUp?: EventHandlerUnion<T, KeyboardEvent>;
      onGotPointerCapture?: EventHandlerUnion<T, PointerEvent>;
      onLostPointerCapture?: EventHandlerUnion<T, PointerEvent>;
      onPointerCancel?: EventHandlerUnion<T, PointerEvent>;
      onPointerDown?: EventHandlerUnion<T, PointerEvent>;
      onPointerEnter?: EventHandlerUnion<T, PointerEvent>;
      onPointerLeave?: EventHandlerUnion<T, PointerEvent>;
      onPointerMove?: EventHandlerUnion<T, PointerEvent>;
      onPointerOver?: EventHandlerUnion<T, PointerEvent>;
      onPointerOut?: EventHandlerUnion<T, PointerEvent>;
      onPointerUp?: EventHandlerUnion<T, PointerEvent>;
      onAbort?: EventHandlerUnion<T, Event>;
      onCanPlay?: EventHandlerUnion<T, Event>;
      onCanPlayThrough?: EventHandlerUnion<T, Event>;
      onDurationChange?: EventHandlerUnion<T, Event>;
      onEmptied?: EventHandlerUnion<T, Event>;
      onEncrypted?: EventHandlerUnion<T, Event>;
      onEnded?: EventHandlerUnion<T, Event>;
      onLoadedData?: EventHandlerUnion<T, Event>;
      onLoadedMetadata?: EventHandlerUnion<T, Event>;
      onLoadStart?: EventHandlerUnion<T, Event>;
      onPause?: EventHandlerUnion<T, Event>;
      onPlay?: EventHandlerUnion<T, Event>;
      onPlaying?: EventHandlerUnion<T, Event>;
      onProgress?: EventHandlerUnion<T, Event>;
      onRateChange?: EventHandlerUnion<T, Event>;
      onSeeked?: EventHandlerUnion<T, Event>;
      onSeeking?: EventHandlerUnion<T, Event>;
      onStalled?: EventHandlerUnion<T, Event>;
      onSuspend?: EventHandlerUnion<T, Event>;
      onTimeUpdate?: EventHandlerUnion<T, Event>;
      onVolumeChange?: EventHandlerUnion<T, Event>;
      onWaiting?: EventHandlerUnion<T, Event>;
      onClick?: EventHandlerUnion<T, MouseEvent>;
      onContextMenu?: EventHandlerUnion<T, MouseEvent>;
      onDblClick?: EventHandlerUnion<T, MouseEvent>;
      onDrag?: EventHandlerUnion<T, DragEvent>;
      onDragEnd?: EventHandlerUnion<T, DragEvent>;
      onDragEnter?: EventHandlerUnion<T, DragEvent>;
      onDragExit?: EventHandlerUnion<T, DragEvent>;
      onDragLeave?: EventHandlerUnion<T, DragEvent>;
      onDragOver?: EventHandlerUnion<T, DragEvent>;
      onDragStart?: EventHandlerUnion<T, DragEvent>;
      onDrop?: EventHandlerUnion<T, DragEvent>;
      onMouseDown?: EventHandlerUnion<T, MouseEvent>;
      onMouseEnter?: EventHandlerUnion<T, MouseEvent>;
      onMouseLeave?: EventHandlerUnion<T, MouseEvent>;
      onMouseMove?: EventHandlerUnion<T, MouseEvent>;
      onMouseOut?: EventHandlerUnion<T, MouseEvent>;
      onMouseOver?: EventHandlerUnion<T, MouseEvent>;
      onMouseUp?: EventHandlerUnion<T, MouseEvent>;
      onSelect?: EventHandlerUnion<T, UIEvent>;
      onTouchCancel?: EventHandlerUnion<T, TouchEvent>;
      onTouchEnd?: EventHandlerUnion<T, TouchEvent>;
      onTouchMove?: EventHandlerUnion<T, TouchEvent>;
      onTouchStart?: EventHandlerUnion<T, TouchEvent>;
      onScroll?: EventHandlerUnion<T, UIEvent>;
      onWheel?: EventHandlerUnion<T, WheelEvent>;
      onAnimationStart?: EventHandlerUnion<T, AnimationEvent>;
      onAnimationEnd?: EventHandlerUnion<T, AnimationEvent>;
      onAnimationIteration?: EventHandlerUnion<T, AnimationEvent>;
      onTransitionEnd?: EventHandlerUnion<T, TransitionEvent>;

      // lower case events
      oncopy?: EventHandlerUnion<T, ClipboardEvent>;
      oncut?: EventHandlerUnion<T, ClipboardEvent>;
      onpaste?: EventHandlerUnion<T, ClipboardEvent>;
      oncompositionend?: EventHandlerUnion<T, CompositionEvent>;
      oncompositionstart?: EventHandlerUnion<T, CompositionEvent>;
      oncompositionupdate?: EventHandlerUnion<T, CompositionEvent>;
      onfocus?: EventHandlerUnion<T, FocusEvent>;
      onfocusout?: EventHandlerUnion<T, FocusEvent>;
      onfocusin?: EventHandlerUnion<T, FocusEvent>;
      onblur?: EventHandlerUnion<T, FocusEvent>;
      onchange?: EventHandlerUnion<T, Event>;
      oninput?: EventHandlerUnion<T, InputEvent>;
      onreset?: EventHandlerUnion<T, Event>;
      onsubmit?: EventHandlerUnion<
        T,
        Event & {
          submitter: HTMLElement;
        }
      >;
      onload?: EventHandlerUnion<T, Event>;
      onerror?: EventHandlerUnion<T, Event>;
      onkeydown?: EventHandlerUnion<T, KeyboardEvent>;
      onkeypress?: EventHandlerUnion<T, KeyboardEvent>;
      onkeyup?: EventHandlerUnion<T, KeyboardEvent>;
      ongotpointercapture?: EventHandlerUnion<T, PointerEvent>;
      onlostpointercapture?: EventHandlerUnion<T, PointerEvent>;
      onpointercancel?: EventHandlerUnion<T, PointerEvent>;
      onpointerdown?: EventHandlerUnion<T, PointerEvent>;
      onpointerenter?: EventHandlerUnion<T, PointerEvent>;
      onpointerleave?: EventHandlerUnion<T, PointerEvent>;
      onpointermove?: EventHandlerUnion<T, PointerEvent>;
      onpointerover?: EventHandlerUnion<T, PointerEvent>;
      onpointerout?: EventHandlerUnion<T, PointerEvent>;
      onpointerup?: EventHandlerUnion<T, PointerEvent>;
      onabort?: EventHandlerUnion<T, Event>;
      oncanplay?: EventHandlerUnion<T, Event>;
      oncanplaythrough?: EventHandlerUnion<T, Event>;
      ondurationchange?: EventHandlerUnion<T, Event>;
      onemptied?: EventHandlerUnion<T, Event>;
      onencrypted?: EventHandlerUnion<T, Event>;
      onended?: EventHandlerUnion<T, Event>;
      onloadeddata?: EventHandlerUnion<T, Event>;
      onloadedmetadata?: EventHandlerUnion<T, Event>;
      onloadstart?: EventHandlerUnion<T, Event>;
      onpause?: EventHandlerUnion<T, Event>;
      onplay?: EventHandlerUnion<T, Event>;
      onplaying?: EventHandlerUnion<T, Event>;
      onprogress?: EventHandlerUnion<T, Event>;
      onratechange?: EventHandlerUnion<T, Event>;
      onseeked?: EventHandlerUnion<T, Event>;
      onseeking?: EventHandlerUnion<T, Event>;
      onstalled?: EventHandlerUnion<T, Event>;
      onsuspend?: EventHandlerUnion<T, Event>;
      ontimeupdate?: EventHandlerUnion<T, Event>;
      onvolumechange?: EventHandlerUnion<T, Event>;
      onwaiting?: EventHandlerUnion<T, Event>;
      onclick?: EventHandlerUnion<T, MouseEvent>;
      oncontextmenu?: EventHandlerUnion<T, MouseEvent>;
      ondblclick?: EventHandlerUnion<T, MouseEvent>;
      ondrag?: EventHandlerUnion<T, DragEvent>;
      ondragend?: EventHandlerUnion<T, DragEvent>;
      ondragenter?: EventHandlerUnion<T, DragEvent>;
      ondragexit?: EventHandlerUnion<T, DragEvent>;
      ondragleave?: EventHandlerUnion<T, DragEvent>;
      ondragover?: EventHandlerUnion<T, DragEvent>;
      ondragstart?: EventHandlerUnion<T, DragEvent>;
      ondrop?: EventHandlerUnion<T, DragEvent>;
      onmousedown?: EventHandlerUnion<T, MouseEvent>;
      onmouseenter?: EventHandlerUnion<T, MouseEvent>;
      onmouseleave?: EventHandlerUnion<T, MouseEvent>;
      onmousemove?: EventHandlerUnion<T, MouseEvent>;
      onmouseout?: EventHandlerUnion<T, MouseEvent>;
      onmouseover?: EventHandlerUnion<T, MouseEvent>;
      onmouseup?: EventHandlerUnion<T, MouseEvent>;
      onselect?: EventHandlerUnion<T, UIEvent>;
      ontouchcancel?: EventHandlerUnion<T, TouchEvent>;
      ontouchend?: EventHandlerUnion<T, TouchEvent>;
      ontouchmove?: EventHandlerUnion<T, TouchEvent>;
      ontouchstart?: EventHandlerUnion<T, TouchEvent>;
      onscroll?: EventHandlerUnion<T, UIEvent>;
      onwheel?: EventHandlerUnion<T, WheelEvent>;
      onanimationstart?: EventHandlerUnion<T, AnimationEvent>;
      onanimationend?: EventHandlerUnion<T, AnimationEvent>;
      onanimationiteration?: EventHandlerUnion<T, AnimationEvent>;
      ontransitionend?: EventHandlerUnion<T, TransitionEvent>;
    }
    type CSSWideKeyword = 'initial' | 'inherit' | 'unset';
    type CSSPercentage = string;
    type CSSLength = number | string;
    interface CSSProperties {
      /**
       * Aligns a flex container's lines within the flex container when there is extra space in the cross-axis, similar to how justify-content aligns individual items within the main-axis.
       */
      'align-content'?:
        | CSSWideKeyword
        | 'flex-start'
        | 'flex-end'
        | 'center'
        | 'space-between'
        | 'space-around'
        | 'stretch';
      /**
       * Sets the default alignment in the cross axis for all of the flex container's items, including anonymous flex items, similarly to how justify-content aligns items along the main axis.
       */
      'align-items'?:
        | CSSWideKeyword
        | 'flex-start'
        | 'flex-end'
        | 'center'
        | 'baseline'
        | 'stretch';
      /**
       * Allows the default alignment to be overridden for individual flex items.
       */
      'align-self'?:
        | CSSWideKeyword
        | 'auto'
        | 'flex-start'
        | 'flex-end'
        | 'center'
        | 'baseline'
        | 'stretch';
      /**
       * This property allows precise alignment of elements, such as graphics,
       * that do not have a baseline-table or lack the desired baseline in their baseline-table.
       * With the alignment-adjust property, the position of the baseline identified by the alignment-baseline
       * can be explicitly determined. It also determines precisely the alignment point for each glyph within a textual element.
       */
      'alignment-adjust'?: CSSWideKeyword | any;
      'alignment-baseline'?: CSSWideKeyword | any;
      /**
       * Defines a length of time to elapse before an animation starts, allowing an animation to begin execution some time after it is applied.
       */
      'animation-delay'?: CSSWideKeyword | any;
      /**
       * Defines whether an animation should run in reverse on some or all cycles.
       */
      'animation-direction'?: CSSWideKeyword | any;
      /**
       * Defines how long an animation runs for.
       */
      'animation-duration'?: CSSWideKeyword | any;
      /**
       * Specifies how many times an animation cycle should play.
       */
      'animation-iteration-count'?: CSSWideKeyword | any;
      /**
       * Defines the list of animations that apply to the element.
       */
      'animation-name'?: CSSWideKeyword | any;
      /**
       * Defines whether an animation is running or paused.
       */
      'animation-play-state'?: CSSWideKeyword | any;
      /**
       * Allows changing the style of any element to platform-based interface elements or vice versa.
       */
      appearance?: CSSWideKeyword | any;
      /**
       * Determines whether or not the “back” side of a transformed element is visible when facing the viewer.
       */
      'backface-visibility'?: CSSWideKeyword | any;
      /**
       * Shorthand property to set the values for one or more of:
       * background-clip, background-color, background-image,
       * background-origin, background-position, background-repeat,
       * background-size, and background-attachment.
       */
      background?: CSSWideKeyword | any;
      /**
       * If a background-image is specified, this property determines
       * whether that image's position is fixed within the viewport,
       * or scrolls along with its containing block.
       * See CSS 3 background-attachment property https://drafts.csswg.org/css-backgrounds-3/#the-background-attachment
       */
      'background-attachment'?: CSSWideKeyword | 'scroll' | 'fixed' | 'local';
      /**
       * This property describes how the element's background images should blend with each other and the element's background color.
       * The value is a list of blend modes that corresponds to each background image. Each element in the list will apply to the
       * corresponding element of background-image. If a property doesn’t have enough comma-separated values to match the number of layers,
       * the UA must calculate its used value by repeating the list of values until there are enough.
       */
      'background-blend-mode'?: CSSWideKeyword | any;
      /**
       * Sets the background color of an element.
       */
      'background-color'?: CSSWideKeyword | any;
      'background-composite'?: CSSWideKeyword | any;
      /**
       * Applies one or more background images to an element. These can be any valid CSS image, including url() paths to image files or CSS gradients.
       */
      'background-image'?: CSSWideKeyword | any;
      /**
       * Specifies what the background-position property is relative to.
       */
      'background-origin'?: CSSWideKeyword | any;
      /**
       * Sets the position of a background image.
       */
      'background-position'?: CSSWideKeyword | any;
      /**
       * Background-repeat defines if and how background images will be repeated after they have been sized and positioned
       */
      'background-repeat'?: CSSWideKeyword | any;
      /**
       * Defines the size of the background images
       */
      'background-size'?: CSSWideKeyword | any;
      /**
       * Obsolete - spec retired, not implemented.
       */
      'baseline-shift'?: CSSWideKeyword | any;
      /**
       * Non standard. Sets or retrieves the location of the Dynamic HTML (DHTML) behavior.
       */
      behavior?: CSSWideKeyword | any;
      /**
       * Shorthand property that defines the different properties of all four sides of an element's border in a single declaration.
       * It can be used to set border-width, border-style and border-color, or a subset of these.
       */
      border?: CSSWideKeyword | any;
      /**
       * Shorthand that sets the values of border-bottom-color,
       * border-bottom-style, and border-bottom-width.
       */
      'border-bottom'?: CSSWideKeyword | any;
      /**
       * Sets the color of the bottom border of an element.
       */
      'border-bottom-color'?: CSSWideKeyword | any;
      /**
       * Defines the shape of the border of the bottom-left corner.
       */
      'border-bottom-left-radius'?: CSSWideKeyword | CSSLength;
      /**
       * Defines the shape of the border of the bottom-right corner.
       */
      'border-bottom-right-radius'?: CSSWideKeyword | CSSLength;
      /**
       * Sets the line style of the bottom border of a box.
       */
      'border-bottom-style'?: CSSWideKeyword | any;
      /**
       * Sets the width of an element's bottom border. To set all four borders,
       * use the border-width shorthand property which sets the values simultaneously for border-top-width,
       * border-right-width, border-bottom-width, and border-left-width.
       */
      'border-bottom-width'?: CSSWideKeyword | any;
      /**
       * Border-collapse can be used for collapsing the borders between table cells
       */
      'border-collapse'?: CSSWideKeyword | any;
      /**
       * The CSS border-color property sets the color of an element's four borders.
       * This property can have from one to four values, made up of the elementary properties:
       *      •       border-top-color
       *      •       border-right-color
       *      •       border-bottom-color
       *      •       border-left-color The default color is the currentColor of each of these values.
       * If you provide one value, it sets the color for the element. Two values set the horizontal and vertical values,
       * respectively. Providing three values sets the top, vertical, and bottom values, in that order.
       * Four values set all for sides: top, right, bottom, and left, in that order.
       */
      'border-color'?: CSSWideKeyword | any;
      /**
       * Specifies different corner clipping effects, such as scoop (inner curves), bevel (straight cuts) or notch (cut-off rectangles).
       * Works along with border-radius to specify the size of each corner effect.
       */
      'border-corner-shape'?: CSSWideKeyword | any;
      /**
       * The property border-image-source is used to set the image to be used instead of the border style.
       * If this is set to none the border-style is used instead.
       */
      'border-image-source'?: CSSWideKeyword | any;
      /**
       * The border-image-width CSS property defines the offset to use for dividing the border image in nine parts,
       * the top-left corner, central top edge, top-right-corner, central right edge, bottom-right corner, central bottom edge,
       * bottom-left corner, and central right edge. They represent inward distance from the top, right, bottom, and left edges.
       */
      'border-image-width'?: CSSWideKeyword | any;
      /**
       * Shorthand property that defines the border-width, border-style and border-color of an element's left border in a single declaration.
       * Note that you can use the corresponding longhand properties to set specific individual properties of the left border — border-left-width,
       * border-left-style and border-left-color.
       */
      'border-left'?: CSSWideKeyword | any;
      /**
       * The CSS border-left-color property sets the color of an element's left border. This page explains the border-left-color value,
       * but often you will find it more convenient to fix the border's left color as part of a shorthand set, either border-left or border-color.
       * Colors can be defined several ways. For more information, see Usage.
       */
      'border-left-color'?: CSSWideKeyword | any;
      /**
       * Sets the style of an element's left border. To set all four borders, use the shorthand property, border-style.
       * Otherwise, you can set the borders individually with border-top-style, border-right-style, border-bottom-style, border-left-style.
       */
      'border-left-style'?: CSSWideKeyword | any;
      /**
       * Sets the width of an element's left border. To set all four borders,
       * use the border-width shorthand property which sets the values simultaneously for border-top-width,
       * border-right-width, border-bottom-width, and border-left-width.
       */
      'border-left-width'?: CSSWideKeyword | any;
      /**
       * Shorthand property that sets the rounding of all four corners.
       */
      'border-radius'?: CSSWideKeyword | CSSLength;
      /**
       * Shorthand property that defines the border-width, border-style and border-color of an element's right border
       * in a single declaration. Note that you can use the corresponding longhand properties to set specific
       * individual properties of the right border — border-right-width, border-right-style and border-right-color.
       */
      'border-right'?: CSSWideKeyword | any;
      /**
       * Sets the color of an element's right border. This page explains the border-right-color value,
       * but often you will find it more convenient to fix the border's right color as part of a shorthand set,
       * either border-right or border-color.
       * Colors can be defined several ways. For more information, see Usage.
       */
      'border-right-color'?: CSSWideKeyword | any;
      /**
       * Sets the style of an element's right border. To set all four borders, use the shorthand property,
       * border-style. Otherwise, you can set the borders individually with border-top-style, border-right-style,
       * border-bottom-style, border-left-style.
       */
      'border-right-style'?: CSSWideKeyword | any;
      /**
       * Sets the width of an element's right border. To set all four borders,
       * use the border-width shorthand property which sets the values simultaneously for border-top-width,
       * border-right-width, border-bottom-width, and border-left-width.
       */
      'border-right-width'?: CSSWideKeyword | any;
      /**
       * Specifies the distance between the borders of adjacent cells.
       */
      'border-spacing'?: CSSWideKeyword | any;
      /**
       * Sets the style of an element's four borders. This property can have from one to four values.
       * With only one value, the value will be applied to all four borders;
       * otherwise, this works as a shorthand property for each of border-top-style, border-right-style,
       * border-bottom-style, border-left-style, where each border style may be assigned a separate value.
       */
      'border-style'?: CSSWideKeyword | any;
      /**
       * Shorthand property that defines the border-width, border-style and border-color of an element's top border
       * in a single declaration. Note that you can use the corresponding longhand properties to set specific
       * individual properties of the top border — border-top-width, border-top-style and border-top-color.
       */
      'border-top'?: CSSWideKeyword | any;
      /**
       * Sets the color of an element's top border. This page explains the border-top-color value,
       * but often you will find it more convenient to fix the border's top color as part of a shorthand set,
       * either border-top or border-color.
       * Colors can be defined several ways. For more information, see Usage.
       */
      'border-top-color'?: CSSWideKeyword | any;
      /**
       * Sets the rounding of the top-left corner of the element.
       */
      'border-top-left-radius'?: CSSWideKeyword | CSSLength;
      /**
       * Sets the rounding of the top-right corner of the element.
       */
      'border-top-right-radius'?: CSSWideKeyword | CSSLength;
      /**
       * Sets the style of an element's top border. To set all four borders, use the shorthand property, border-style.
       * Otherwise, you can set the borders individually with border-top-style, border-right-style, border-bottom-style, border-left-style.
       */
      'border-top-style'?: CSSWideKeyword | any;
      /**
       * Sets the width of an element's top border. To set all four borders,
       * use the border-width shorthand property which sets the values simultaneously for border-top-width,
       * border-right-width, border-bottom-width, and border-left-width.
       */
      'border-top-width'?: CSSWideKeyword | any;
      /**
       * Sets the width of an element's four borders. This property can have from one to four values.
       * This is a shorthand property for setting values simultaneously for border-top-width,
       * border-right-width, border-bottom-width, and border-left-width.
       */
      'border-width'?: CSSWideKeyword | any;
      /**
       * This property specifies how far an absolutely positioned box's bottom margin edge
       * is offset above the bottom edge of the box's containing block. For relatively positioned boxes,
       * the offset is with respect to the bottom edges of the box itself
       * (i.e., the box is given a position in the normal flow, then offset from that position according to these properties).
       */
      bottom?: CSSWideKeyword | any;
      /**
       * Obsolete.
       */
      'box-align'?: CSSWideKeyword | any;
      /**
       * Breaks a box into fragments creating new borders,
       * padding and repeating backgrounds or lets it stay as a continuous box on a page break,
       * column break, or, for inline elements, at a line break.
       */
      'box-decoration-break'?: CSSWideKeyword | any;
      /**
       * Deprecated
       */
      'box-direction'?: CSSWideKeyword | any;
      /**
       * Do not use. This property has been replaced by the flex-wrap property.
       * Gets or sets a value that specifies the direction to add successive rows or columns when the value of box-lines is set to multiple.
       */
      'box-line-progression'?: CSSWideKeyword | any;
      /**
       * Do not use. This property has been replaced by the flex-wrap property.
       * Gets or sets a value that specifies whether child elements wrap onto multiple lines or columns based on the space available in the object.
       */
      'box-lines'?: CSSWideKeyword | any;
      /**
       * Do not use. This property has been replaced by flex-order.
       * Specifies the ordinal group that a child element of the object belongs to.
       * This ordinal value identifies the display order (along the axis defined by the box-orient property) for the group.
       */
      'box-ordinal-group'?: CSSWideKeyword | any;
      /**
       * Deprecated.
       */
      'box-flex'?: CSSWideKeyword | number;
      /**
       * Deprecated.
       */
      'box-flex-group'?: CSSWideKeyword | number;
      /**
       * Cast a drop shadow from the frame of almost any element.
       * MDN: https://developer.mozilla.org/en-US/docs/Web/CSS/box-shadow
       */
      'box-shadow'?: CSSWideKeyword | any;
      /**
       * The CSS break-after property allows you to force a break on multi-column layouts.
       * More specifically, it allows you to force a break after an element.
       * It allows you to determine if a break should occur, and what type of break it should be.
       * The break-after CSS property describes how the page, column or region break behaves after the generated box.
       * If there is no generated box, the property is ignored.
       */
      'break-after'?: CSSWideKeyword | any;
      /**
       * Control page/column/region breaks that fall above a block of content
       */
      'break-before'?: CSSWideKeyword | any;
      /**
       * Control page/column/region breaks that fall within a block of content
       */
      'break-inside'?: CSSWideKeyword | any;
      /**
       * The clear CSS property specifies if an element can be positioned next to
       * or must be positioned below the floating elements that precede it in the markup.
       */
      clear?: CSSWideKeyword | any;
      /**
       * Deprecated; see clip-path.
       * Lets you specify the dimensions of an absolutely positioned element that should be visible,
       * and the element is clipped into this shape, and displayed.
       */
      clip?: CSSWideKeyword | any;
      /**
       * Clipping crops an graphic, so that only a portion of the graphic is rendered, or filled.
       * This clip-rule property, when used with the clip-path property, defines which clip rule, or algorithm,
       * to use when filling the different parts of a graphics.
       */
      'clip-rule'?: CSSWideKeyword | any;
      /**
       * The color property sets the color of an element's foreground content (usually text),
       * accepting any standard CSS color from keywords and hex values to RGB(a) and HSL(a).
       */
      color?: CSSWideKeyword | any;
      /**
       * Describes the number of columns of the element.
       * See CSS 3 column-count property https://www.w3.org/TR/css3-multicol/#cc
       */
      'column-count'?: CSSWideKeyword | number | 'auto';
      /**
       * Specifies how to fill columns (balanced or sequential).
       */
      'column-fill'?: CSSWideKeyword | any;
      /**
       * The column-gap property controls the width of the gap between columns in multi-column elements.
       */
      'column-gap'?: CSSWideKeyword | any;
      /**
       * Sets the width, style, and color of the rule between columns.
       */
      'column-rule'?: CSSWideKeyword | any;
      /**
       * Specifies the color of the rule between columns.
       */
      'column-rule-color'?: CSSWideKeyword | any;
      /**
       * Specifies the width of the rule between columns.
       */
      'column-rule-width'?: CSSWideKeyword | any;
      /**
       * The column-span CSS property makes it possible for an element to span across all columns when its value is set to all.
       * An element that spans more than one column is called a spanning element.
       */
      'column-span'?: CSSWideKeyword | any;
      /**
       * Specifies the width of columns in multi-column elements.
       */
      'column-width'?: CSSWideKeyword | any;
      /**
       * This property is a shorthand property for setting column-width and/or column-count.
       */
      columns?: CSSWideKeyword | any;
      /**
       * The counter-increment property accepts one or more names of counters (identifiers),
       * each one optionally followed by an integer which specifies the value by which the counter should be incremented
       * (e.g. if the value is 2, the counter increases by 2 each time it is invoked).
       */
      'counter-increment'?: CSSWideKeyword | any;
      /**
       * The counter-reset property contains a list of one or more names of counters,
       * each one optionally followed by an integer (otherwise, the integer defaults to 0.).
       * Each time the given element is invoked, the counters specified by the property are set to the given integer.
       */
      'counter-reset'?: CSSWideKeyword | any;
      /**
       * The cue property specifies sound files (known as an "auditory icon") to be played by speech media agents
       * before and after presenting an element's content; if only one file is specified, it is played both before and after.
       * The volume at which the file(s) should be played, relative to the volume of the main element, may also be specified.
       * The icon files may also be set separately with the cue-before and cue-after properties.
       */
      cue?: CSSWideKeyword | any;
      /**
       * The cue-after property specifies a sound file (known as an "auditory icon") to be played by speech media agents
       * after presenting an element's content; the volume at which the file should be played may also be specified.
       * The shorthand property cue sets cue sounds for both before and after the element is presented.
       */
      'cue-after'?: CSSWideKeyword | any;
      /**
       * Specifies the mouse cursor displayed when the mouse pointer is over an element.
       */
      cursor?: CSSWideKeyword | any;
      /**
       * The direction CSS property specifies the text direction/writing direction. The rtl is used for Hebrew or Arabic text, the ltr is for other languages.
       */
      direction?: CSSWideKeyword | any;
      /**
       * This property specifies the type of rendering box used for an element. It is a shorthand property for many other display properties.
       */
      display?: CSSWideKeyword | any;
      /**
       * The ‘fill’ property paints the interior of the given graphical element.
       * The area to be painted consists of any areas inside the outline of the shape.
       * To determine the inside of the shape, all subpaths are considered,
       * and the interior is determined according to the rules associated with the current value of the ‘fill-rule’ property.
       * The zero-width geometric outline of a shape is included in the area to be painted.
       */
      fill?: CSSWideKeyword | any;
      /**
       * SVG: Specifies the opacity of the color or the content the current object is filled with.
       * See SVG 1.1 https://www.w3.org/TR/SVG/painting.html#FillOpacityProperty
       */
      'fill-opacity'?: CSSWideKeyword | number;
      /**
       * The ‘fill-rule’ property indicates the algorithm which is to be used to determine what parts of the canvas are included inside the shape.
       * For a simple, non-intersecting path, it is intuitively clear what region lies "inside";
       * however, for a more complex path, such as a path that intersects itself or where one subpath encloses another,
       * the interpretation of "inside" is not so obvious.
       * The ‘fill-rule’ property provides two options for how the inside of a shape is determined:
       */
      'fill-rule'?: CSSWideKeyword | any;
      /**
       * Applies various image processing effects. This property is largely unsupported. See Compatibility section for more information.
       */
      filter?: CSSWideKeyword | any;
      /**
       * Shorthand for `flex-grow`, `flex-shrink`, and `flex-basis`.
       */
      flex?: CSSWideKeyword | number | string;
      /**
       * Obsolete, do not use. This property has been renamed to align-items.
       * Specifies the alignment (perpendicular to the layout axis defined by the flex-direction property) of child elements of the object.
       */
      'flex-align'?: CSSWideKeyword | any;
      /**
       * The flex-basis CSS property describes the initial main size of the flex item
       * before any free space is distributed according to the flex factors described in the flex property (flex-grow and flex-shrink).
       */
      'flex-basis'?: CSSWideKeyword | any;
      /**
       * The flex-direction CSS property describes how flex items are placed in the flex container, by setting the direction of the flex container's main axis.
       */
      'flex-direction'?: CSSWideKeyword | 'row' | 'row-reverse' | 'column' | 'column-reverse';
      /**
       * The flex-flow CSS property defines the flex container's main and cross axis. It is a shorthand property for the flex-direction and flex-wrap properties.
       */
      'flex-flow'?: CSSWideKeyword | string;
      /**
       * Specifies the flex grow factor of a flex item.
       * See CSS flex-grow property https://drafts.csswg.org/css-flexbox-1/#flex-grow-property
       */
      'flex-grow'?: CSSWideKeyword | number;
      /**
       * Do not use. This property has been renamed to align-self
       * Specifies the alignment (perpendicular to the layout axis defined by flex-direction) of child elements of the object.
       */
      'flex-item-align'?: CSSWideKeyword | any;
      /**
       * Do not use. This property has been renamed to align-content.
       * Specifies how a flexbox's lines align within the flexbox when there is extra space along the axis that is perpendicular to the axis defined by the flex-direction property.
       */
      'flex-line-pack'?: CSSWideKeyword | any;
      /**
       * Gets or sets a value that specifies the ordinal group that a flexbox element belongs to. This ordinal value identifies the display order for the group.
       */
      'flex-order'?: CSSWideKeyword | any;
      /**
       * Specifies the flex shrink factor of a flex item.
       * See CSS flex-shrink property https://drafts.csswg.org/css-flexbox-1/#flex-shrink-property
       */
      'flex-shrink'?: CSSWideKeyword | number;
      /**
       * Specifies whether flex items are forced into a single line or can be wrapped onto multiple lines.
       * If wrapping is allowed, this property also enables you to control the direction in which lines are stacked.
       * See CSS flex-wrap property https://drafts.csswg.org/css-flexbox-1/#flex-wrap-property
       */
      'flex-wrap'?: CSSWideKeyword | 'nowrap' | 'wrap' | 'wrap-reverse';
      /**
       * Elements which have the style float are floated horizontally.
       * These elements can move as far to the left or right of the containing element.
       * All elements after the floating element will flow around it, but elements before the floating element are not impacted.
       * If several floating elements are placed after each other, they will float next to each other as long as there is room.
       */
      float?: CSSWideKeyword | any;
      /**
       * Flows content from a named flow (specified by a corresponding flow-into) through selected elements to form a dynamic chain of layout regions.
       */
      'flow-from'?: CSSWideKeyword | any;
      /**
       * The font property is shorthand that allows you to do one of two things: you can either set up six of the most mature font properties in one line,
       * or you can set one of a choice of keywords to adopt a system font setting.
       */
      font?: CSSWideKeyword | any;
      /**
       * The font-family property allows one or more font family names and/or generic family names to be specified for usage on the selected element(s)' text.
       * The browser then goes through the list; for each character in the selection it applies the first font family that has an available glyph for that character.
       */
      'font-family'?: CSSWideKeyword | any;
      /**
       * The font-kerning property allows contextual adjustment of inter-glyph spacing, i.e. the spaces between the characters in text.
       * This property controls <bold>metric kerning</bold> - that utilizes adjustment data contained in the font. Optical Kerning is not supported as yet.
       */
      'font-kerning'?: CSSWideKeyword | any;
      /**
       * Specifies the size of the font. Used to compute em and ex units.
       * See CSS 3 font-size property https://www.w3.org/TR/css-fonts-3/#propdef-font-size
       */
      'font-size'?:
        | CSSWideKeyword
        | 'xx-small'
        | 'x-small'
        | 'small'
        | 'medium'
        | 'large'
        | 'x-large'
        | 'xx-large'
        | 'larger'
        | 'smaller'
        | CSSLength
        | CSSPercentage;
      /**
       * The font-size-adjust property adjusts the font-size of the fallback fonts defined with font-family,
       * so that the x-height is the same no matter what font is used.
       * This preserves the readability of the text when fallback happens.
       * See CSS 3 font-size-adjust property https://www.w3.org/TR/css-fonts-3/#propdef-font-size-adjust
       */
      'font-size-adjust'?: CSSWideKeyword | 'none' | number;
      /**
       * Allows you to expand or condense the widths for a normal, condensed, or expanded font face.
       * See CSS 3 font-stretch property https://drafts.csswg.org/css-fonts-3/#propdef-font-stretch
       */
      'font-stretch'?:
        | CSSWideKeyword
        | 'normal'
        | 'ultra-condensed'
        | 'extra-condensed'
        | 'condensed'
        | 'semi-condensed'
        | 'semi-expanded'
        | 'expanded'
        | 'extra-expanded'
        | 'ultra-expanded';
      /**
       * The font-style property allows normal, italic, or oblique faces to be selected.
       * Italic forms are generally cursive in nature while oblique faces are typically sloped versions of the regular face.
       * Oblique faces can be simulated by artificially sloping the glyphs of the regular face.
       * See CSS 3 font-style property https://www.w3.org/TR/css-fonts-3/#propdef-font-style
       */
      'font-style'?: CSSWideKeyword | 'normal' | 'italic' | 'oblique';
      /**
       * This value specifies whether the user agent is allowed to synthesize bold or oblique font faces when a font family lacks bold or italic faces.
       */
      'font-synthesis'?: CSSWideKeyword | any;
      /**
       * The font-variant property enables you to select the small-caps font within a font family.
       */
      'font-variant'?: CSSWideKeyword | any;
      /**
       * Fonts can provide alternate glyphs in addition to default glyph for a character. This property provides control over the selection of these alternate glyphs.
       */
      'font-variant-alternates'?: CSSWideKeyword | any;
      /**
       * Specifies the weight or boldness of the font.
       * See CSS 3 'font-weight' property https://www.w3.org/TR/css-fonts-3/#propdef-font-weight
       */
      'font-weight'?:
        | CSSWideKeyword
        | 'normal'
        | 'bold'
        | 'bolder'
        | 'lighter'
        | 100
        | 200
        | 300
        | 400
        | 500
        | 600
        | 700
        | 800
        | 900;
      /**
       * Lays out one or more grid items bound by 4 grid lines. Shorthand for setting grid-column-start, grid-column-end, grid-row-start, and grid-row-end in a single declaration.
       */
      'grid-area'?: CSSWideKeyword | any;
      /**
       * Controls a grid item's placement in a grid area, particularly grid position and a grid span. Shorthand for setting grid-column-start and grid-column-end in a single declaration.
       */
      'grid-column'?: CSSWideKeyword | any;
      /**
       * Controls a grid item's placement in a grid area as well as grid position and a grid span.
       * The grid-column-end property (with grid-row-start, grid-row-end, and grid-column-start) determines a grid item's placement by specifying the grid lines of a grid item's grid area.
       */
      'grid-column-end'?: CSSWideKeyword | any;
      /**
       * Determines a grid item's placement by specifying the starting grid lines of a grid item's grid area.
       * A grid item's placement in a grid area consists of a grid position and a grid span.
       * See also ( grid-row-start, grid-row-end, and grid-column-end)
       */
      'grid-column-start'?: CSSWideKeyword | any;
      /**
       * Gets or sets a value that indicates which row an element within a Grid should appear in. Shorthand for setting grid-row-start and grid-row-end in a single declaration.
       */
      'grid-row'?: CSSWideKeyword | any;
      /**
       * Determines a grid item’s placement by specifying the block-end. A grid item's placement in a grid area consists of a grid position and a grid span.
       * The grid-row-end property (with grid-row-start, grid-column-start, and grid-column-end) determines a grid item's placement by specifying the grid lines of a grid item's grid area.
       */
      'grid-row-end'?: CSSWideKeyword | any;
      /**
       * Specifies a row position based upon an integer location, string value, or desired row size.
       * css/properties/grid-row is used as short-hand for grid-row-position and grid-row-position
       */
      'grid-row-position'?: CSSWideKeyword | any;
      'grid-row-span'?: CSSWideKeyword | any;
      /**
       * Specifies named grid areas which are not associated with any particular grid item, but can be referenced from the grid-placement properties.
       * The syntax of the grid-template-areas property also provides a visualization of the structure of the grid, making the overall layout of the grid container easier to understand.
       */
      'grid-template-areas'?: CSSWideKeyword | any;
      /**
       * Specifies (with grid-template-rows) the line names and track sizing functions of the grid.
       * Each sizing function can be specified as a length, a percentage of the grid container’s size,
       * a measurement of the contents occupying the column or row, or a fraction of the free space in the grid.
       */
      'grid-template-columns'?: CSSWideKeyword | any;
      /**
       * Specifies (with grid-template-columns) the line names and track sizing functions of the grid.
       * Each sizing function can be specified as a length, a percentage of the grid container’s size,
       * a measurement of the contents occupying the column or row, or a fraction of the free space in the grid.
       */
      'grid-template-rows'?: CSSWideKeyword | any;
      /**
       * Sets the height of an element. The content area of the element height does not include the padding, border, and margin of the element.
       */
      height?: CSSWideKeyword | any;
      /**
       * Specifies the minimum number of characters in a hyphenated word
       */
      'hyphenate-limit-chars'?: CSSWideKeyword | any;
      /**
       * Indicates the maximum number of successive hyphenated lines in an element. The ‘no-limit’ value means that there is no limit.
       */
      'hyphenate-limit-lines'?: CSSWideKeyword | any;
      /**
       * Specifies the maximum amount of trailing whitespace (before justification) that may be left in a line before hyphenation is triggered
       * to pull part of a word from the next line back up into the current one.
       */
      'hyphenate-limit-zone'?: CSSWideKeyword | any;
      /**
       * Specifies whether or not words in a sentence can be split by the use of a manual or automatic hyphenation mechanism.
       */
      hyphens?: CSSWideKeyword | any;
      'ime-mode'?: CSSWideKeyword | any;
      /**
       * Defines how the browser distributes space between and around flex items
       * along the main-axis of their container.
       * See CSS justify-content property https://www.w3.org/TR/css-flexbox-1/#justify-content-property
       */
      'justify-content'?:
        | CSSWideKeyword
        | 'flex-start'
        | 'flex-end'
        | 'center'
        | 'space-between'
        | 'space-around'
        | 'space-evenly'
        | 'stretch';
      'layout-grid'?: CSSWideKeyword | any;
      'layout-grid-char'?: CSSWideKeyword | any;
      'layout-grid-line'?: CSSWideKeyword | any;
      'layout-grid-mode'?: CSSWideKeyword | any;
      'layout-grid-type'?: CSSWideKeyword | any;
      /**
       * Sets the left edge of an element
       */
      left?: CSSWideKeyword | any;
      /**
       * The letter-spacing CSS property specifies the spacing behavior between text characters.
       */
      'letter-spacing'?: CSSWideKeyword | any;
      /**
       * Deprecated. Gets or sets line-breaking rules for text in selected languages such as Japanese, Chinese, and Korean.
       */
      'line-break'?: CSSWideKeyword | any;
      'line-clamp'?: CSSWideKeyword | number;
      /**
       * Specifies the height of an inline block level element.
       * See CSS 2.1 line-height property https://www.w3.org/TR/CSS21/visudet.html#propdef-line-height
       */
      'line-height'?: CSSWideKeyword | 'normal' | number | CSSLength | CSSPercentage;
      /**
       * Shorthand property that sets the list-style-type, list-style-position and list-style-image properties in one declaration.
       */
      'list-style'?: CSSWideKeyword | any;
      /**
       * This property sets the image that will be used as the list item marker. When the image is available,
       * it will replace the marker set with the 'list-style-type' marker. That also means that if the image is not available,
       * it will show the style specified by list-style-property
       */
      'list-style-image'?: CSSWideKeyword | any;
      /**
       * Specifies if the list-item markers should appear inside or outside the content flow.
       */
      'list-style-position'?: CSSWideKeyword | any;
      /**
       * Specifies the type of list-item marker in a list.
       */
      'list-style-type'?: CSSWideKeyword | any;
      /**
       * The margin property is shorthand to allow you to set all four margins of an element at once.
       * Its equivalent longhand properties are margin-top, margin-right, margin-bottom and margin-left.
       * Negative values are also allowed.
       */
      margin?: CSSWideKeyword | any;
      /**
       * margin-bottom sets the bottom margin of an element.
       */
      'margin-bottom'?: CSSWideKeyword | any;
      /**
       * margin-left sets the left margin of an element.
       */
      'margin-left'?: CSSWideKeyword | any;
      /**
       * margin-right sets the right margin of an element.
       */
      'margin-right'?: CSSWideKeyword | any;
      /**
       * margin-top sets the top margin of an element.
       */
      'margin-top'?: CSSWideKeyword | any;
      /**
       * The marquee-direction determines the initial direction in which the marquee content moves.
       */
      'marquee-direction'?: CSSWideKeyword | any;
      /**
       * The 'marquee-style' property determines a marquee's scrolling behavior.
       */
      'marquee-style'?: CSSWideKeyword | any;
      /**
       * This property is shorthand for setting mask-image, mask-mode, mask-repeat, mask-position, mask-clip, mask-origin, mask-composite and mask-size.
       * Omitted values are set to their original properties' initial values.
       */
      mask?: CSSWideKeyword | any;
      /**
       * This property is shorthand for setting mask-border-source, mask-border-slice, mask-border-width, mask-border-outset, and mask-border-repeat.
       * Omitted values are set to their original properties' initial values.
       */
      'mask-border'?: CSSWideKeyword | any;
      /**
       * This property specifies how the images for the sides and the middle part of the mask image are scaled and tiled.
       * The first keyword applies to the horizontal sides, the second one applies to the vertical ones.
       * If the second keyword is absent, it is assumed to be the same as the first, similar to the CSS border-image-repeat property.
       */
      'mask-border-repeat'?: CSSWideKeyword | any;
      /**
       * This property specifies inward offsets from the top, right, bottom, and left edges of the mask image,
       * dividing it into nine regions: four corners, four edges, and a middle.
       * The middle image part is discarded and treated as fully transparent black unless the fill keyword is present.
       * The four values set the top, right, bottom and left offsets in that order, similar to the CSS border-image-slice property.
       */
      'mask-border-slice'?: CSSWideKeyword | any;
      /**
       * Specifies an image to be used as a mask. An image that is empty, fails to download, is non-existent, or cannot be displayed is ignored and does not mask the element.
       */
      'mask-border-source'?: CSSWideKeyword | any;
      /**
       * This property sets the width of the mask box image, similar to the CSS border-image-width property.
       */
      'mask-border-width'?: CSSWideKeyword | any;
      /**
       * Determines the mask painting area, which defines the area that is affected by the mask.
       * The painted content of an element may be restricted to this area.
       */
      'mask-clip'?: CSSWideKeyword | any;
      /**
       * For elements rendered as a single box, specifies the mask positioning area.
       * For elements rendered as multiple boxes (e.g., inline boxes on several lines, boxes on several pages)
       * specifies which boxes box-decoration-break operates on to determine the mask positioning area(s).
       */
      'mask-origin'?: CSSWideKeyword | any;
      /**
       * This property must not be used. It is no longer included in any standard or standard track specification,
       * nor is it implemented in any browser. It is only used when the text-align-last property is set to size.
       * It controls allowed adjustments of font-size to fit line content.
       */
      'max-font-size'?: CSSWideKeyword | any;
      /**
       * Sets the maximum height for an element. It prevents the height of the element to exceed the specified value.
       * If min-height is specified and is greater than max-height, max-height is overridden.
       */
      'max-height'?: CSSWideKeyword | any;
      /**
       * Sets the maximum width for an element. It limits the width property to be larger than the value specified in max-width.
       */
      'max-width'?: CSSWideKeyword | any;
      /**
       * Sets the minimum height for an element. It prevents the height of the element to be smaller than the specified value.
       * The value of min-height overrides both max-height and height.
       */
      'min-height'?: CSSWideKeyword | any;
      /**
       * Sets the minimum width of an element. It limits the width property to be not smaller than the value specified in min-width.
       */
      'min-width'?: CSSWideKeyword | any;
      /**
       * Specifies the transparency of an element.
       * See CSS 3 opacity property https://drafts.csswg.org/css-color-3/#opacity
       */
      opacity?: CSSWideKeyword | number;
      /**
       * Specifies the order used to lay out flex items in their flex container.
       * Elements are laid out in the ascending order of the order value.
       * See CSS order property https://drafts.csswg.org/css-flexbox-1/#order-property
       */
      order?: CSSWideKeyword | number;
      /**
       * In paged media, this property defines the minimum number of lines in
       * a block container that must be left at the bottom of the page.
       * See CSS 3 orphans, widows properties https://drafts.csswg.org/css-break-3/#widows-orphans
       */
      orphans?: CSSWideKeyword | number;
      /**
       * The CSS outline property is a shorthand property for setting one or more of the individual outline properties outline-style,
       * outline-width and outline-color in a single rule. In most cases the use of this shortcut is preferable and more convenient.
       * Outlines differ from borders in the following ways:
       *      •       Outlines do not take up space, they are drawn above the content.
       *      •       Outlines may be non-rectangular. They are rectangular in Gecko/Firefox.
       *              Internet Explorer attempts to place the smallest contiguous outline around all elements or shapes that are indicated to have an outline.
       *              Opera draws a non-rectangular shape around a construct.
       */
      outline?: CSSWideKeyword | any;
      /**
       * The outline-color property sets the color of the outline of an element. An outline is a line that is drawn around elements, outside the border edge, to make the element stand out.
       */
      'outline-color'?: CSSWideKeyword | any;
      /**
       * The outline-offset property offsets the outline and draw it beyond the border edge.
       */
      'outline-offset'?: CSSWideKeyword | any;
      /**
       * The overflow property controls how extra content exceeding the bounding box of an element is rendered.
       * It can be used in conjunction with an element that has a fixed width and height, to eliminate text-induced page distortion.
       */
      overflow?: CSSWideKeyword | 'auto' | 'hidden' | 'scroll' | 'visible';
      /**
       * Specifies the preferred scrolling methods for elements that overflow.
       */
      'overflow-style'?: CSSWideKeyword | any;
      /**
       * Controls how extra content exceeding the x-axis of the bounding box of an element is rendered.
       */
      'overflow-x'?: CSSWideKeyword | 'auto' | 'hidden' | 'scroll' | 'visible';
      /**
       * Controls how extra content exceeding the y-axis of the bounding box of an element is rendered.
       */
      'overflow-y'?: CSSWideKeyword | 'auto' | 'hidden' | 'scroll' | 'visible';
      /**
       * The padding optional CSS property sets the required padding space on one to four sides of an element.
       * The padding area is the space between an element and its border. Negative values are not allowed but decimal values are permitted.
       * The element size is treated as fixed, and the content of the element shifts toward the center as padding is increased.
       * The padding property is a shorthand to avoid setting each side separately (padding-top, padding-right, padding-bottom, padding-left).
       */
      padding?: CSSWideKeyword | any;
      /**
       * The padding-bottom CSS property of an element sets the padding space required on the bottom of an element.
       * The padding area is the space between the content of the element and its border.
       * Contrary to margin-bottom values, negative values of padding-bottom are invalid.
       */
      'padding-bottom'?: CSSWideKeyword | any;
      /**
       * The padding-left CSS property of an element sets the padding space required on the left side of an element.
       * The padding area is the space between the content of the element and its border.
       * Contrary to margin-left values, negative values of padding-left are invalid.
       */
      'padding-left'?: CSSWideKeyword | any;
      /**
       * The padding-right CSS property of an element sets the padding space required on the right side of an element.
       * The padding area is the space between the content of the element and its border.
       * Contrary to margin-right values, negative values of padding-right are invalid.
       */
      'padding-right'?: CSSWideKeyword | any;
      /**
       * The padding-top CSS property of an element sets the padding space required on the top of an element.
       * The padding area is the space between the content of the element and its border.
       * Contrary to margin-top values, negative values of padding-top are invalid.
       */
      'padding-top'?: CSSWideKeyword | any;
      /**
       * The page-break-after property is supported in all major browsers. With CSS3, page-break-* properties are only aliases of the break-* properties.
       * The CSS3 Fragmentation spec defines breaks for all CSS box fragmentation.
       */
      'page-break-after'?: CSSWideKeyword | any;
      /**
       * The page-break-before property sets the page-breaking behavior before an element.
       * With CSS3, page-break-* properties are only aliases of the break-* properties.
       * The CSS3 Fragmentation spec defines breaks for all CSS box fragmentation.
       */
      'page-break-before'?: CSSWideKeyword | any;
      /**
       * Sets the page-breaking behavior inside an element. With CSS3, page-break-* properties are only aliases of the break-* properties.
       * The CSS3 Fragmentation spec defines breaks for all CSS box fragmentation.
       */
      'page-break-inside'?: CSSWideKeyword | any;
      /**
       * The pause property determines how long a speech media agent should pause before and after presenting an element.
       * It is a shorthand for the pause-before and pause-after properties.
       */
      pause?: CSSWideKeyword | any;
      /**
       * The pause-after property determines how long a speech media agent should pause after presenting an element.
       * It may be replaced by the shorthand property pause, which sets pause time before and after.
       */
      'pause-after'?: CSSWideKeyword | any;
      /**
       * The pause-before property determines how long a speech media agent should pause before presenting an element.
       * It may be replaced by the shorthand property pause, which sets pause time before and after.
       */
      'pause-before'?: CSSWideKeyword | any;
      /**
       * The perspective property defines how far an element is placed from the view on the z-axis, from the screen to the viewer.
       * Perspective defines how an object is viewed. In graphic arts, perspective is the representation on a flat surface of what the viewer's eye would see in a 3D space.
       * (See Wikipedia for more information about graphical perspective and for related illustrations.)
       * The illusion of perspective on a flat surface, such as a computer screen,
       * is created by projecting points on the flat surface as they would appear if the flat surface were a window
       * through which the viewer was looking at the object. In discussion of virtual environments, this flat surface is called a projection plane.
       */
      perspective?: CSSWideKeyword | any;
      /**
       * The perspective-origin property establishes the origin for the perspective property.
       * It effectively sets the X and Y position at which the viewer appears to be looking at the children of the element.
       * When used with perspective, perspective-origin changes the appearance of an object,
       * as if a viewer were looking at it from a different origin.
       * An object appears differently if a viewer is looking directly at it versus looking at it from below, above, or from the side.
       * Thus, the perspective-origin is like a vanishing point.
       * The default value of perspective-origin is 50% 50%.
       * This displays an object as if the viewer's eye were positioned directly at the center of the screen, both top-to-bottom and left-to-right.
       * A value of 0% 0% changes the object as if the viewer was looking toward the top left angle.
       * A value of 100% 100% changes the appearance as if viewed toward the bottom right angle.
       */
      'perspective-origin'?: CSSWideKeyword | any;
      /**
       * The pointer-events property allows you to control whether an element can be the target for the pointing device (e.g, mouse, pen) events.
       */
      'pointer-events'?: CSSWideKeyword | any;
      /**
       * The position property controls the type of positioning used by an element within its parent elements.
       * The effect of the position property depends on a lot of factors, for example the position property of parent elements.
       */
      position?: CSSWideKeyword | 'static' | 'relative' | 'absolute' | 'fixed' | 'sticky';
      /**
       * Obsolete: unsupported.
       * This property determines whether or not a full-width punctuation mark character should be trimmed if it appears at the beginning of a line,
       * so that its "ink" lines up with the first glyph in the line above and below.
       */
      'punctuation-trim'?: CSSWideKeyword | any;
      /**
       * Sets the type of quotation marks for embedded quotations.
       */
      quotes?: CSSWideKeyword | any;
      /**
       * Controls whether the last region in a chain displays additional 'overset' content according its default overflow property,
       * or if it displays a fragment of content as if it were flowing into a subsequent region.
       */
      'region-fragment'?: CSSWideKeyword | any;
      /**
       * The rest-after property determines how long a speech media agent should pause after presenting an element's main content,
       * before presenting that element's exit cue sound. It may be replaced by the shorthand property rest, which sets rest time before and after.
       */
      'rest-after'?: CSSWideKeyword | any;
      /**
       * The rest-before property determines how long a speech media agent should pause after presenting an intro cue sound for an element,
       * before presenting that element's main content. It may be replaced by the shorthand property rest, which sets rest time before and after.
       */
      'rest-before'?: CSSWideKeyword | any;
      /**
       * Specifies the position an element in relation to the right side of the containing element.
       */
      right?: CSSWideKeyword | any;
      'ruby-align'?: CSSWideKeyword | any;
      'ruby-position'?: CSSWideKeyword | any;
      /**
       * Defines the alpha channel threshold used to extract a shape from an image. Can be thought of as a "minimum opacity" threshold;
       * that is, a value of 0.5 means that the shape will enclose all the pixels that are more than 50% opaque.
       */
      'shape-image-threshold'?: CSSWideKeyword | any;
      /**
       * A future level of CSS Shapes will define a shape-inside property, which will define a shape to wrap content within the element.
       * See Editor's Draft <http://dev.w3.org/csswg/css-shapes/> and CSSWG wiki page on next-level plans <http://wiki.csswg.org/spec/css-shapes>
       */
      'shape-inside'?: CSSWideKeyword | any;
      /**
       * Adds a margin to a shape-outside. In effect, defines a new shape that is the smallest contour around all the points
       * that are the shape-margin distance outward perpendicular to each point on the underlying shape.
       * For points where a perpendicular direction is not defined (e.g., a triangle corner),
       * takes all points on a circle centered at the point and with a radius of the shape-margin distance.
       * This property accepts only non-negative values.
       */
      'shape-margin'?: CSSWideKeyword | any;
      /**
       * Declares a shape around which text should be wrapped, with possible modifications from the shape-margin property.
       * The shape defined by shape-outside and shape-margin changes the geometry of a float element's float area.
       */
      'shape-outside'?: CSSWideKeyword | any;
      /**
       * The speak property determines whether or not a speech synthesizer will read aloud the contents of an element.
       */
      speak?: CSSWideKeyword | any;
      /**
       * The speak-as property determines how the speech synthesizer interprets the content: words as whole words or as a sequence of letters,
       * numbers as a numerical value or a sequence of digits, punctuation as pauses in speech or named punctuation characters.
       */
      'speak-as'?: CSSWideKeyword | any;
      /**
       * SVG: Specifies the opacity of the outline on the current object.
       * See SVG 1.1 https://www.w3.org/TR/SVG/painting.html#StrokeOpacityProperty
       */
      'stroke-opacity'?: CSSWideKeyword | number;
      /**
       * SVG: Specifies the width of the outline on the current object.
       * See SVG 1.1 https://www.w3.org/TR/SVG/painting.html#StrokeWidthProperty
       */
      'stroke-width'?: CSSWideKeyword | CSSPercentage | CSSLength;
      /**
       * The tab-size CSS property is used to customise the width of a tab (U+0009) character.
       */
      'tab-size'?: CSSWideKeyword | any;
      /**
       * The 'table-layout' property controls the algorithm used to lay out the table cells, rows, and columns.
       */
      'table-layout'?: CSSWideKeyword | any;
      /**
       * The text-align CSS property describes how inline content like text is aligned in its parent block element.
       * text-align does not control the alignment of block elements itself, only their inline content.
       */
      'text-align'?: CSSWideKeyword | any;
      /**
       * The text-align-last CSS property describes how the last line of a block element or a line before line break is aligned in its parent block element.
       */
      'text-align-last'?: CSSWideKeyword | any;
      /**
       * The text-decoration CSS property is used to set the text formatting to underline, overline, line-through or blink.
       * underline and overline decorations are positioned under the text, line-through over it.
       */
      'text-decoration'?: CSSWideKeyword | any;
      /**
       * Sets the color of any text decoration, such as underlines, overlines, and strike throughs.
       */
      'text-decoration-color'?: CSSWideKeyword | any;
      /**
       * Sets what kind of line decorations are added to an element, such as underlines, overlines, etc.
       */
      'text-decoration-line'?: CSSWideKeyword | any;
      'text-decoration-line-through'?: CSSWideKeyword | any;
      'text-decoration-none'?: CSSWideKeyword | any;
      'text-decoration-overline'?: CSSWideKeyword | any;
      /**
       * Specifies what parts of an element’s content are skipped over when applying any text decoration.
       */
      'text-decoration-skip'?: CSSWideKeyword | any;
      /**
       * This property specifies the style of the text decoration line drawn on the specified element.
       * The intended meaning for the values are the same as those of the border-style-properties.
       */
      'text-decoration-style'?: CSSWideKeyword | any;
      'text-decoration-underline'?: CSSWideKeyword | any;
      /**
       * The text-emphasis property will apply special emphasis marks to the elements text.
       * Slightly similar to the text-decoration property only that this property can have affect on the line-height.
       * It also is noted that this is shorthand for text-emphasis-style and for text-emphasis-color.
       */
      'text-emphasis'?: CSSWideKeyword | any;
      /**
       * The text-emphasis-color property specifies the foreground color of the emphasis marks.
       */
      'text-emphasis-color'?: CSSWideKeyword | any;
      /**
       * The text-emphasis-style property applies special emphasis marks to an element's text.
       */
      'text-emphasis-style'?: CSSWideKeyword | any;
      /**
       * This property helps determine an inline box's block-progression dimension,
       * derived from the text-height and font-size properties for non-replaced elements,
       * the height or the width for replaced elements, and the stacked block-progression dimension for inline-block elements.
       * The block-progression dimension determines the position of the padding, border and margin for the element.
       */
      'text-height'?: CSSWideKeyword | any;
      /**
       * Specifies the amount of space horizontally that should be left on the first line of the text of an element.
       * This horizontal spacing is at the beginning of the first line and is in respect to the left edge of the containing block box.
       */
      'text-indent'?: CSSWideKeyword | any;
      'text-justify-trim'?: CSSWideKeyword | any;
      'text-kashida-space'?: CSSWideKeyword | any;
      /**
       * The text-line-through property is a shorthand property for text-line-through-style, text-line-through-color and text-line-through-mode.
       * (Considered obsolete; use text-decoration instead.)
       */
      'text-line-through'?: CSSWideKeyword | any;
      /**
       * Specifies the line colors for the line-through text decoration.
       * (Considered obsolete; use text-decoration-color instead.)
       */
      'text-line-through-color'?: CSSWideKeyword | any;
      /**
       * Sets the mode for the line-through text decoration, determining whether the text decoration affects the space characters or not.
       * (Considered obsolete; use text-decoration-skip instead.)
       */
      'text-line-through-mode'?: CSSWideKeyword | any;
      /**
       * Specifies the line style for line-through text decoration.
       * (Considered obsolete; use text-decoration-style instead.)
       */
      'text-line-through-style'?: CSSWideKeyword | any;
      /**
       * Specifies the line width for the line-through text decoration.
       */
      'text-line-through-width'?: CSSWideKeyword | any;
      /**
       * The text-overflow shorthand CSS property determines how overflowed content that is not displayed is signaled to the users.
       * It can be clipped, display an ellipsis ('…', U+2026 HORIZONTAL ELLIPSIS) or a Web author-defined string.
       * It covers the two long-hand properties text-overflow-mode and text-overflow-ellipsis
       */
      'text-overflow'?: CSSWideKeyword | any;
      /**
       * The text-overline property is the shorthand for the text-overline-style, text-overline-width, text-overline-color, and text-overline-mode properties.
       */
      'text-overline'?: CSSWideKeyword | any;
      /**
       * Specifies the line color for the overline text decoration.
       */
      'text-overline-color'?: CSSWideKeyword | any;
      /**
       * Sets the mode for the overline text decoration, determining whether the text decoration affects the space characters or not.
       */
      'text-overline-mode'?: CSSWideKeyword | any;
      /**
       * Specifies the line style for overline text decoration.
       */
      'text-overline-style'?: CSSWideKeyword | any;
      /**
       * Specifies the line width for the overline text decoration.
       */
      'text-overline-width'?: CSSWideKeyword | any;
      /**
       * The text-rendering CSS property provides information to the browser about how to optimize when rendering text.
       * Options are: legibility, speed or geometric precision.
       */
      'text-rendering'?: CSSWideKeyword | any;
      /**
       * Obsolete: unsupported.
       */
      'text-script'?: CSSWideKeyword | any;
      /**
       * The CSS text-shadow property applies one or more drop shadows to the text and <text-decorations> of an element.
       * Each shadow is specified as an offset from the text, along with optional color and blur radius values.
       */
      'text-shadow'?: CSSWideKeyword | any;
      /**
       * This property transforms text for styling purposes. (It has no effect on the underlying content.)
       */
      'text-transform'?: CSSWideKeyword | any;
      /**
       * Unsupported.
       * This property will add a underline position value to the element that has an underline defined.
       */
      'text-underline-position'?: CSSWideKeyword | any;
      /**
       * After review this should be replaced by text-decoration should it not?
       * This property will set the underline style for text with a line value for underline, overline, and line-through.
       */
      'text-underline-style'?: CSSWideKeyword | any;
      /**
       * This property specifies how far an absolutely positioned box's top margin edge is offset below the top edge of the box's containing block.
       * For relatively positioned boxes, the offset is with respect to the top edges of the box itself (i.e., the box is given a position in the normal flow,
       * then offset from that position according to these properties).
       */
      top?: CSSWideKeyword | any;
      /**
       * Determines whether touch input may trigger default behavior supplied by the user agent, such as panning or zooming.
       */
      'touch-action'?: CSSWideKeyword | any;
      /**
       * CSS transforms allow elements styled with CSS to be transformed in two-dimensional or three-dimensional space.
       * Using this property, elements can be translated, rotated, scaled, and skewed. The value list may consist of 2D and/or 3D transform values.
       */
      transform?: CSSWideKeyword | any;
      /**
       * This property defines the origin of the transformation axes relative to the element to which the transformation is applied.
       */
      'transform-origin'?: CSSWideKeyword | any;
      /**
       * This property allows you to define the relative position of the origin of the transformation grid along the z-axis.
       */
      'transform-origin-z'?: CSSWideKeyword | any;
      /**
       * This property specifies how nested elements are rendered in 3D space relative to their parent.
       */
      'transform-style'?: CSSWideKeyword | any;
      /**
       * The transition CSS property is a shorthand property for transition-property, transition-duration, transition-timing-function,
       * and transition-delay. It allows to define the transition between two states of an element.
       */
      transition?: CSSWideKeyword | any;
      /**
       * Defines when the transition will start. A value of ‘0s’ means the transition will execute as soon as the property is changed.
       * Otherwise, the value specifies an offset from the moment the property is changed, and the transition will delay execution by that offset.
       */
      'transition-delay'?: CSSWideKeyword | any;
      /**
       * The 'transition-duration' property specifies the length of time a transition animation takes to complete.
       */
      'transition-duration'?: CSSWideKeyword | any;
      /**
       * The 'transition-property' property specifies the name of the CSS property to which the transition is applied.
       */
      'transition-property'?: CSSWideKeyword | any;
      /**
       * Sets the pace of action within a transition
       */
      'transition-timing-function'?: CSSWideKeyword | any;
      /**
       * The unicode-bidi CSS property specifies the level of embedding with respect to the bidirectional algorithm.
       */
      'unicode-bidi'?: CSSWideKeyword | any;
      /**
       * unicode-range allows you to set a specific range of characters to be downloaded from a font (embedded using @font-face) and made available for use on the current page.
       */
      'unicode-range'?: CSSWideKeyword | any;
      /**
       * This is for all the high level UX stuff.
       */
      'user-focus'?: CSSWideKeyword | any;
      /**
       * For inputing user content
       */
      'user-input'?: CSSWideKeyword | any;
      /**
       * The vertical-align property controls how inline elements or text are vertically aligned compared to the baseline.
       * If this property is used on table-cells it controls the vertical alignment of content of the table cell.
       */
      'vertical-align'?: CSSWideKeyword | any;
      /**
       * The visibility property specifies whether the boxes generated by an element are rendered.
       */
      visibility?: CSSWideKeyword | any;
      /**
       * The voice-balance property sets the apparent position (in stereo sound) of the synthesized voice for spoken media.
       */
      'voice-balance'?: CSSWideKeyword | any;
      /**
       * The voice-duration property allows the author to explicitly set the amount of time it should take a speech synthesizer to read an element's content,
       * for example to allow the speech to be synchronized with other media.
       * With a value of auto (the default) the length of time it takes to read the content is determined by the content itself and the voice-rate property.
       */
      'voice-duration'?: CSSWideKeyword | any;
      /**
       * The voice-family property sets the speaker's voice used by a speech media agent to read an element.
       * The speaker may be specified as a named character (to match a voice option in the speech reading software)
       * or as a generic description of the age and gender of the voice.
       * Similar to the font-family property for visual media,
       * a comma-separated list of fallback options may be given in case the speech reader does not recognize the character name
       * or cannot synthesize the requested combination of generic properties.
       */
      'voice-family'?: CSSWideKeyword | any;
      /**
       * The voice-pitch property sets pitch or tone (high or low) for the synthesized speech when reading an element;
       * the pitch may be specified absolutely or relative to the normal pitch for the voice-family used to read the text.
       */
      'voice-pitch'?: CSSWideKeyword | any;
      /**
       * The voice-range property determines how much variation in pitch or tone will be created by the speech synthesize when reading an element.
       * Emphasized text, grammatical structures and punctuation may all be rendered as changes in pitch,
       * this property determines how strong or obvious those changes are;
       * large ranges are associated with enthusiastic or emotional speech,
       * while small ranges are associated with flat or mechanical speech.
       */
      'voice-range'?: CSSWideKeyword | any;
      /**
       * The voice-rate property sets the speed at which the voice synthesized by a speech media agent will read content.
       */
      'voice-rate'?: CSSWideKeyword | any;
      /**
       * The voice-stress property sets the level of vocal emphasis to be used for synthesized speech reading the element.
       */
      'voice-stress'?: CSSWideKeyword | any;
      /**
       * The voice-volume property sets the volume for spoken content in speech media. It replaces the deprecated volume property.
       */
      'voice-volume'?: CSSWideKeyword | any;
      /**
       * The white-space property controls whether and how white space inside the element is collapsed, and whether lines may wrap at unforced "soft wrap" opportunities.
       */
      'white-space'?: CSSWideKeyword | any;
      /**
       * Obsolete: unsupported.
       */
      'white-space-treatment'?: CSSWideKeyword | any;
      /**
       * In paged media, this property defines the mimimum number of lines
       * that must be left at the top of the second page.
       * See CSS 3 orphans, widows properties https://drafts.csswg.org/css-break-3/#widows-orphans
       */
      widows?: CSSWideKeyword | number;
      /**
       * Specifies the width of the content area of an element. The content area of the element width does not include the padding, border, and margin of the element.
       */
      width?: CSSWideKeyword | any;
      /**
       * The word-break property is often used when there is long generated content that is strung together without and spaces or hyphens to beak apart.
       * A common case of this is when there is a long URL that does not have any hyphens. This case could potentially cause the breaking of the layout as it could extend past the parent element.
       */
      'word-break'?: CSSWideKeyword | any;
      /**
       * The word-spacing CSS property specifies the spacing behavior between "words".
       */
      'word-spacing'?: CSSWideKeyword | any;
      /**
       * An alias of css/properties/overflow-wrap, word-wrap defines whether to break words when the content exceeds the boundaries of its container.
       */
      'word-wrap'?: CSSWideKeyword | any;
      /**
       * Specifies how exclusions affect inline content within block-level elements. Elements lay out their inline content in their content area but wrap around exclusion areas.
       */
      'wrap-flow'?: CSSWideKeyword | any;
      /**
       * Set the value that is used to offset the inner wrap shape from other shapes. Inline content that intersects a shape with this property will be pushed by this shape's margin.
       */
      'wrap-margin'?: CSSWideKeyword | any;
      /**
       * Obsolete and unsupported. Do not use.
       * This CSS property controls the text when it reaches the end of the block in which it is enclosed.
       */
      'wrap-option'?: CSSWideKeyword | any;
      /**
       * writing-mode specifies if lines of text are laid out horizontally or vertically, and the direction which lines of text and blocks progress.
       */
      'writing-mode'?: CSSWideKeyword | any;
      /**
       * The z-index property specifies the z-order of an element and its descendants.
       * When elements overlap, z-order determines which one covers the other.
       * See CSS 2 z-index property https://www.w3.org/TR/CSS2/visuren.html#z-index
       */
      'z-index'?: CSSWideKeyword | 'auto' | number;
      /**
       * Sets the initial zoom factor of a document defined by @viewport.
       * See CSS zoom descriptor https://drafts.csswg.org/css-device-adapt/#zoom-desc
       */
      zoom?: CSSWideKeyword | 'auto' | number | CSSPercentage;
      [propertyName: string]: any;
    }
    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-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';
    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/
    interface AriaAttributes {
      /** Identifies the currently active element when DOM focus is on a composite widget, textbox, group, or application. */
      'aria-activedescendant'?: string;
      /** 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. */
      'aria-atomic'?: 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.
       */
      'aria-autocomplete'?: '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. */
      'aria-busy'?: boolean | 'false' | 'true';
      /**
       * Indicates the current "checked" state of checkboxes, radio buttons, and other widgets.
       * @see aria-pressed @see aria-selected.
       */
      'aria-checked'?: boolean | 'false' | 'mixed' | 'true';
      /**
       * Defines the total number of columns in a table, grid, or treegrid.
       * @see aria-colindex.
       */
      'aria-colcount'?: 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 aria-colcount @see aria-colspan.
       */
      'aria-colindex'?: number | string;
      /**
       * Defines the number of columns spanned by a cell or gridcell within a table, grid, or treegrid.
       * @see aria-colindex @see aria-rowspan.
       */
      'aria-colspan'?: number | string;
      /**
       * Identifies the element (or elements) whose contents or presence are controlled by the current element.
       * @see aria-owns.
       */
      'aria-controls'?: string;
      /** Indicates the element that represents the current item within a container or set of related elements. */
      'aria-current'?: boolean | 'false' | 'true' | 'page' | 'step' | 'location' | 'date' | 'time';
      /**
       * Identifies the element (or elements) that describes the object.
       * @see aria-labelledby
       */
      'aria-describedby'?: string;
      /**
       * Identifies the element that provides a detailed, extended description for the object.
       * @see aria-describedby.
       */
      'aria-details'?: string;
      /**
       * Indicates that the element is perceivable but disabled, so it is not editable or otherwise operable.
       * @see aria-hidden @see aria-readonly.
       */
      'aria-disabled'?: boolean | 'false' | 'true';
      /**
       * Indicates what functions can be performed when a dragged object is released on the drop target.
       * @deprecated in ARIA 1.1
       */
      'aria-dropeffect'?: 'none' | 'copy' | 'execute' | 'link' | 'move' | 'popup';
      /**
       * Identifies the element that provides an error message for the object.
       * @see aria-invalid @see aria-describedby.
       */
      'aria-errormessage'?: string;
      /** Indicates whether the element, or another grouping element it controls, is currently expanded or collapsed. */
      'aria-expanded'?: 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;
      /**
       * Indicates an element's "grabbed" state in a drag-and-drop operation.
       * @deprecated in ARIA 1.1
       */
      'aria-grabbed'?: boolean | 'false' | 'true';
      /** Indicates the availability and type of interactive popup element, such as menu or dialog, that can be triggered by an element. */
      'aria-haspopup'?:
        | boolean
        | 'false'
        | 'true'
        | 'menu'
        | 'listbox'
        | 'tree'
        | 'grid'
        | 'dialog';
      /**
       * Indicates whether the element is exposed to an accessibility API.
       * @see aria-disabled.
       */
      'aria-hidden'?: boolean | 'false' | 'true';
      /**
       * Indicates the entered value does not conform to the format expected by the application.
       * @see aria-errormessage.
       */
      'aria-invalid'?: boolean | 'false' | 'true' | 'grammar' | 'spelling';
      /** Indicates keyboard shortcuts that an author has implemented to activate or give focus to an element. */
      'aria-keyshortcuts'?: string;
      /**
       * Defines a string value that labels the current element.
       * @see aria-labelledby.
       */
      'aria-label'?: string;
      /**
       * Identifies the element (or elements) that labels the current element.
       * @see aria-describedby.
       */
      'aria-labelledby'?: string;
      /** Defines the hierarchical level of an element within a structure. */
      'aria-level'?: 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. */
      'aria-live'?: 'off' | 'assertive' | 'polite';
      /** Indicates whether an element is modal when displayed. */
      'aria-modal'?: boolean | 'false' | 'true';
      /** Indicates whether a text box accepts multiple lines of input or only a single line. */
      'aria-multiline'?: boolean | 'false' | 'true';
      /** Indicates that the user may select more than one item from the current selectable descendants. */
      'aria-multiselectable'?: boolean | 'false' | 'true';
      /** Indicates whether the element's orientation is horizontal, vertical, or unknown/ambiguous. */
      'aria-orientation'?: '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;
      /**
       * 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.
       */
      'aria-placeholder'?: 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 aria-setsize.
       */
      'aria-posinset'?: number | string;
      /**
       * Indicates the current "pressed" state of toggle buttons.
       * @see aria-checked @see aria-selected.
       */
      'aria-pressed'?: boolean | 'false' | 'mixed' | 'true';
      /**
       * Indicates that the element is not editable, but is otherwise operable.
       * @see aria-disabled.
       */
      'aria-readonly'?: boolean | 'false' | 'true';
      /**
       * Indicates what notifications the user agent will trigger when the accessibility tree within a live region is modified.
       * @see aria-atomic.
       */
      'aria-relevant'?:
        | '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. */
      'aria-required'?: boolean | 'false' | 'true';
      /** Defines a human-readable, author-localized description for the role of an element. */
      'aria-roledescription'?: string;
      /**
       * Defines the total number of rows in a table, grid, or treegrid.
       * @see aria-rowindex.
       */
      'aria-rowcount'?: 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 aria-rowcount @see aria-rowspan.
       */
      'aria-rowindex'?: number | string;
      /**
       * Defines the number of rows spanned by a cell or gridcell within a table, grid, or treegrid.
       * @see aria-rowindex @see aria-colspan.
       */
      'aria-rowspan'?: number | string;
      /**
       * Indicates the current "selected" state of various widgets.
       * @see aria-checked @see aria-pressed.
       */
      'aria-selected'?: 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 aria-posinset.
       */
      'aria-setsize'?: number | string;
      /** Indicates if items in a table or grid are sorted in ascending or descending order. */
      'aria-sort'?: 'none' | 'ascending' | 'descending' | 'other';
      /** Defines the maximum allowed value for a range widget. */
      'aria-valuemax'?: number | string;
      /** Defines the minimum allowed value for a range widget. */
      'aria-valuemin'?: number | string;
      /**
       * Defines the current value for a range widget.
       * @see aria-valuetext.
       */
      'aria-valuenow'?: number | string;
      /** Defines the human readable text alternative of aria-valuenow for a range widget. */
      'aria-valuetext'?: string;
    }

    interface HTMLAttributes<T> extends AriaAttributes, DOMAttributes<T> {
      accessKey?: string;
      className?: string;
      class?: string;
      contenteditable?: boolean | 'inherit';
      contextmenu?: string;
      dir?: HTMLDir;
      draggable?: boolean;
      hidden?: boolean;
      id?: string;
      lang?: string;
      spellcheck?: boolean;
      style?: CSSProperties | string;
      tabindex?: number | string;
      title?: string;
      translate?: 'yes' | 'no';
      about?: string;
      datatype?: string;
      inlist?: any;
      prefix?: string;
      property?: string;
      resource?: string;
      typeof?: string;
      vocab?: 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'
        | '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';
      autocapitalize?: HTMLAutocapitalize;
      color?: string;
      itemprop?: string;
      itemscope?: boolean;
      itemtype?: string;
      itemid?: string;
      itemref?: string;
      align?: 'start' | 'end' | 'center' | 'baseline' | 'stretch' | 'left' | 'right';
      part?: string;
      exportparts?: string;
      inputmode?: 'none' | 'text' | 'tel' | 'url' | 'email' | 'numeric' | 'decimal' | 'search';
      contentEditable?: boolean | 'inherit';
      contextMenu?: string;
      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 AnchorHTMLAttributes<T> extends HTMLAttributes<T> {
      download?: any;
      href?: string;
      hreflang?: string;
      media?: string;
      ping?: string;
      referrerpolicy?: HTMLReferrerPolicy;
      rel?: string;
      target?: string;
      type?: string;
      referrerPolicy?: HTMLReferrerPolicy;
    }
    interface AudioHTMLAttributes<T> extends MediaHTMLAttributes<T> {}
    interface AreaHTMLAttributes<T> extends HTMLAttributes<T> {
      alt?: string;
      coords?: string;
      download?: any;
      href?: string;
      hreflang?: string;
      ping?: string;
      referrerpolicy?: HTMLReferrerPolicy;
      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;
      formaction?: string;
      formenctype?: HTMLFormEncType;
      formmethod?: HTMLFormMethod;
      formnovalidate?: boolean;
      formtarget?: string;
      name?: string;
      type?: 'submit' | 'reset' | 'button';
      value?: string;
      formAction?: string;
      formEnctype?: HTMLFormEncType;
      formMethod?: HTMLFormMethod;
      formNoValidate?: boolean;
      formTarget?: string;
    }
    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 | string[] | number;
    }
    interface DetailsHtmlAttributes<T> extends HTMLAttributes<T> {
      open?: boolean;
    }
    interface DialogHtmlAttributes<T> extends HTMLAttributes<T> {
      open?: boolean;
    }
    interface EmbedHTMLAttributes<T> extends HTMLAttributes<T> {
      height?: number | string;
      src?: string;
      type?: string;
      width?: number | string;
    }
    interface FieldsetHTMLAttributes<T> extends HTMLAttributes<T> {
      disabled?: boolean;
      form?: string;
      name?: string;
    }
    interface FormHTMLAttributes<T> extends HTMLAttributes<T> {
      acceptcharset?: string;
      action?: string;
      autocomplete?: string;
      encoding?: HTMLFormEncType;
      enctype?: HTMLFormEncType;
      method?: HTMLFormMethod;
      name?: string;
      novalidate?: boolean;
      target?: string;
      acceptCharset?: string;
      noValidate?: boolean;
    }
    interface IframeHTMLAttributes<T> extends HTMLAttributes<T> {
      allow?: string;
      allowfullscreen?: boolean;
      height?: number | string;
      name?: string;
      referrerpolicy?: HTMLReferrerPolicy;
      sandbox?: HTMLIframeSandbox;
      src?: string;
      srcdoc?: string;
      width?: number | string;
      referrerPolicy?: HTMLReferrerPolicy;
    }
    interface ImgHTMLAttributes<T> extends HTMLAttributes<T> {
      alt?: string;
      crossorigin?: HTMLCrossorigin;
      decoding?: 'sync' | 'async' | 'auto';
      height?: number | string;
      loading?: 'eager' | 'lazy';
      referrerpolicy?: HTMLReferrerPolicy;
      referrerPolicy?: HTMLReferrerPolicy;
      sizes?: string;
      src?: string;
      srcset?: string;
      srcSet?: string;
      usemap?: string;
      useMap?: string;
      width?: number | string;
      crossOrigin?: HTMLCrossorigin;
    }
    interface InputHTMLAttributes<T> extends HTMLAttributes<T> {
      accept?: string;
      alt?: string;
      autocomplete?: string;
      autofocus?: boolean;
      capture?: boolean | string;
      checked?: boolean;
      crossorigin?: HTMLCrossorigin;
      disabled?: boolean;
      form?: string;
      formaction?: string;
      formenctype?: HTMLFormEncType;
      formmethod?: HTMLFormMethod;
      formnovalidate?: boolean;
      formtarget?: string;
      height?: number | string;
      list?: string;
      max?: number | string;
      maxlength?: number | string;
      min?: number | string;
      minlength?: number | string;
      multiple?: boolean;
      name?: string;
      pattern?: string;
      placeholder?: string;
      readonly?: boolean;
      required?: boolean;
      size?: number | string;
      src?: string;
      step?: number | string;
      type?: string;
      value?: string | string[] | number;
      width?: number | string;
      crossOrigin?: HTMLCrossorigin;
      formAction?: string;
      formEnctype?: HTMLFormEncType;
      formMethod?: HTMLFormMethod;
      formNoValidate?: boolean;
      formTarget?: string;
      maxLength?: number | string;
      minLength?: number | string;
      readOnly?: boolean;
    }
    interface InsHTMLAttributes<T> extends HTMLAttributes<T> {
      cite?: string;
      dateTime?: string;
    }
    interface KeygenHTMLAttributes<T> extends HTMLAttributes<T> {
      autofocus?: boolean;
      challenge?: string;
      disabled?: boolean;
      form?: string;
      keytype?: string;
      keyparams?: string;
      name?: string;
    }
    interface LabelHTMLAttributes<T> extends HTMLAttributes<T> {
      htmlFor?: string;
      for?: string;
      form?: string;
    }
    interface LiHTMLAttributes<T> extends HTMLAttributes<T> {
      value?: number | string;
    }
    interface LinkHTMLAttributes<T> extends HTMLAttributes<T> {
      as?: HTMLLinkAs;
      crossorigin?: HTMLCrossorigin;
      disabled?: boolean;
      href?: string;
      hreflang?: string;
      integrity?: string;
      media?: string;
      referrerpolicy?: HTMLReferrerPolicy;
      rel?: string;
      sizes?: string;
      type?: string;
      crossOrigin?: HTMLCrossorigin;
      referrerPolicy?: HTMLReferrerPolicy;
    }
    interface MapHTMLAttributes<T> extends HTMLAttributes<T> {
      name?: string;
    }
    interface MediaHTMLAttributes<T> extends HTMLAttributes<T> {
      autoplay?: boolean;
      controls?: boolean;
      crossorigin?: HTMLCrossorigin;
      loop?: boolean;
      mediagroup?: string;
      muted?: boolean;
      preload?: 'none' | 'metadata' | 'auto' | '';
      src?: string;
      crossOrigin?: HTMLCrossorigin;
      mediaGroup?: string;
    }
    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;
      httpEquiv?: 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 | 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;
      usemap?: 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 | string[] | number;
    }
    interface OutputHTMLAttributes<T> extends HTMLAttributes<T> {
      form?: string;
      htmlFor?: string;
      for?: string;
      name?: string;
    }
    interface ParamHTMLAttributes<T> extends HTMLAttributes<T> {
      name?: string;
      value?: string | string[] | number;
    }
    interface ProgressHTMLAttributes<T> extends HTMLAttributes<T> {
      max?: number | string;
      value?: string | string[] | number;
    }
    interface ScriptHTMLAttributes<T> extends HTMLAttributes<T> {
      async?: boolean;
      charset?: string;
      crossorigin?: HTMLCrossorigin;
      defer?: boolean;
      integrity?: string;
      nomodule?: boolean;
      nonce?: string;
      referrerpolicy?: HTMLReferrerPolicy;
      src?: string;
      type?: string;
      crossOrigin?: HTMLCrossorigin;
      noModule?: boolean;
      referrerPolicy?: HTMLReferrerPolicy;
    }
    interface SelectHTMLAttributes<T> extends HTMLAttributes<T> {
      autocomplete?: string;
      autofocus?: boolean;
      disabled?: boolean;
      form?: string;
      multiple?: boolean;
      name?: string;
      required?: boolean;
      size?: number | string;
      value?: string | string[] | number;
    }
    interface HTMLSlotElementAttributes<T = HTMLSlotElement> extends HTMLAttributes<T> {
      name?: string;
    }
    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> {
      colspan?: number | string;
      headers?: string;
      rowspan?: number | string;
      colSpan?: number | string;
      rowSpan?: number | string;
    }
    interface TextareaHTMLAttributes<T> extends HTMLAttributes<T> {
      autocomplete?: string;
      autofocus?: boolean;
      cols?: number | string;
      dirname?: string;
      disabled?: boolean;
      form?: string;
      maxlength?: number | string;
      minlength?: number | string;
      name?: string;
      placeholder?: string;
      readonly?: boolean;
      required?: boolean;
      rows?: number | string;
      value?: string | string[] | number;
      wrap?: 'hard' | 'soft' | 'off';
      maxLength?: number | string;
      minLength?: number | string;
      readOnly?: boolean;
    }
    interface ThHTMLAttributes<T> extends HTMLAttributes<T> {
      colspan?: number | string;
      headers?: string;
      rowspan?: number | string;
      colSpan?: number | string;
      rowSpan?: number | string;
      scope?: 'col' | 'row' | 'rowgroup' | 'colgroup';
    }
    interface TimeHTMLAttributes<T> extends HTMLAttributes<T> {
      datetime?: string;
      dateTime?: string;
    }
    interface TrackHTMLAttributes<T> extends HTMLAttributes<T> {
      default?: boolean;
      kind?: 'subtitles' | 'captions' | 'descriptions' | 'chapters' | 'metadata';
      label?: string;
      src?: string;
      srclang?: string;
    }
    interface VideoHTMLAttributes<T> extends MediaHTMLAttributes<T> {
      height?: number | string;
      playsinline?: boolean;
      poster?: string;
      width?: number | string;
    }
    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 DOMAttributes<T> {
      id?: string;
      lang?: string;
      tabIndex?: number | string;
      tabindex?: number | string;
    }
    interface StylableSVGAttributes {
      class?: string;
      className?: string;
      style?: CSSProperties | string;
    }
    interface TransformableSVGAttributes {
      transform?: string;
    }
    interface ConditionalProcessingSVGAttributes {
      requiredExtensions?: string;
      requiredFeatures?: string;
      systemLanguage?: string;
    }
    interface ExternalResourceSVGAttributes {
      externalResourcesRequired?: 'true' | 'false';
    }
    interface AnimationTimingSVGAttributes {
      begin?: string;
      dur?: string;
      end?: string;
      min?: string;
      max?: string;
      restart?: 'always' | 'whenNotActive' | 'never';
      repeatCount?: number | 'indefinite';
      repeatDur?: string;
      fill?: 'freeze' | 'remove';
    }
    interface AnimationValueSVGAttributes {
      calcMode?: 'discrete' | 'linear' | 'paced' | 'spline';
      values?: string;
      keyTimes?: string;
      keySplines?: string;
      from?: number | string;
      to?: number | string;
      by?: number | string;
    }
    interface AnimationAdditionSVGAttributes {
      attributeName?: string;
      additive?: 'replace' | 'sum';
      accumulate?: 'none' | 'sum';
    }
    interface AnimationAttributeTargetSVGAttributes {
      attributeName?: string;
      attributeType?: 'CSS' | 'XML' | 'auto';
    }
    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';
      '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;
      y?: number | string;
      width?: number | string;
      height?: number | string;
      result?: string;
    }
    interface SingleInputFilterSVGAttributes {
      in?: string;
    }
    interface DoubleInputFilterSVGAttributes {
      in?: string;
      in2?: string;
    }
    interface FitToViewBoxSVGAttributes {
      viewBox?: string;
      preserveAspectRatio?: SVGPreserveAspectRatio;
    }
    interface GradientElementSVGAttributes<T>
      extends CoreSVGAttributes<T>,
        ExternalResourceSVGAttributes,
        StylableSVGAttributes {
      gradientUnits?: SVGUnits;
      gradientTransform?: string;
      spreadMethod?: 'pad' | 'reflect' | 'repeat';
    }
    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'
        > {}
    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;
      keyPoints?: string;
      rotate?: number | string | 'auto' | 'auto-reverse';
      origin?: 'default';
    }
    interface AnimateTransformSVGAttributes<T>
      extends AnimationElementSVGAttributes<T>,
        AnimationAttributeTargetSVGAttributes,
        AnimationTimingSVGAttributes,
        AnimationValueSVGAttributes,
        AnimationAdditionSVGAttributes {
      type?: 'translate' | 'scale' | 'rotate' | 'skewX' | 'skewY';
    }
    interface CircleSVGAttributes<T>
      extends GraphicsElementSVGAttributes<T>,
        ShapeElementSVGAttributes<T>,
        ConditionalProcessingSVGAttributes,
        StylableSVGAttributes,
        TransformableSVGAttributes {
      cx?: number | string;
      cy?: number | string;
      r?: number | string;
    }
    interface ClipPathSVGAttributes<T>
      extends CoreSVGAttributes<T>,
        ConditionalProcessingSVGAttributes,
        ExternalResourceSVGAttributes,
        StylableSVGAttributes,
        TransformableSVGAttributes,
        Pick<PresentationSVGAttributes, 'clip-path'> {
      clipPathUnits?: SVGUnits;
    }
    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;
      cy?: number | string;
      rx?: number | string;
      ry?: number | string;
    }
    interface FeBlendSVGAttributes<T>
      extends FilterPrimitiveElementSVGAttributes<T>,
        DoubleInputFilterSVGAttributes,
        StylableSVGAttributes {
      mode?: 'normal' | 'multiply' | 'screen' | 'darken' | 'lighten';
    }
    interface FeColorMatrixSVGAttributes<T>
      extends FilterPrimitiveElementSVGAttributes<T>,
        SingleInputFilterSVGAttributes,
        StylableSVGAttributes {
      type?: 'matrix' | 'saturate' | 'hueRotate' | 'luminanceToAlpha';
      values?: string;
    }
    interface FeComponentTransferSVGAttributes<T>
      extends FilterPrimitiveElementSVGAttributes<T>,
        SingleInputFilterSVGAttributes,
        StylableSVGAttributes {}
    interface FeCompositeSVGAttributes<T>
      extends FilterPrimitiveElementSVGAttributes<T>,
        DoubleInputFilterSVGAttributes,
        StylableSVGAttributes {
      operator?: 'over' | 'in' | 'out' | 'atop' | 'xor' | 'arithmetic';
      k1?: number | string;
      k2?: number | string;
      k3?: number | string;
      k4?: number | string;
    }
    interface FeConvolveMatrixSVGAttributes<T>
      extends FilterPrimitiveElementSVGAttributes<T>,
        SingleInputFilterSVGAttributes,
        StylableSVGAttributes {
      order?: number | string;
      kernelMatrix?: string;
      divisor?: number | string;
      bias?: number | string;
      targetX?: number | string;
      targetY?: number | string;
      edgeMode?: 'duplicate' | 'wrap' | 'none';
      kernelUnitLength?: number | string;
      preserveAlpha?: 'true' | 'false';
    }
    interface FeDiffuseLightingSVGAttributes<T>
      extends FilterPrimitiveElementSVGAttributes<T>,
        SingleInputFilterSVGAttributes,
        StylableSVGAttributes,
        Pick<PresentationSVGAttributes, 'color' | 'lighting-color'> {
      surfaceScale?: number | string;
      diffuseConstant?: number | string;
      kernelUnitLength?: number | string;
    }
    interface FeDisplacementMapSVGAttributes<T>
      extends FilterPrimitiveElementSVGAttributes<T>,
        DoubleInputFilterSVGAttributes,
        StylableSVGAttributes {
      scale?: number | string;
      xChannelSelector?: 'R' | 'G' | 'B' | 'A';
      yChannelSelector?: 'R' | 'G' | 'B' | 'A';
    }
    interface FeDistantLightSVGAttributes<T> extends LightSourceElementSVGAttributes<T> {
      azimuth?: number | string;
      elevation?: number | string;
    }
    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';
      tableValues?: string;
      slope?: number | string;
      intercept?: number | string;
      amplitude?: number | string;
      exponent?: number | string;
      offset?: number | string;
    }
    interface FeGaussianBlurSVGAttributes<T>
      extends FilterPrimitiveElementSVGAttributes<T>,
        SingleInputFilterSVGAttributes,
        StylableSVGAttributes {
      stdDeviation?: number | string;
    }
    interface FeImageSVGAttributes<T>
      extends FilterPrimitiveElementSVGAttributes<T>,
        ExternalResourceSVGAttributes,
        StylableSVGAttributes {
      preserveAspectRatio: SVGPreserveAspectRatio;
    }
    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';
      radius?: number | string;
    }
    interface FeOffsetSVGAttributes<T>
      extends FilterPrimitiveElementSVGAttributes<T>,
        SingleInputFilterSVGAttributes,
        StylableSVGAttributes {
      dx?: number | string;
      dy?: number | string;
    }
    interface FePointLightSVGAttributes<T> extends LightSourceElementSVGAttributes<T> {
      x?: number | string;
      y?: number | string;
      z?: number | string;
    }
    interface FeSpecularLightingSVGAttributes<T>
      extends FilterPrimitiveElementSVGAttributes<T>,
        SingleInputFilterSVGAttributes,
        StylableSVGAttributes,
        Pick<PresentationSVGAttributes, 'color' | 'lighting-color'> {
      surfaceScale?: string;
      specularConstant?: string;
      specularExponent?: string;
      kernelUnitLength?: number | string;
    }
    interface FeSpotLightSVGAttributes<T> extends LightSourceElementSVGAttributes<T> {
      x?: number | string;
      y?: number | string;
      z?: number | string;
      pointsAtX?: number | string;
      pointsAtY?: number | string;
      pointsAtZ?: number | string;
      specularExponent?: number | string;
      limitingConeAngle?: number | string;
    }
    interface FeTileSVGAttributes<T>
      extends FilterPrimitiveElementSVGAttributes<T>,
        SingleInputFilterSVGAttributes,
        StylableSVGAttributes {}
    interface FeTurbulanceSVGAttributes<T>
      extends FilterPrimitiveElementSVGAttributes<T>,
        StylableSVGAttributes {
      baseFrequency?: number | string;
      numOctaves?: number | string;
      seed?: number | string;
      stitchTiles?: 'stitch' | 'noStitch';
      type?: 'fractalNoise' | 'turbulence';
    }
    interface FilterSVGAttributes<T>
      extends CoreSVGAttributes<T>,
        ExternalResourceSVGAttributes,
        StylableSVGAttributes {
      filterUnits?: SVGUnits;
      primitiveUnits?: SVGUnits;
      x?: number | string;
      y?: number | string;
      width?: number | string;
      height?: number | string;
      filterRes?: number | string;
    }
    interface ForeignObjectSVGAttributes<T>
      extends NewViewportSVGAttributes<T>,
        ConditionalProcessingSVGAttributes,
        ExternalResourceSVGAttributes,
        StylableSVGAttributes,
        TransformableSVGAttributes,
        Pick<PresentationSVGAttributes, 'display' | 'visibility'> {
      x?: number | string;
      y?: number | string;
      width?: number | string;
      height?: number | string;
    }
    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;
      y?: number | string;
      width?: number | string;
      height?: number | string;
      preserveAspectRatio?: ImagePreserveAspectRatio;
    }
    interface LineSVGAttributes<T>
      extends GraphicsElementSVGAttributes<T>,
        ShapeElementSVGAttributes<T>,
        ConditionalProcessingSVGAttributes,
        ExternalResourceSVGAttributes,
        StylableSVGAttributes,
        TransformableSVGAttributes,
        Pick<PresentationSVGAttributes, 'marker-start' | 'marker-mid' | 'marker-end'> {
      x1?: number | string;
      y1?: number | string;
      x2?: number | string;
      y2?: number | string;
    }
    interface LinearGradientSVGAttributes<T> extends GradientElementSVGAttributes<T> {
      x1?: number | string;
      x2?: number | string;
      y1?: number | string;
      y2?: number | string;
    }
    interface MarkerSVGAttributes<T>
      extends ContainerElementSVGAttributes<T>,
        ExternalResourceSVGAttributes,
        StylableSVGAttributes,
        FitToViewBoxSVGAttributes,
        Pick<PresentationSVGAttributes, 'overflow' | 'clip'> {
      markerUnits?: 'strokeWidth' | 'userSpaceOnUse';
      refX?: number | string;
      refY?: number | string;
      markerWidth?: number | string;
      markerHeight?: number | string;
      orient?: string;
    }
    interface MaskSVGAttributes<T>
      extends Omit<ContainerElementSVGAttributes<T>, 'opacity' | 'filter'>,
        ConditionalProcessingSVGAttributes,
        ExternalResourceSVGAttributes,
        StylableSVGAttributes {
      maskUnits?: SVGUnits;
      maskContentUnits?: SVGUnits;
      x?: number | string;
      y?: number | string;
      width?: number | string;
      height?: number | string;
    }
    interface MetadataSVGAttributes<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;
      pathLength?: number | string;
    }
    interface PatternSVGAttributes<T>
      extends ContainerElementSVGAttributes<T>,
        ConditionalProcessingSVGAttributes,
        ExternalResourceSVGAttributes,
        StylableSVGAttributes,
        FitToViewBoxSVGAttributes,
        Pick<PresentationSVGAttributes, 'overflow' | 'clip'> {
      x?: number | string;
      y?: number | string;
      width?: number | string;
      height?: number | string;
      patternUnits?: SVGUnits;
      patternContentUnits?: SVGUnits;
      patternTransform?: string;
    }
    interface PolygonSVGAttributes<T>
      extends GraphicsElementSVGAttributes<T>,
        ShapeElementSVGAttributes<T>,
        ConditionalProcessingSVGAttributes,
        ExternalResourceSVGAttributes,
        StylableSVGAttributes,
        TransformableSVGAttributes,
        Pick<PresentationSVGAttributes, 'marker-start' | 'marker-mid' | 'marker-end'> {
      points?: string;
    }
    interface PolylineSVGAttributes<T>
      extends GraphicsElementSVGAttributes<T>,
        ShapeElementSVGAttributes<T>,
        ConditionalProcessingSVGAttributes,
        ExternalResourceSVGAttributes,
        StylableSVGAttributes,
        TransformableSVGAttributes,
        Pick<PresentationSVGAttributes, 'marker-start' | 'marker-mid' | 'marker-end'> {
      points?: string;
    }
    interface RadialGradientSVGAttributes<T> extends GradientElementSVGAttributes<T> {
      cx?: number | string;
      cy?: number | string;
      r?: number | string;
      fx?: number | string;
      fy?: number | string;
    }
    interface RectSVGAttributes<T>
      extends GraphicsElementSVGAttributes<T>,
        ShapeElementSVGAttributes<T>,
        ConditionalProcessingSVGAttributes,
        ExternalResourceSVGAttributes,
        StylableSVGAttributes,
        TransformableSVGAttributes {
      x?: number | string;
      y?: number | string;
      width?: number | string;
      height?: number | string;
      rx?: number | string;
      ry?: number | string;
    }
    interface StopSVGAttributes<T>
      extends CoreSVGAttributes<T>,
        StylableSVGAttributes,
        Pick<PresentationSVGAttributes, 'color' | 'stop-color' | 'stop-opacity'> {
      offset?: number | string;
    }
    interface SvgSVGAttributes<T>
      extends ContainerElementSVGAttributes<T>,
        NewViewportSVGAttributes<T>,
        ConditionalProcessingSVGAttributes,
        ExternalResourceSVGAttributes,
        StylableSVGAttributes,
        FitToViewBoxSVGAttributes,
        ZoomAndPanSVGAttributes,
        PresentationSVGAttributes {
      version?: string;
      'base-profile'?: string;
      x?: number | string;
      y?: number | string;
      width?: number | string;
      height?: number | string;
      contentScriptType?: string;
      contentStyleType?: string;
      xmlns?: string;
    }
    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 {}
    interface TextSVGAttributes<T>
      extends TextContentElementSVGAttributes<T>,
        GraphicsElementSVGAttributes<T>,
        ConditionalProcessingSVGAttributes,
        ExternalResourceSVGAttributes,
        StylableSVGAttributes,
        TransformableSVGAttributes,
        Pick<PresentationSVGAttributes, 'writing-mode' | 'text-rendering'> {
      x?: number | string;
      y?: number | string;
      dx?: number | string;
      dy?: number | string;
      rotate?: number | string;
      textLength?: number | string;
      lengthAdjust?: 'spacing' | 'spacingAndGlyphs';
    }
    interface TextPathSVGAttributes<T>
      extends TextContentElementSVGAttributes<T>,
        ConditionalProcessingSVGAttributes,
        ExternalResourceSVGAttributes,
        StylableSVGAttributes,
        Pick<
          PresentationSVGAttributes,
          'alignment-baseline' | 'baseline-shift' | 'display' | 'visibility'
        > {
      startOffset?: number | string;
      method?: 'align' | 'stretch';
      spacing?: 'auto' | 'exact';
    }
    interface TSpanSVGAttributes<T>
      extends TextContentElementSVGAttributes<T>,
        ConditionalProcessingSVGAttributes,
        ExternalResourceSVGAttributes,
        StylableSVGAttributes,
        Pick<
          PresentationSVGAttributes,
          'alignment-baseline' | 'baseline-shift' | 'display' | 'visibility'
        > {
      x?: number | string;
      y?: number | string;
      dx?: number | string;
      dy?: number | string;
      rotate?: number | string;
      textLength?: number | string;
      lengthAdjust?: 'spacing' | 'spacingAndGlyphs';
    }
    interface UseSVGAttributes<T>
      extends GraphicsElementSVGAttributes<T>,
        ConditionalProcessingSVGAttributes,
        ExternalResourceSVGAttributes,
        StylableSVGAttributes,
        TransformableSVGAttributes {
      x?: number | string;
      y?: number | string;
      width?: number | string;
      height?: number | string;
      href?: string;
    }
    interface ViewSVGAttributes<T>
      extends CoreSVGAttributes<T>,
        ExternalResourceSVGAttributes,
        FitToViewBoxSVGAttributes,
        ZoomAndPanSVGAttributes {
      viewTarget?: string;
    }
    interface IntrinsicElements {
      a: AnchorHTMLAttributes<HTMLAnchorElement>;
      abbr: HTMLAttributes<HTMLElement>;
      address: HTMLAttributes<HTMLElement>;
      area: AreaHTMLAttributes<HTMLAreaElement>;
      article: HTMLAttributes<HTMLElement>;
      aside: HTMLAttributes<HTMLElement>;
      audio: AudioHTMLAttributes<HTMLAudioElement>;
      b: HTMLAttributes<HTMLElement>;
      base: BaseHTMLAttributes<HTMLBaseElement>;
      bdi: HTMLAttributes<HTMLElement>;
      bdo: HTMLAttributes<HTMLElement>;
      big: HTMLAttributes<HTMLElement>;
      blockquote: BlockquoteHTMLAttributes<HTMLElement>;
      body: HTMLAttributes<HTMLBodyElement>;
      br: HTMLAttributes<HTMLBRElement>;
      button: ButtonHTMLAttributes<HTMLButtonElement>;
      canvas: CanvasHTMLAttributes<HTMLCanvasElement>;
      caption: HTMLAttributes<HTMLElement>;
      cite: HTMLAttributes<HTMLElement>;
      code: HTMLAttributes<HTMLElement>;
      col: ColHTMLAttributes<HTMLTableColElement>;
      colgroup: ColgroupHTMLAttributes<HTMLTableColElement>;
      data: DataHTMLAttributes<HTMLElement>;
      datalist: HTMLAttributes<HTMLDataListElement>;
      dd: HTMLAttributes<HTMLElement>;
      del: HTMLAttributes<HTMLElement>;
      details: DetailsHtmlAttributes<HTMLElement>;
      dfn: HTMLAttributes<HTMLElement>;
      dialog: DialogHtmlAttributes<HTMLElement>;
      div: HTMLAttributes<HTMLDivElement>;
      dl: HTMLAttributes<HTMLDListElement>;
      dt: HTMLAttributes<HTMLElement>;
      em: HTMLAttributes<HTMLElement>;
      embed: EmbedHTMLAttributes<HTMLEmbedElement>;
      fieldset: FieldsetHTMLAttributes<HTMLFieldSetElement>;
      figcaption: HTMLAttributes<HTMLElement>;
      figure: HTMLAttributes<HTMLElement>;
      footer: HTMLAttributes<HTMLElement>;
      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<HTMLElement>;
      hgroup: HTMLAttributes<HTMLElement>;
      hr: HTMLAttributes<HTMLHRElement>;
      html: HTMLAttributes<HTMLHtmlElement>;
      i: HTMLAttributes<HTMLElement>;
      iframe: IframeHTMLAttributes<HTMLIFrameElement>;
      img: ImgHTMLAttributes<HTMLImageElement>;
      input: InputHTMLAttributes<HTMLInputElement>;
      ins: InsHTMLAttributes<HTMLModElement>;
      kbd: HTMLAttributes<HTMLElement>;
      keygen: KeygenHTMLAttributes<HTMLElement>;
      label: LabelHTMLAttributes<HTMLLabelElement>;
      legend: HTMLAttributes<HTMLLegendElement>;
      li: LiHTMLAttributes<HTMLLIElement>;
      link: LinkHTMLAttributes<HTMLLinkElement>;
      main: HTMLAttributes<HTMLElement>;
      map: MapHTMLAttributes<HTMLMapElement>;
      mark: HTMLAttributes<HTMLElement>;
      menu: MenuHTMLAttributes<HTMLElement>;
      menuitem: HTMLAttributes<HTMLElement>;
      meta: MetaHTMLAttributes<HTMLMetaElement>;
      meter: MeterHTMLAttributes<HTMLElement>;
      nav: HTMLAttributes<HTMLElement>;
      noindex: HTMLAttributes<HTMLElement>;
      noscript: HTMLAttributes<HTMLElement>;
      object: ObjectHTMLAttributes<HTMLObjectElement>;
      ol: OlHTMLAttributes<HTMLOListElement>;
      optgroup: OptgroupHTMLAttributes<HTMLOptGroupElement>;
      option: OptionHTMLAttributes<HTMLOptionElement>;
      output: OutputHTMLAttributes<HTMLElement>;
      p: HTMLAttributes<HTMLParagraphElement>;
      param: ParamHTMLAttributes<HTMLParamElement>;
      picture: HTMLAttributes<HTMLElement>;
      pre: HTMLAttributes<HTMLPreElement>;
      progress: ProgressHTMLAttributes<HTMLProgressElement>;
      q: QuoteHTMLAttributes<HTMLQuoteElement>;
      rp: HTMLAttributes<HTMLElement>;
      rt: HTMLAttributes<HTMLElement>;
      ruby: HTMLAttributes<HTMLElement>;
      s: HTMLAttributes<HTMLElement>;
      samp: HTMLAttributes<HTMLElement>;
      script: ScriptHTMLAttributes<HTMLElement>;
      section: HTMLAttributes<HTMLElement>;
      select: SelectHTMLAttributes<HTMLSelectElement>;
      slot: HTMLSlotElementAttributes;
      small: HTMLAttributes<HTMLElement>;
      source: SourceHTMLAttributes<HTMLSourceElement>;
      span: HTMLAttributes<HTMLSpanElement>;
      strong: HTMLAttributes<HTMLElement>;
      style: StyleHTMLAttributes<HTMLStyleElement>;
      sub: HTMLAttributes<HTMLElement>;
      summary: HTMLAttributes<HTMLElement>;
      sup: HTMLAttributes<HTMLElement>;
      table: HTMLAttributes<HTMLTableElement>;
      tbody: HTMLAttributes<HTMLTableSectionElement>;
      td: TdHTMLAttributes<HTMLTableDataCellElement>;
      textarea: TextareaHTMLAttributes<HTMLTextAreaElement>;
      tfoot: HTMLAttributes<HTMLTableSectionElement>;
      th: ThHTMLAttributes<HTMLTableHeaderCellElement>;
      thead: HTMLAttributes<HTMLTableSectionElement>;
      time: TimeHTMLAttributes<HTMLElement>;
      title: HTMLAttributes<HTMLTitleElement>;
      tr: HTMLAttributes<HTMLTableRowElement>;
      track: TrackHTMLAttributes<HTMLTrackElement>;
      u: HTMLAttributes<HTMLElement>;
      ul: HTMLAttributes<HTMLUListElement>;
      var: HTMLAttributes<HTMLElement>;
      video: VideoHTMLAttributes<HTMLVideoElement>;
      wbr: HTMLAttributes<HTMLElement>;
      svg: SvgSVGAttributes<SVGSVGElement>;
      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>;
      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>;
      path: PathSVGAttributes<SVGPathElement>;
      pattern: PatternSVGAttributes<SVGPatternElement>;
      polygon: PolygonSVGAttributes<SVGPolygonElement>;
      polyline: PolylineSVGAttributes<SVGPolylineElement>;
      radialGradient: RadialGradientSVGAttributes<SVGRadialGradientElement>;
      rect: RectSVGAttributes<SVGRectElement>;
      stop: StopSVGAttributes<SVGStopElement>;
      switch: SwitchSVGAttributes<SVGSwitchElement>;
      symbol: SymbolSVGAttributes<SVGSymbolElement>;
      text: TextSVGAttributes<SVGTextElement>;
      textPath: TextPathSVGAttributes<SVGTextPathElement>;
      tspan: TSpanSVGAttributes<SVGTSpanElement>;
      use: UseSVGAttributes<SVGUseElement>;
      view: ViewSVGAttributes<SVGViewElement>;
    }
  }
}

declare module 'solid-js/render/component' {
  import type { JSX } from 'solid-js/jsx';
  export type PropsWithChildren<P> = P & {
    children?: JSX.Element;
  };
  export type Component<P = {}> = (props: PropsWithChildren<P>) => JSX.Element;
  /**
   * Takes the props of the passed component and returns its type
   *
   * @example
   * ComponentProps<typeof Portal> // { mount?: Node; useShadow?: boolean; children: JSX.Element }
   * ComponentProps<'div'> // JSX.HTMLAttributes<HTMLDivElement>
   */
  export type ComponentProps<
    T extends keyof JSX.IntrinsicElements | Component<any>
  > = T extends Component<infer P>
    ? P
    : T extends keyof JSX.IntrinsicElements
    ? JSX.IntrinsicElements[T]
    : {};
  export function createComponent<T>(Comp: (props: T) => JSX.Element, props: T): JSX.Element;
  export function mergeProps<T>(source: T): T;
  export function mergeProps<T, U>(source: T, source1: U): T & U;
  export function mergeProps<T, U, V>(source: T, source1: U, source2: V): T & U & V;
  export function mergeProps<T, U, V, W>(
    source: T,
    source1: U,
    source2: V,
    source3: W,
  ): T & U & V & W;
  export function splitProps<T extends object, K1 extends keyof T>(
    props: T,
    ...keys: [K1[]]
  ): [Pick<T, K1>, Omit<T, K1>];
  export function splitProps<T extends object, K1 extends keyof T, K2 extends keyof T>(
    props: T,
    ...keys: [K1[], K2[]]
  ): [Pick<T, K1>, Pick<T, K2>, Omit<T, K1 | K2>];
  export function splitProps<
    T extends object,
    K1 extends keyof T,
    K2 extends keyof T,
    K3 extends keyof T
  >(
    props: T,
    ...keys: [K1[], K2[], K3[]]
  ): [Pick<T, K1>, Pick<T, K2>, Pick<T, K3>, Omit<T, K1 | K2 | K3>];
  export function splitProps<
    T extends object,
    K1 extends keyof T,
    K2 extends keyof T,
    K3 extends keyof T,
    K4 extends keyof T
  >(
    props: T,
    ...keys: [K1[], K2[], K3[], K4[]]
  ): [Pick<T, K1>, Pick<T, K2>, Pick<T, K3>, Pick<T, K4>, Omit<T, K1 | K2 | K3 | K4>];
  export function splitProps<
    T extends object,
    K1 extends keyof T,
    K2 extends keyof T,
    K3 extends keyof T,
    K4 extends keyof T,
    K5 extends keyof T
  >(
    props: T,
    ...keys: [K1[], K2[], K3[], K4[], K5[]]
  ): [
    Pick<T, K1>,
    Pick<T, K2>,
    Pick<T, K3>,
    Pick<T, K4>,
    Pick<T, K5>,
    Omit<T, K1 | K2 | K3 | K4 | K5>,
  ];
  export function lazy<T extends Component<any>>(
    fn: () => Promise<{
      default: T;
    }>,
  ): T & {
    preload: () => Promise<T>;
  };
}

declare module 'solid-js/render/flow' {
  import { Accessor } from 'solid-js/reactive/signal';
  import type { JSX } from 'solid-js/jsx';
  export function For<T, U extends JSX.Element>(props: {
    each: readonly T[];
    fallback?: JSX.Element;
    children: (item: T, index: Accessor<number>) => U;
  }): Accessor<U[]>;
  export function Index<T, U extends JSX.Element>(props: {
    each: readonly T[];
    fallback?: JSX.Element;
    children: (item: Accessor<T>, index: number) => U;
  }): Accessor<U[]>;
  export function Show<T>(props: {
    when: T | undefined | null | false;
    fallback?: JSX.Element;
    children: JSX.Element | ((item: T) => JSX.Element);
  }): () => JSX.Element;
  export function Switch(props: {
    fallback?: JSX.Element;
    children: JSX.Element;
  }): Accessor<JSX.Element>;
  export type MatchProps<T> = {
    when: T | undefined | null | false;
    children: JSX.Element | ((item: T) => JSX.Element);
  };
  export function Match<T>(props: MatchProps<T>): JSX.Element;
  export function ErrorBoundary(props: {
    fallback: JSX.Element | ((err: any, reset: () => void) => JSX.Element);
    children: JSX.Element;
  }): Accessor<JSX.Element>;
}

declare module 'solid-js/render/Suspense' {
  import type { JSX } from 'solid-js/jsx';
  export function SuspenseList(props: {
    children: JSX.Element;
    revealOrder: 'forwards' | 'backwards' | 'together';
    tail?: 'collapsed' | 'hidden';
  }): JSX.Element;
  export function Suspense(props: { fallback?: JSX.Element; children: JSX.Element }): JSX.Element;
}

declare module 'solid-js/render/hydration' {
  type HydrationContext = {
    id: string;
    count: number;
    loadResource?: (id: string) => Promise<any>;
  };
  type SharedConfig = {
    context?: HydrationContext;
    resources?: {
      [key: string]: any;
    };
    registry?: Map<string, Element>;
  };
  export const sharedConfig: SharedConfig;
  export function setHydrateContext(context?: HydrationContext): void;
  export function nextHydrateContext(): HydrationContext | undefined;
  export {};
}

// Generated by dts-bundle v0.7.3

declare module 'solid-js/web' {
  import { Component, JSX, Accessor } from 'solid-js';
  export * from 'solid-js/web/client';
  export {
    For,
    Show,
    Suspense,
    SuspenseList,
    Switch,
    Match,
    Index,
    ErrorBoundary,
    mergeProps,
  } from 'solid-js';
  export * from 'solid-js/web/server-mock';
  export const isServer = false;
  export function Portal(props: {
    mount?: Node;
    useShadow?: boolean;
    isSVG?: boolean;
    children: JSX.Element;
  }): Text;
  type DynamicProps<T> = T & {
    children?: any;
    component?: Component<T> | string | keyof JSX.IntrinsicElements;
  };
  export function Dynamic<T>(props: DynamicProps<T>): Accessor<JSX.Element>;
}

declare module 'solid-js/web/client' {
  import { JSX } from 'solid-js/web/jsx';
  export const Aliases: Record<string, string>;
  export const Properties: Set<string>;
  export const ChildProperties: Set<string>;
  export const DelegatedEvents: Set<string>;
  export const SVGElements: Set<string>;
  export const SVGNamespace: Record<string, string>;

  type MountableElement = Element | Document | ShadowRoot | DocumentFragment | Node;
  export function render(code: () => JSX.Element, element: MountableElement): () => void;
  export function template(html: string, count: number, isSVG?: boolean): Element;
  export function effect<T>(fn: (prev?: T) => T, init?: T): void;
  export function memo<T>(fn: () => T, equal: boolean): () => T;
  export function insert<T>(
    parent: MountableElement,
    accessor: (() => T) | T,
    marker?: Node | null,
    init?: JSX.Element,
  ): JSX.Element;
  export function createComponent<T>(Comp: (props: T) => JSX.Element, props: T): JSX.Element;
  export function delegateEvents(eventNames: string[], d?: Document): void;
  export function clearDelegatedEvents(d?: Document): void;
  export function spread<T>(
    node: Element,
    accessor: (() => T) | T,
    isSVG?: Boolean,
    skipChildren?: Boolean,
  ): void;
  export function assign(node: Element, props: any, isSVG?: Boolean, skipChildren?: Boolean): void;
  export function setAttribute(node: Element, name: string, value: string): void;
  export function setAttributeNS(
    node: Element,
    namespace: string,
    name: string,
    value: string,
  ): void;
  export function addEventListener(
    node: Element,
    name: string,
    handler: () => void,
    delegate: boolean,
  ): void;
  export function classList(
    node: Element,
    value: { [k: string]: boolean },
    prev?: { [k: string]: boolean },
  ): void;
  export function style(
    node: Element,
    value: { [k: string]: string },
    prev?: { [k: string]: string },
  ): void;
  export function getOwner(): unknown;
  export function mergeProps(target: unknown, ...sources: unknown[]): unknown;
  export function dynamicProperty(props: unknown, key: string): unknown;

  export function hydrate(fn: () => JSX.Element, node: MountableElement): () => void;
  export function gatherHydratable(node: Element): void;
  export function getHydrationKey(): string;
  export function getNextElement(template: HTMLTemplateElement): Node;
  export function getNextMatch(start: Node, nodeName: string): Node;
  export function getNextMarker(start: Node): [Node, Array<Node>];
  export function HydrationScript(): JSX.Element;
  export function NoHydration(props: { children?: JSX.Element }): JSX.Element;
}

declare module 'solid-js/web/server-mock' {
  export type PipeToWritableResults = {
    startWriting: () => void;
    write: (v: string) => void;
    abort: () => void;
  };
  export function renderToString<T>(
    fn: () => T,
    options?: {
      eventNames?: string[];
      nonce?: string;
    },
  ): string;
  export function renderToStringAsync<T>(
    fn: () => T,
    options?: {
      eventNames?: string[];
      timeoutMs?: number;
      nonce?: string;
    },
  ): Promise<string>;
  export function pipeToNodeWritable<T>(
    fn: () => T,
    writable: {
      write: (v: string) => void;
    },
    options?: {
      eventNames?: string[];
      nonce?: string;
      onReady?: (r: PipeToWritableResults) => void;
      onComplete?: (r: PipeToWritableResults) => void | Promise<void>;
    },
  ): void;
  export function pipeToWritable<T>(
    fn: () => T,
    writable: WritableStream,
    options?: {
      eventNames?: string[];
      nonce?: string;
      onReady?: (r: PipeToWritableResults) => void;
      onComplete?: (r: PipeToWritableResults) => void | Promise<void>;
    },
  ): void;
  export function ssr(
    template: string[] | string,
    ...nodes: any[]
  ): {
    t: string;
  };
  export function resolveSSRNode(node: any): string;
  export function ssrClassList(value: { [k: string]: boolean }): string;
  export function ssrStyle(value: { [k: string]: string }): string;
  export function ssrSpread(accessor: any): () => string;
  export function ssrBoolean(key: string, value: boolean): string;
  export function ssrHydrationKey(): string;
  export function escape(html: string): string;
  export function generateHydrationScript(): string;
}

declare module 'solid-js/web/jsx' {
  export { JSX } from 'solid-js';
}

// Generated by dts-bundle v0.7.3

declare module 'solid-js/h' {
  const _default: import('hyper-dom-expressions').HyperScript;
  export default _default;
}

// Generated by dts-bundle v0.7.3

declare module 'solid-js/html' {
  const _default: import('lit-dom-expressions').HTMLTag;
  export default _default;
}

// Generated by dts-bundle v0.7.3

declare module 'solid-js/store' {
  export { createStore, unwrap, $RAW } from 'solid-js/store/store';
  export type {
    Store,
    SetStoreFunction,
    NotWrappable,
    StoreNode,
    StoreSetter,
    StorePathRange,
    ArrayFilterFn,
    Part,
    Next,
    Readonly,
    DeepReadonly,
  } from 'solid-js/store/store';
  export * from 'solid-js/store/mutable';
  export * from 'solid-js/store/modifiers';
}

declare module 'solid-js/store/store' {
  import { $PROXY, Accessor } from 'solid-js';
  export const $RAW: unique symbol, $NODE: unique symbol, $NAME: unique symbol;
  export type StoreNode = {
    [$NODE]?: any;
    [$PROXY]?: any;
    [$NAME]?: string;
    [k: string]: any;
    [k: number]: any;
  };
  type AddSymbolToPrimitive<T> = T extends {
    [Symbol.toPrimitive]: infer V;
  }
    ? {
        [Symbol.toPrimitive]: V;
      }
    : {};
  type AddSymbolIterator<T> = T extends {
    [Symbol.iterator]: infer V;
  }
    ? {
        [Symbol.iterator]: V;
      }
    : {};
  type AddSymbolToStringTag<T> = T extends {
    [Symbol.toStringTag]: infer V;
  }
    ? {
        [Symbol.toStringTag]: V;
      }
    : {};
  type AddCallable<T> = T extends {
    (...x: any[]): infer V;
  }
    ? {
        (...x: Parameters<T>): V;
      }
    : {};
  export type NotWrappable = string | number | boolean | Function | null;
  export type Store<T> = {
    [P in keyof T]: T[P] extends object ? Store<T[P]> & T[P] : T[P];
  } & {
    [$RAW]?: T;
  } & AddSymbolToPrimitive<T> &
    AddSymbolIterator<T> &
    AddSymbolToStringTag<T> &
    AddCallable<T>;
  export function isWrappable(obj: any): boolean;
  export function unwrap<T extends StoreNode>(item: any, set?: Set<unknown>): T;
  export function getDataNodes(target: StoreNode): any;
  export function proxyDescriptor(
    target: StoreNode,
    property: string | number | symbol,
  ): PropertyDescriptor | undefined;
  export function createDataNode(): Accessor<void> & {
    $: () => void;
  };
  export function setProperty(state: StoreNode, property: string | number, value: any): void;
  export function updatePath(
    current: StoreNode,
    path: any[],
    traversed?: (number | string)[],
  ): void;
  export type Readonly<T> = {
    readonly [K in keyof T]: DeepReadonly<T[K]>;
  };
  export type DeepReadonly<T> = T extends [infer A]
    ? Readonly<[A]>
    : T extends [infer A, infer B]
    ? Readonly<[A, B]>
    : T extends [infer A, infer B, infer C]
    ? Readonly<[A, B, C]>
    : T extends [infer A, infer B, infer C, infer D]
    ? Readonly<[A, B, C, D]>
    : T extends [infer A, infer B, infer C, infer D, infer E]
    ? Readonly<[A, B, C, D, E]>
    : T extends [infer A, infer B, infer C, infer D, infer E, infer F]
    ? Readonly<[A, B, C, D, E, F]>
    : T extends [infer A, infer B, infer C, infer D, infer E, infer F, infer G]
    ? Readonly<[A, B, C, D, E, F, G]>
    : T extends [infer A, infer B, infer C, infer D, infer E, infer F, infer G, infer H]
    ? Readonly<[A, B, C, D, E, F, G, H]>
    : T extends object
    ? Readonly<T>
    : T;
  export type StoreSetter<T> =
    | Partial<T>
    | ((
        prevState: T extends NotWrappable ? T : Store<DeepReadonly<T>>,
        traversed?: (string | number)[],
      ) => Partial<T | DeepReadonly<T>> | void);
  export type StorePathRange = {
    from?: number;
    to?: number;
    by?: number;
  };
  export type ArrayFilterFn<T> = (
    item: T extends any[] ? T[number] : never,
    index: number,
  ) => boolean;
  export type Part<T> = keyof T | Array<keyof T> | StorePathRange | ArrayFilterFn<T>;
  export type Next<T, K> = K extends keyof T
    ? T[K]
    : K extends Array<keyof T>
    ? T[K[number]]
    : T extends any[]
    ? K extends StorePathRange
      ? T[number]
      : K extends ArrayFilterFn<T>
      ? T[number]
      : never
    : never;
  export interface SetStoreFunction<T> {
    <Setter extends StoreSetter<T>>(...args: [Setter]): void;
    <K1 extends Part<T>, Setter extends StoreSetter<Next<T, K1>>>(...args: [K1, Setter]): void;
    <
      K1 extends Part<T>,
      K2 extends Part<Next<T, K1>>,
      Setter extends StoreSetter<Next<Next<T, K1>, K2>>
    >(
      ...args: [K1, K2, Setter]
    ): void;
    <
      K1 extends Part<T>,
      K2 extends Part<Next<T, K1>>,
      K3 extends Part<Next<Next<T, K1>, K2>>,
      Setter extends StoreSetter<Next<Next<Next<T, K1>, K2>, K3>>
    >(
      ...args: [K1, K2, K3, Setter]
    ): void;
    <
      K1 extends Part<T>,
      K2 extends Part<Next<T, K1>>,
      K3 extends Part<Next<Next<T, K1>, K2>>,
      K4 extends Part<Next<Next<Next<T, K1>, K2>, K3>>,
      Setter extends StoreSetter<Next<Next<Next<Next<T, K1>, K2>, K3>, K4>>
    >(
      ...args: [K1, K2, K3, K4, Setter]
    ): void;
    <
      K1 extends Part<T>,
      K2 extends Part<Next<T, K1>>,
      K3 extends Part<Next<Next<T, K1>, K2>>,
      K4 extends Part<Next<Next<Next<T, K1>, K2>, K3>>,
      K5 extends Part<Next<Next<Next<Next<T, K1>, K2>, K3>, K4>>,
      Setter extends StoreSetter<Next<Next<Next<Next<Next<T, K1>, K2>, K3>, K4>, K5>>
    >(
      ...args: [K1, K2, K3, K4, K5, Setter]
    ): void;
    <
      K1 extends Part<T>,
      K2 extends Part<Next<T, K1>>,
      K3 extends Part<Next<Next<T, K1>, K2>>,
      K4 extends Part<Next<Next<Next<T, K1>, K2>, K3>>,
      K5 extends Part<Next<Next<Next<Next<T, K1>, K2>, K3>, K4>>,
      K6 extends Part<Next<Next<Next<Next<Next<T, K1>, K2>, K3>, K4>, K5>>,
      Setter extends StoreSetter<Next<Next<Next<Next<Next<Next<T, K1>, K2>, K3>, K4>, K5>, K6>>
    >(
      ...args: [K1, K2, K3, K4, K5, K6, Setter]
    ): void;
    <
      K1 extends Part<T>,
      K2 extends Part<Next<T, K1>>,
      K3 extends Part<Next<Next<T, K1>, K2>>,
      K4 extends Part<Next<Next<Next<T, K1>, K2>, K3>>,
      K5 extends Part<Next<Next<Next<Next<T, K1>, K2>, K3>, K4>>,
      K6 extends Part<Next<Next<Next<Next<Next<T, K1>, K2>, K3>, K4>, K5>>,
      K7 extends Part<Next<Next<Next<Next<Next<Next<T, K1>, K2>, K3>, K4>, K5>, K6>>,
      Setter extends StoreSetter<
        Next<Next<Next<Next<Next<Next<Next<T, K1>, K2>, K3>, K4>, K5>, K6>, K7>
      >
    >(
      ...args: [K1, K2, K3, K4, K5, K6, K7, Setter]
    ): void;
    <
      K1 extends Part<T>,
      K2 extends Part<Next<T, K1>>,
      K3 extends Part<Next<Next<T, K1>, K2>>,
      K4 extends Part<Next<Next<Next<T, K1>, K2>, K3>>,
      K5 extends Part<Next<Next<Next<Next<T, K1>, K2>, K3>, K4>>,
      K6 extends Part<Next<Next<Next<Next<Next<T, K1>, K2>, K3>, K4>, K5>>,
      K7 extends Part<Next<Next<Next<Next<Next<Next<T, K1>, K2>, K3>, K4>, K5>, K6>>,
      K8 extends Part<Next<Next<Next<Next<Next<Next<Next<T, K1>, K2>, K3>, K4>, K5>, K6>, K7>>
    >(
      ...args: [K1, K2, K3, K4, K5, K6, K7, K8, ...(Part<any> | StoreSetter<any>)[]]
    ): void;
  }
  export function createStore<T extends StoreNode>(
    store: T | Store<T>,
    options?: {
      name?: string;
    },
  ): [get: Store<T>, set: SetStoreFunction<T>];
  export {};
}

declare module 'solid-js/store/mutable' {
  import { StoreNode, Store } from 'solid-js/store/store';
  export function createMutable<T extends StoreNode>(
    state: T | Store<T>,
    options?: {
      name?: string;
    },
  ): Store<T>;
}

declare module 'solid-js/store/modifiers' {
  import { Store, NotWrappable, DeepReadonly } from 'solid-js/store/store';
  export type ReconcileOptions = {
    key?: string | null;
    merge?: boolean;
  };
  export function reconcile<T>(
    value: T | Store<T>,
    options?: ReconcileOptions,
  ): (
    state: T extends NotWrappable ? T : Store<DeepReadonly<T>>,
  ) => T extends NotWrappable ? T : Store<T>;
  export function produce<T>(
    fn: (state: T) => void,
  ): (
    state: T extends NotWrappable ? T : Store<DeepReadonly<T>>,
  ) => T extends NotWrappable ? T : Store<T>;
}