@stencil/core 4.43.3 → 5.0.0-alpha.1

package/dist/runtime/client/index.d.ts

@@ -0,0 +1,2358 @@
+import { BUILD, Env, NAMESPACE } from "@stencil/core/runtime/app-data";
+//#region src/declarations/stencil-public-runtime.d.ts
+interface ElementDecorator {
+  (): PropertyDecorator;
+}
+interface EventDecorator {
+  (opts?: EventOptions): PropertyDecorator;
+}
+interface EventOptions {
+  /**
+   * A string custom event name to override the default.
+   */
+  eventName?: string;
+  /**
+   * A Boolean indicating whether the event bubbles up through the DOM or not.
+   */
+  bubbles?: boolean;
+  /**
+   * A Boolean indicating whether the event is cancelable.
+   */
+  cancelable?: boolean;
+  /**
+   * A Boolean value indicating whether or not the event can bubble across the boundary between the shadow DOM and the regular DOM.
+   */
+  composed?: boolean;
+}
+interface UserBuildConditionals {
+  isDev: boolean;
+  isBrowser: boolean;
+  isServer: boolean;
+  isTesting: boolean;
+}
+/**
+ * The `@Element()` decorator is a reference to the actual host element
+ * once it has rendered.
+ */
+declare const Element$2: ElementDecorator;
+/**
+ * Components can emit data and events using the Event Emitter decorator.
+ * To dispatch Custom DOM events for other components to handle, use the
+ * `@Event()` decorator. The Event decorator also makes it easier for Stencil
+ * to automatically build types and documentation for the event data.
+ * https://stenciljs.com/docs/events
+ */
+declare const Event$1: EventDecorator;
+type ResolutionHandler = (elm: HTMLElement) => string | undefined | null;
+type ErrorHandler = (err: any, element?: HTMLElement) => void;
+interface HTMLStencilElement extends HTMLElement {
+  componentOnReady(): Promise<this>;
+}
+type TagTransformer = (tag: string) => string;
+interface ComponentInterface {
+  connectedCallback?(): void;
+  disconnectedCallback?(): void;
+  componentWillRender?(): Promise<void> | void;
+  componentDidRender?(): void;
+  /**
+   * The component is about to load and it has not
+   * rendered yet.
+   *
+   * This is the best place to make any data updates
+   * before the first render.
+   *
+   * componentWillLoad will only be called once.
+   */
+  componentWillLoad?(): Promise<void> | void;
+  /**
+   * The component has loaded and has already rendered.
+   *
+   * Updating data in this method will cause the
+   * component to re-render.
+   *
+   * componentDidLoad will only be called once.
+   */
+  componentDidLoad?(): void;
+  /**
+   * A `@Prop` or `@State` property changed and a rerender is about to be requested.
+   *
+   * Called multiple times throughout the life of
+   * the component as its properties change.
+   *
+   * componentShouldUpdate is not called on the first render.
+   */
+  componentShouldUpdate?(newVal: any, oldVal: any, propName: string): boolean | void;
+  /**
+   * The component is about to update and re-render.
+   *
+   * Called multiple times throughout the life of
+   * the component as it updates.
+   *
+   * componentWillUpdate is not called on the first render.
+   */
+  componentWillUpdate?(): Promise<void> | void;
+  /**
+   * The component has just re-rendered.
+   *
+   * Called multiple times throughout the life of
+   * the component as it updates.
+   *
+   * componentWillUpdate is not called on the
+   * first render.
+   */
+  componentDidUpdate?(): void;
+  render?(): any;
+  [memberName: string]: any;
+}
+interface RafCallback {
+  (timeStamp: number): void;
+}
+/**
+ * Utilities for working with functional Stencil components. An object
+ * conforming to this interface is passed by the Stencil runtime as the third
+ * argument to a functional component, allowing component authors to work with
+ * features like children.
+ *
+ * The children of a functional component will be passed as the second
+ * argument, so a functional component which uses these utils to transform its
+ * children might look like the following:
+ *
+ * ```ts
+ * export const AddClass: FunctionalComponent = (_, children, utils) => (
+ *  utils.map(children, child => ({
+ *    ...child,
+ *    vattrs: {
+ *      ...child.vattrs,
+ *      class: `${child.vattrs.class} add-class`
+ *    }
+ *  }))
+ * );
+ * ```
+ *
+ * For more see the Stencil documentation, here:
+ * https://stenciljs.com/docs/functional-components
+ */
+interface FunctionalUtilities {
+  /**
+   * Utility for reading the children of a functional component at runtime.
+   * Since the Stencil runtime uses a different interface for children it is
+   * not recommended to read the children directly, and is preferable to use
+   * this utility to, for instance, perform a side effect for each child.
+   */
+  forEach: (children: VNode[], cb: (vnode: ChildNode$1, index: number, array: ChildNode$1[]) => void) => void;
+  /**
+   * Utility for transforming the children of a functional component. Given an
+   * array of children and a callback this will return a list of the results of
+   * passing each child to the supplied callback.
+   */
+  map: (children: VNode[], cb: (vnode: ChildNode$1, index: number, array: ChildNode$1[]) => ChildNode$1) => VNode[];
+}
+interface FunctionalComponent<T = {}> {
+  (props: T, children: VNode[], utils: FunctionalUtilities): VNode | VNode[] | null;
+}
+/**
+ * A Child VDOM node
+ *
+ * This has most of the same properties as {@link VNode} but friendlier names
+ * (i.e. `vtag` instead of `$tag$`, `vchildren` instead of `$children$`) in
+ * order to provide a friendlier public interface for users of the
+ * {@link FunctionalUtilities}).
+ */
+interface ChildNode$1 {
+  vtag?: string | number | Function;
+  vkey?: string | number;
+  vtext?: string;
+  vchildren?: VNode[];
+  vattrs?: any;
+  vname?: string;
+}
+/**
+ * A virtual DOM node
+ */
+interface VNode {
+  $flags$: number;
+  $tag$: string | number | Function;
+  $elm$: any;
+  $text$: string;
+  $children$: VNode[];
+  $attrs$?: any;
+  $name$?: string;
+  $key$?: string | number;
+}
+declare namespace JSXBase {
+  interface IntrinsicElements {
+    slot: JSXBase.SlotAttributes<HTMLSlotElement>;
+    a: JSXBase.AnchorHTMLAttributes<HTMLAnchorElement>;
+    abbr: JSXBase.HTMLAttributes;
+    address: JSXBase.HTMLAttributes;
+    area: JSXBase.AreaHTMLAttributes<HTMLAreaElement>;
+    article: JSXBase.HTMLAttributes;
+    aside: JSXBase.HTMLAttributes;
+    audio: JSXBase.AudioHTMLAttributes<HTMLAudioElement>;
+    b: JSXBase.HTMLAttributes;
+    base: JSXBase.BaseHTMLAttributes<HTMLBaseElement>;
+    bdi: JSXBase.HTMLAttributes;
+    bdo: JSXBase.HTMLAttributes;
+    big: JSXBase.HTMLAttributes;
+    blockquote: JSXBase.BlockquoteHTMLAttributes<HTMLQuoteElement>;
+    body: JSXBase.HTMLAttributes<HTMLBodyElement>;
+    br: JSXBase.HTMLAttributes<HTMLBRElement>;
+    button: JSXBase.ButtonHTMLAttributes<HTMLButtonElement>;
+    canvas: JSXBase.CanvasHTMLAttributes<HTMLCanvasElement>;
+    caption: JSXBase.HTMLAttributes<HTMLTableCaptionElement>;
+    cite: JSXBase.HTMLAttributes;
+    code: JSXBase.HTMLAttributes;
+    col: JSXBase.ColHTMLAttributes<HTMLTableColElement>;
+    colgroup: JSXBase.ColgroupHTMLAttributes<HTMLTableColElement>;
+    data: JSXBase.HTMLAttributes<HTMLDataElement>;
+    datalist: JSXBase.HTMLAttributes<HTMLDataListElement>;
+    dd: JSXBase.HTMLAttributes;
+    del: JSXBase.DelHTMLAttributes<HTMLModElement>;
+    details: JSXBase.DetailsHTMLAttributes<HTMLElement>;
+    dfn: JSXBase.HTMLAttributes;
+    dialog: JSXBase.DialogHTMLAttributes<HTMLDialogElement>;
+    div: JSXBase.HTMLAttributes<HTMLDivElement>;
+    dl: JSXBase.HTMLAttributes<HTMLDListElement>;
+    dt: JSXBase.HTMLAttributes;
+    em: JSXBase.HTMLAttributes;
+    embed: JSXBase.EmbedHTMLAttributes<HTMLEmbedElement>;
+    fieldset: JSXBase.FieldsetHTMLAttributes<HTMLFieldSetElement>;
+    figcaption: JSXBase.HTMLAttributes;
+    figure: JSXBase.HTMLAttributes;
+    footer: JSXBase.HTMLAttributes;
+    form: JSXBase.FormHTMLAttributes<HTMLFormElement>;
+    h1: JSXBase.HTMLAttributes<HTMLHeadingElement>;
+    h2: JSXBase.HTMLAttributes<HTMLHeadingElement>;
+    h3: JSXBase.HTMLAttributes<HTMLHeadingElement>;
+    h4: JSXBase.HTMLAttributes<HTMLHeadingElement>;
+    h5: JSXBase.HTMLAttributes<HTMLHeadingElement>;
+    h6: JSXBase.HTMLAttributes<HTMLHeadingElement>;
+    head: JSXBase.HTMLAttributes<HTMLHeadElement>;
+    header: JSXBase.HTMLAttributes;
+    hgroup: JSXBase.HTMLAttributes;
+    hr: JSXBase.HTMLAttributes<HTMLHRElement>;
+    html: JSXBase.HTMLAttributes<HTMLHtmlElement>;
+    i: JSXBase.HTMLAttributes;
+    iframe: JSXBase.IframeHTMLAttributes<HTMLIFrameElement>;
+    img: JSXBase.ImgHTMLAttributes<HTMLImageElement>;
+    input: JSXBase.InputHTMLAttributes<HTMLInputElement>;
+    ins: JSXBase.InsHTMLAttributes<HTMLModElement>;
+    kbd: JSXBase.HTMLAttributes;
+    keygen: JSXBase.KeygenHTMLAttributes<HTMLElement>;
+    label: JSXBase.LabelHTMLAttributes<HTMLLabelElement>;
+    legend: JSXBase.HTMLAttributes<HTMLLegendElement>;
+    li: JSXBase.LiHTMLAttributes<HTMLLIElement>;
+    link: JSXBase.LinkHTMLAttributes<HTMLLinkElement>;
+    main: JSXBase.HTMLAttributes;
+    map: JSXBase.MapHTMLAttributes<HTMLMapElement>;
+    mark: JSXBase.HTMLAttributes;
+    menu: JSXBase.MenuHTMLAttributes<HTMLMenuElement>;
+    menuitem: JSXBase.HTMLAttributes;
+    meta: JSXBase.MetaHTMLAttributes<HTMLMetaElement>;
+    meter: JSXBase.MeterHTMLAttributes<HTMLMeterElement>;
+    nav: JSXBase.HTMLAttributes;
+    noscript: JSXBase.HTMLAttributes;
+    object: JSXBase.ObjectHTMLAttributes<HTMLObjectElement>;
+    ol: JSXBase.OlHTMLAttributes<HTMLOListElement>;
+    optgroup: JSXBase.OptgroupHTMLAttributes<HTMLOptGroupElement>;
+    option: JSXBase.OptionHTMLAttributes<HTMLOptionElement>;
+    output: JSXBase.OutputHTMLAttributes<HTMLOutputElement>;
+    p: JSXBase.HTMLAttributes<HTMLParagraphElement>;
+    param: JSXBase.ParamHTMLAttributes<HTMLParamElement>;
+    picture: JSXBase.HTMLAttributes<HTMLPictureElement>;
+    pre: JSXBase.HTMLAttributes<HTMLPreElement>;
+    progress: JSXBase.ProgressHTMLAttributes<HTMLProgressElement>;
+    q: JSXBase.QuoteHTMLAttributes<HTMLQuoteElement>;
+    rp: JSXBase.HTMLAttributes;
+    rt: JSXBase.HTMLAttributes;
+    ruby: JSXBase.HTMLAttributes;
+    s: JSXBase.HTMLAttributes;
+    samp: JSXBase.HTMLAttributes;
+    script: JSXBase.ScriptHTMLAttributes<HTMLScriptElement>;
+    section: JSXBase.HTMLAttributes;
+    select: JSXBase.SelectHTMLAttributes<HTMLSelectElement>;
+    small: JSXBase.HTMLAttributes;
+    source: JSXBase.SourceHTMLAttributes<HTMLSourceElement>;
+    span: JSXBase.HTMLAttributes<HTMLSpanElement>;
+    strong: JSXBase.HTMLAttributes;
+    style: JSXBase.StyleHTMLAttributes<HTMLStyleElement>;
+    sub: JSXBase.HTMLAttributes;
+    summary: JSXBase.HTMLAttributes;
+    sup: JSXBase.HTMLAttributes;
+    table: JSXBase.TableHTMLAttributes<HTMLTableElement>;
+    tbody: JSXBase.HTMLAttributes<HTMLTableSectionElement>;
+    td: JSXBase.TdHTMLAttributes<HTMLTableDataCellElement>;
+    textarea: JSXBase.TextareaHTMLAttributes<HTMLTextAreaElement>;
+    tfoot: JSXBase.HTMLAttributes<HTMLTableSectionElement>;
+    th: JSXBase.ThHTMLAttributes<HTMLTableHeaderCellElement>;
+    thead: JSXBase.HTMLAttributes<HTMLTableSectionElement>;
+    time: JSXBase.TimeHTMLAttributes<HTMLTimeElement>;
+    title: JSXBase.HTMLAttributes<HTMLTitleElement>;
+    tr: JSXBase.HTMLAttributes<HTMLTableRowElement>;
+    track: JSXBase.TrackHTMLAttributes<HTMLTrackElement>;
+    u: JSXBase.HTMLAttributes;
+    ul: JSXBase.HTMLAttributes<HTMLUListElement>;
+    var: JSXBase.HTMLAttributes;
+    video: JSXBase.VideoHTMLAttributes<HTMLVideoElement>;
+    wbr: JSXBase.HTMLAttributes;
+    animate: JSXBase.SVGAttributes;
+    circle: JSXBase.SVGAttributes;
+    clipPath: JSXBase.SVGAttributes;
+    defs: JSXBase.SVGAttributes;
+    desc: JSXBase.SVGAttributes;
+    ellipse: JSXBase.SVGAttributes;
+    feBlend: JSXBase.SVGAttributes;
+    feColorMatrix: JSXBase.SVGAttributes;
+    feComponentTransfer: JSXBase.SVGAttributes;
+    feComposite: JSXBase.SVGAttributes;
+    feConvolveMatrix: JSXBase.SVGAttributes;
+    feDiffuseLighting: JSXBase.SVGAttributes;
+    feDisplacementMap: JSXBase.SVGAttributes;
+    feDistantLight: JSXBase.SVGAttributes;
+    feDropShadow: JSXBase.SVGAttributes;
+    feFlood: JSXBase.SVGAttributes;
+    feFuncA: JSXBase.SVGAttributes;
+    feFuncB: JSXBase.SVGAttributes;
+    feFuncG: JSXBase.SVGAttributes;
+    feFuncR: JSXBase.SVGAttributes;
+    feGaussianBlur: JSXBase.SVGAttributes;
+    feImage: JSXBase.SVGAttributes;
+    feMerge: JSXBase.SVGAttributes;
+    feMergeNode: JSXBase.SVGAttributes;
+    feMorphology: JSXBase.SVGAttributes;
+    feOffset: JSXBase.SVGAttributes;
+    fePointLight: JSXBase.SVGAttributes;
+    feSpecularLighting: JSXBase.SVGAttributes;
+    feSpotLight: JSXBase.SVGAttributes;
+    feTile: JSXBase.SVGAttributes;
+    feTurbulence: JSXBase.SVGAttributes;
+    filter: JSXBase.SVGAttributes;
+    foreignObject: JSXBase.SVGAttributes;
+    g: JSXBase.SVGAttributes;
+    image: JSXBase.SVGAttributes;
+    line: JSXBase.SVGAttributes;
+    linearGradient: JSXBase.SVGAttributes;
+    marker: JSXBase.SVGAttributes;
+    mask: JSXBase.SVGAttributes;
+    metadata: JSXBase.SVGAttributes;
+    path: JSXBase.SVGAttributes;
+    pattern: JSXBase.SVGAttributes;
+    polygon: JSXBase.SVGAttributes;
+    polyline: JSXBase.SVGAttributes;
+    radialGradient: JSXBase.SVGAttributes;
+    rect: JSXBase.SVGAttributes;
+    stop: JSXBase.SVGAttributes;
+    svg: JSXBase.SVGAttributes;
+    switch: JSXBase.SVGAttributes;
+    symbol: JSXBase.SVGAttributes;
+    text: JSXBase.SVGAttributes;
+    textPath: JSXBase.SVGAttributes;
+    tspan: JSXBase.SVGAttributes;
+    use: JSXBase.SVGAttributes;
+    view: JSXBase.SVGAttributes;
+  }
+  interface SlotAttributes<T = HTMLSlotElement> extends JSXAttributes<T> {
+    name?: string;
+    slot?: string;
+    onSlotchange?: (event: Event$1) => void;
+  }
+  interface AnchorHTMLAttributes<T> extends HTMLAttributes<T> {
+    download?: any;
+    href?: string;
+    hrefLang?: string;
+    hreflang?: string;
+    media?: string;
+    ping?: string;
+    rel?: string;
+    target?: string;
+    referrerPolicy?: ReferrerPolicy;
+  }
+  interface AudioHTMLAttributes<T> extends MediaHTMLAttributes<T> {}
+  interface AreaHTMLAttributes<T> extends HTMLAttributes<T> {
+    alt?: string;
+    coords?: string;
+    download?: any;
+    href?: string;
+    hrefLang?: string;
+    hreflang?: string;
+    media?: string;
+    rel?: string;
+    shape?: string;
+    target?: string;
+  }
+  interface BaseHTMLAttributes<T> extends HTMLAttributes<T> {
+    href?: string;
+    target?: string;
+  }
+  interface BlockquoteHTMLAttributes<T> extends HTMLAttributes<T> {
+    cite?: string;
+  }
+  interface ButtonHTMLAttributes<T> extends HTMLAttributes<T> {
+    disabled?: boolean;
+    form?: string;
+    formAction?: string;
+    formaction?: string;
+    formEncType?: string;
+    formenctype?: string;
+    formMethod?: string;
+    formmethod?: string;
+    formNoValidate?: boolean;
+    formnovalidate?: boolean;
+    formTarget?: string;
+    formtarget?: string;
+    name?: string;
+    type?: string;
+    value?: string | string[] | number;
+    popoverTargetAction?: string;
+    popoverTargetElement?: Element$2 | null;
+    popoverTarget?: string;
+    command?: string;
+    commandFor?: string;
+    commandfor?: string;
+  }
+  interface CanvasHTMLAttributes<T> extends HTMLAttributes<T> {
+    height?: number | string;
+    width?: number | string;
+  }
+  interface ColHTMLAttributes<T> extends HTMLAttributes<T> {
+    span?: number;
+  }
+  interface ColgroupHTMLAttributes<T> extends HTMLAttributes<T> {
+    span?: number;
+  }
+  interface DetailsHTMLAttributes<T> extends HTMLAttributes<T> {
+    open?: boolean;
+    name?: string;
+    onToggle?: (event: ToggleEvent) => void;
+  }
+  interface DelHTMLAttributes<T> extends HTMLAttributes<T> {
+    cite?: string;
+    dateTime?: string;
+    datetime?: string;
+  }
+  interface DialogHTMLAttributes<T> extends HTMLAttributes<T> {
+    onCancel?: (event: Event$1) => void;
+    onClose?: (event: Event$1) => void;
+    open?: boolean;
+    returnValue?: string;
+  }
+  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;
+    acceptcharset?: string;
+    action?: string;
+    autoComplete?: string;
+    autocomplete?: string;
+    encType?: string;
+    enctype?: string;
+    method?: string;
+    name?: string;
+    noValidate?: boolean;
+    novalidate?: boolean | string;
+    target?: string;
+  }
+  interface HtmlHTMLAttributes<T> extends HTMLAttributes<T> {
+    manifest?: string;
+  }
+  interface IframeHTMLAttributes<T> extends HTMLAttributes<T> {
+    allow?: string;
+    allowFullScreen?: boolean;
+    allowfullScreen?: string | boolean;
+    allowTransparency?: boolean;
+    allowtransparency?: string | boolean;
+    frameBorder?: number | string;
+    frameborder?: number | string;
+    importance?: 'low' | 'auto' | 'high';
+    height?: number | string;
+    loading?: 'lazy' | 'auto' | 'eager';
+    marginHeight?: number;
+    marginheight?: string | number;
+    marginWidth?: number;
+    marginwidth?: string | number;
+    name?: string;
+    referrerPolicy?: ReferrerPolicy;
+    sandbox?: string;
+    scrolling?: string;
+    seamless?: boolean;
+    src?: string;
+    srcDoc?: string;
+    srcdoc?: string;
+    width?: number | string;
+  }
+  interface ImgHTMLAttributes<T> extends HTMLAttributes<T> {
+    alt?: string;
+    crossOrigin?: string;
+    crossorigin?: string;
+    decoding?: 'async' | 'auto' | 'sync';
+    importance?: 'low' | 'auto' | 'high';
+    height?: number | string;
+    loading?: 'lazy' | 'auto' | 'eager';
+    sizes?: string;
+    src?: string;
+    srcSet?: string;
+    srcset?: string;
+    useMap?: string;
+    usemap?: string;
+    width?: number | string;
+  }
+  interface InsHTMLAttributes<T> extends HTMLAttributes<T> {
+    cite?: string;
+    dateTime?: string;
+    datetime?: string;
+  }
+  interface InputHTMLAttributes<T> extends HTMLAttributes<T> {
+    accept?: string;
+    allowdirs?: boolean;
+    alt?: string;
+    autoCapitalize?: string;
+    autocapitalize?: string;
+    autoComplete?: string;
+    autocomplete?: string;
+    capture?: string;
+    checked?: boolean;
+    crossOrigin?: string;
+    crossorigin?: string;
+    defaultChecked?: boolean;
+    defaultValue?: string;
+    dirName?: string;
+    disabled?: boolean;
+    files?: any;
+    form?: string;
+    formAction?: string;
+    formaction?: string;
+    formEncType?: string;
+    formenctype?: string;
+    formMethod?: string;
+    formmethod?: string;
+    formNoValidate?: boolean;
+    formnovalidate?: boolean;
+    formTarget?: string;
+    formtarget?: string;
+    height?: number | string;
+    indeterminate?: boolean;
+    list?: string;
+    max?: number | string;
+    maxLength?: number;
+    maxlength?: number | string;
+    min?: number | string;
+    minLength?: number;
+    minlength?: number | string;
+    multiple?: boolean;
+    name?: string;
+    onSelect?: (event: Event$1) => void;
+    onselect?: (event: Event$1) => void;
+    pattern?: string;
+    placeholder?: string;
+    readOnly?: boolean;
+    readonly?: boolean | string;
+    required?: boolean;
+    selectionStart?: number | string;
+    selectionEnd?: number | string;
+    selectionDirection?: string;
+    size?: number;
+    src?: string;
+    step?: number | string;
+    type?: string;
+    value?: string | string[] | number;
+    valueAsDate?: any;
+    valueAsNumber?: any;
+    webkitdirectory?: boolean;
+    webkitEntries?: any;
+    width?: number | string;
+    popoverTargetAction?: string;
+    popoverTargetElement?: Element$2 | null;
+    popoverTarget?: string;
+  }
+  interface KeygenHTMLAttributes<T> extends HTMLAttributes<T> {
+    challenge?: string;
+    disabled?: boolean;
+    form?: string;
+    keyType?: string;
+    keytype?: string;
+    keyParams?: string;
+    keyparams?: string;
+    name?: string;
+  }
+  interface LabelHTMLAttributes<T> extends HTMLAttributes<T> {
+    form?: string;
+    htmlFor?: string;
+  }
+  interface LiHTMLAttributes<T> extends HTMLAttributes<T> {
+    value?: string | string[] | number;
+  }
+  interface LinkHTMLAttributes<T> extends HTMLAttributes<T> {
+    as?: string;
+    href?: string;
+    hrefLang?: string;
+    hreflang?: string;
+    importance?: 'low' | 'auto' | 'high';
+    integrity?: string;
+    media?: string;
+    rel?: string;
+    sizes?: string;
+    type?: string;
+  }
+  interface MapHTMLAttributes<T> extends HTMLAttributes<T> {
+    name?: string;
+  }
+  interface MenuHTMLAttributes<T> extends HTMLAttributes<T> {
+    type?: string;
+  }
+  interface MediaHTMLAttributes<T> extends HTMLAttributes<T> {
+    autoPlay?: boolean;
+    autoplay?: boolean | string;
+    controls?: boolean;
+    controlslist?: 'nodownload' | 'nofullscreen' | 'noremoteplayback';
+    controlsList?: 'nodownload' | 'nofullscreen' | 'noremoteplayback';
+    crossOrigin?: string;
+    crossorigin?: string;
+    loop?: boolean;
+    mediaGroup?: string;
+    mediagroup?: string;
+    muted?: boolean;
+    preload?: string;
+    src?: string;
+    onAbort?: (event: Event$1) => void;
+    onCanPlay?: (event: Event$1) => void;
+    onCanPlayThrough?: (event: Event$1) => void;
+    onDurationChange?: (event: Event$1) => void;
+    onEmptied?: (event: Event$1) => void;
+    onEnded?: (event: Event$1) => void;
+    onError?: (event: Event$1) => void;
+    onInterruptBegin?: (event: Event$1) => void;
+    onInterruptEnd?: (event: Event$1) => void;
+    onLoadedData?: (event: Event$1) => void;
+    onLoadedMetaData?: (event: Event$1) => void;
+    onLoadStart?: (event: Event$1) => void;
+    onMozAudioAvailable?: (event: Event$1) => void;
+    onPause?: (event: Event$1) => void;
+    onPlay?: (event: Event$1) => void;
+    onPlaying?: (event: Event$1) => void;
+    onProgress?: (event: Event$1) => void;
+    onRateChange?: (event: Event$1) => void;
+    onSeeked?: (event: Event$1) => void;
+    onSeeking?: (event: Event$1) => void;
+    onStalled?: (event: Event$1) => void;
+    onSuspend?: (event: Event$1) => void;
+    onTimeUpdate?: (event: Event$1) => void;
+    onVolumeChange?: (event: Event$1) => void;
+    onWaiting?: (event: Event$1) => void;
+  }
+  interface MetaHTMLAttributes<T> extends HTMLAttributes<T> {
+    charSet?: string;
+    charset?: string;
+    content?: string;
+    httpEquiv?: string;
+    httpequiv?: string;
+    name?: string;
+  }
+  interface MeterHTMLAttributes<T> extends HTMLAttributes<T> {
+    form?: string;
+    high?: number;
+    low?: number;
+    max?: number | string;
+    min?: number | string;
+    optimum?: number;
+    value?: string | string[] | number;
+  }
+  interface QuoteHTMLAttributes<T> extends HTMLAttributes<T> {
+    cite?: string;
+  }
+  interface ObjectHTMLAttributes<T> extends HTMLAttributes<T> {
+    classID?: string;
+    classid?: string;
+    data?: string;
+    form?: string;
+    height?: number | string;
+    name?: string;
+    type?: string;
+    useMap?: string;
+    usemap?: string;
+    width?: number | string;
+    wmode?: string;
+  }
+  interface OlHTMLAttributes<T> extends HTMLAttributes<T> {
+    reversed?: boolean;
+    start?: number;
+  }
+  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;
+    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;
+    charset?: string;
+    crossOrigin?: string;
+    crossorigin?: string;
+    defer?: boolean;
+    importance?: 'low' | 'auto' | 'high';
+    integrity?: string;
+    nonce?: string;
+    src?: string;
+    type?: string;
+  }
+  interface SelectHTMLAttributes<T> extends HTMLAttributes<T> {
+    disabled?: boolean;
+    form?: string;
+    multiple?: boolean;
+    name?: string;
+    required?: boolean;
+    size?: number;
+    autoComplete?: string;
+    autocomplete?: string;
+  }
+  interface SourceHTMLAttributes<T> extends HTMLAttributes<T> {
+    height?: number;
+    media?: string;
+    sizes?: string;
+    src?: string;
+    srcSet?: string;
+    type?: string;
+    width?: number;
+  }
+  interface StyleHTMLAttributes<T> extends HTMLAttributes<T> {
+    media?: string;
+    nonce?: string;
+    scoped?: boolean;
+    type?: string;
+  }
+  interface TableHTMLAttributes<T> extends HTMLAttributes<T> {
+    cellPadding?: number | string;
+    cellpadding?: number | string;
+    cellSpacing?: number | string;
+    cellspacing?: number | string;
+    summary?: string;
+  }
+  interface TextareaHTMLAttributes<T> extends HTMLAttributes<T> {
+    autoComplete?: string;
+    autocomplete?: string;
+    cols?: number;
+    disabled?: boolean;
+    form?: string;
+    maxLength?: number;
+    maxlength?: number | string;
+    minLength?: number;
+    minlength?: number | string;
+    name?: string;
+    onSelect?: (event: Event$1) => void;
+    onselect?: (event: Event$1) => void;
+    placeholder?: string;
+    readOnly?: boolean;
+    readonly?: boolean | string;
+    required?: boolean;
+    rows?: number;
+    value?: string | string[] | number;
+    wrap?: string;
+  }
+  interface TdHTMLAttributes<T> extends HTMLAttributes<T> {
+    colSpan?: number;
+    headers?: string;
+    rowSpan?: number;
+  }
+  interface ThHTMLAttributes<T> extends HTMLAttributes<T> {
+    abbr?: string;
+    colSpan?: number;
+    headers?: string;
+    rowSpan?: number;
+    rowspan?: number | string;
+    scope?: string;
+  }
+  interface TimeHTMLAttributes<T> extends HTMLAttributes<T> {
+    dateTime?: string;
+  }
+  interface TrackHTMLAttributes<T> extends HTMLAttributes<T> {
+    default?: boolean;
+    kind?: string;
+    label?: string;
+    src?: string;
+    srcLang?: string;
+    srclang?: string;
+  }
+  interface VideoHTMLAttributes<T> extends MediaHTMLAttributes<T> {
+    height?: number | string;
+    playsInline?: boolean;
+    playsinline?: boolean | string;
+    poster?: string;
+    width?: number | string;
+  }
+  interface HTMLAttributes<T = HTMLElement> extends DOMAttributes<T> {
+    innerHTML?: string;
+    accessKey?: string;
+    autoFocus?: boolean;
+    autofocus?: boolean | string;
+    class?: string | {
+      [className: string]: boolean;
+    };
+    contentEditable?: boolean | string;
+    contenteditable?: boolean | string;
+    contextMenu?: string;
+    contextmenu?: string;
+    dir?: string;
+    draggable?: boolean;
+    hidden?: boolean;
+    id?: string;
+    inert?: boolean;
+    lang?: string;
+    spellcheck?: 'true' | 'false' | any;
+    style?: {
+      [key: string]: string | undefined;
+    };
+    tabIndex?: number;
+    tabindex?: number | string;
+    title?: string;
+    popover?: string | null;
+    inputMode?: string;
+    inputmode?: string;
+    enterKeyHint?: string;
+    enterkeyhint?: string;
+    is?: string;
+    radioGroup?: string;
+    radiogroup?: string;
+    role?: string;
+    about?: string;
+    datatype?: string;
+    inlist?: any;
+    prefix?: string;
+    property?: string;
+    resource?: string;
+    typeof?: string;
+    vocab?: string;
+    autoCapitalize?: string;
+    autocapitalize?: string;
+    autoCorrect?: string;
+    autocorrect?: string;
+    autoSave?: string;
+    autosave?: string;
+    color?: string;
+    itemProp?: string;
+    itemprop?: string;
+    itemScope?: boolean;
+    itemscope?: boolean;
+    itemType?: string;
+    itemtype?: string;
+    itemID?: string;
+    itemid?: string;
+    itemRef?: string;
+    itemref?: string;
+    results?: number;
+    security?: string;
+    unselectable?: boolean;
+  }
+  interface SVGAttributes<T = SVGElement> extends DOMAttributes<T> {
+    class?: string | {
+      [className: string]: boolean;
+    };
+    color?: string;
+    height?: number | string;
+    id?: string;
+    lang?: string;
+    max?: number | string;
+    media?: string;
+    method?: string;
+    min?: number | string;
+    name?: string;
+    style?: {
+      [key: string]: string | undefined;
+    };
+    target?: string;
+    type?: string;
+    width?: number | string;
+    role?: string;
+    tabindex?: number;
+    'accent-height'?: number | string;
+    accumulate?: 'none' | 'sum';
+    additive?: 'replace' | 'sum';
+    'alignment-baseline'?: 'auto' | 'baseline' | 'before-edge' | 'text-before-edge' | 'middle' | 'central' | 'after-edge' | 'text-after-edge' | 'ideographic' | 'alphabetic' | 'hanging' | 'mathematical' | 'inherit';
+    allowReorder?: 'no' | 'yes';
+    alphabetic?: number | string;
+    amplitude?: number | string;
+    'arabic-form'?: 'initial' | 'medial' | 'terminal' | 'isolated';
+    ascent?: number | string;
+    attributeName?: string;
+    attributeType?: string;
+    autoReverse?: number | string;
+    azimuth?: number | string;
+    baseFrequency?: number | string;
+    'baseline-shift'?: number | string;
+    baseProfile?: number | string;
+    bbox?: number | string;
+    begin?: number | string;
+    bias?: number | string;
+    by?: number | string;
+    calcMode?: number | string;
+    'cap-height'?: number | string;
+    clip?: number | string;
+    'clip-path'?: string;
+    clipPathUnits?: number | string;
+    'clip-rule'?: number | string;
+    'color-interpolation'?: number | string;
+    'color-interpolation-filters'?: 'auto' | 'sRGB' | 'linearRGB';
+    'color-profile'?: number | string;
+    'color-rendering'?: number | string;
+    contentScriptType?: number | string;
+    contentStyleType?: number | string;
+    cursor?: number | string;
+    cx?: number | string;
+    cy?: number | string;
+    d?: string;
+    decelerate?: number | string;
+    descent?: number | string;
+    diffuseConstant?: number | string;
+    direction?: number | string;
+    display?: number | string;
+    divisor?: number | string;
+    'dominant-baseline'?: number | string;
+    dur?: number | string;
+    dx?: number | string;
+    dy?: number | string;
+    'edge-mode'?: number | string;
+    elevation?: number | string;
+    'enable-background'?: number | string;
+    end?: number | string;
+    exponent?: number | string;
+    externalResourcesRequired?: number | string;
+    fill?: string;
+    'fill-opacity'?: number | string;
+    'fill-rule'?: 'nonzero' | 'evenodd' | 'inherit';
+    filter?: string;
+    filterRes?: number | string;
+    filterUnits?: number | string;
+    'flood-color'?: number | string;
+    'flood-opacity'?: number | string;
+    focusable?: number | string;
+    'font-family'?: string;
+    'font-size'?: number | string;
+    'font-size-adjust'?: number | string;
+    'font-stretch'?: number | string;
+    'font-style'?: number | string;
+    'font-variant'?: number | string;
+    'font-weight'?: number | string;
+    format?: number | string;
+    from?: number | string;
+    fx?: number | string;
+    fy?: number | string;
+    g1?: number | string;
+    g2?: number | string;
+    'glyph-name'?: number | string;
+    'glyph-orientation-horizontal'?: number | string;
+    'glyph-orientation-vertical'?: number | string;
+    glyphRef?: number | string;
+    gradientTransform?: string;
+    gradientUnits?: string;
+    hanging?: number | string;
+    'horiz-adv-x'?: number | string;
+    'horiz-origin-x'?: number | string;
+    href?: string;
+    ideographic?: number | string;
+    'image-rendering'?: number | string;
+    in2?: number | string;
+    in?: string;
+    intercept?: number | string;
+    k1?: number | string;
+    k2?: number | string;
+    k3?: number | string;
+    k4?: number | string;
+    k?: number | string;
+    kernelMatrix?: number | string;
+    kernelUnitLength?: number | string;
+    kerning?: number | string;
+    keyPoints?: number | string;
+    keySplines?: number | string;
+    keyTimes?: number | string;
+    lengthAdjust?: number | string;
+    'letter-spacing'?: number | string;
+    'lighting-color'?: number | string;
+    limitingConeAngle?: number | string;
+    local?: number | string;
+    'marker-end'?: string;
+    markerHeight?: number | string;
+    'marker-mid'?: string;
+    'marker-start'?: string;
+    markerUnits?: number | string;
+    markerWidth?: number | string;
+    mask?: string;
+    maskContentUnits?: number | string;
+    maskUnits?: number | string;
+    mathematical?: number | string;
+    mode?: number | string;
+    numOctaves?: number | string;
+    offset?: number | string;
+    opacity?: number | string;
+    operator?: number | string;
+    order?: number | string;
+    orient?: number | string;
+    orientation?: number | string;
+    origin?: number | string;
+    overflow?: number | string;
+    'overline-position'?: number | string;
+    'overline-thickness'?: number | string;
+    'paint-order'?: number | string;
+    panose1?: number | string;
+    pathLength?: number | string;
+    patternContentUnits?: string;
+    patternTransform?: number | string;
+    patternUnits?: string;
+    'pointer-events'?: number | string;
+    points?: string;
+    pointsAtX?: number | string;
+    pointsAtY?: number | string;
+    pointsAtZ?: number | string;
+    preserveAlpha?: number | string;
+    preserveAspectRatio?: string;
+    primitiveUnits?: number | string;
+    r?: number | string;
+    radius?: number | string;
+    refX?: number | string;
+    refY?: number | string;
+    'rendering-intent'?: number | string;
+    repeatCount?: number | string;
+    repeatDur?: number | string;
+    requiredextensions?: number | string;
+    requiredFeatures?: number | string;
+    restart?: number | string;
+    result?: string;
+    rotate?: number | string;
+    rx?: number | string;
+    ry?: number | string;
+    scale?: number | string;
+    seed?: number | string;
+    'shape-rendering'?: number | string;
+    slope?: number | string;
+    spacing?: number | string;
+    specularConstant?: number | string;
+    specularExponent?: number | string;
+    speed?: number | string;
+    spreadMethod?: string;
+    startOffset?: number | string;
+    stdDeviation?: number | string;
+    stemh?: number | string;
+    stemv?: number | string;
+    stitchTiles?: number | string;
+    'stop-color'?: string;
+    'stop-opacity'?: number | string;
+    'strikethrough-position'?: number | string;
+    'strikethrough-thickness'?: number | string;
+    string?: number | string;
+    stroke?: string;
+    'stroke-dasharray'?: string | number;
+    'stroke-dashoffset'?: string | number;
+    'stroke-linecap'?: 'butt' | 'round' | 'square' | 'inherit';
+    'stroke-linejoin'?: 'miter' | 'round' | 'bevel' | 'inherit';
+    'stroke-miterlimit'?: string;
+    'stroke-opacity'?: number | string;
+    'stroke-width'?: number | string;
+    surfaceScale?: number | string;
+    systemLanguage?: number | string;
+    tableValues?: number | string;
+    targetX?: number | string;
+    targetY?: number | string;
+    'text-anchor'?: string;
+    'text-decoration'?: number | string;
+    textLength?: number | string;
+    'text-rendering'?: number | string;
+    to?: number | string;
+    transform?: string;
+    u1?: number | string;
+    u2?: number | string;
+    'underline-position'?: number | string;
+    'underline-thickness'?: number | string;
+    unicode?: number | string;
+    'unicode-bidi'?: number | string;
+    'unicode-range'?: number | string;
+    'units-per-em'?: number | string;
+    'v-alphabetic'?: number | string;
+    values?: string;
+    'vector-effect'?: number | string;
+    version?: string;
+    'vert-adv-y'?: number | string;
+    'vert-origin-x'?: number | string;
+    'vert-origin-y'?: number | string;
+    'v-hanging'?: number | string;
+    'v-ideographic'?: number | string;
+    viewBox?: string;
+    viewTarget?: number | string;
+    visibility?: number | string;
+    'v-mathematical'?: number | string;
+    widths?: number | string;
+    'word-spacing'?: number | string;
+    'writing-mode'?: number | string;
+    x1?: number | string;
+    x2?: number | string;
+    x?: number | string;
+    'x-channel-selector'?: string;
+    'x-height'?: number | string;
+    xlinkActuate?: string;
+    xlinkArcrole?: string;
+    xlinkHref?: string;
+    xlinkRole?: string;
+    xlinkShow?: string;
+    xlinkTitle?: string;
+    xlinkType?: string;
+    xmlBase?: string;
+    xmlLang?: string;
+    xmlns?: string;
+    xmlSpace?: string;
+    y1?: number | string;
+    y2?: number | string;
+    y?: number | string;
+    yChannelSelector?: string;
+    z?: number | string;
+    zoomAndPan?: string;
+  }
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ToggleEvent) */
+  interface ToggleEvent extends Event$1 {
+    /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ToggleEvent/newState) */
+    readonly newState: string;
+    /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ToggleEvent/oldState) */
+    readonly oldState: string;
+  }
+  interface DOMAttributes<T> extends JSXAttributes<T> {
+    slot?: string;
+    part?: string;
+    exportparts?: string;
+    onCopy?: (event: ClipboardEvent) => void;
+    onCopyCapture?: (event: ClipboardEvent) => void;
+    onCut?: (event: ClipboardEvent) => void;
+    onCutCapture?: (event: ClipboardEvent) => void;
+    onPaste?: (event: ClipboardEvent) => void;
+    onPasteCapture?: (event: ClipboardEvent) => void;
+    onCompositionend?: (event: CompositionEvent) => void;
+    onCompositionendCapture?: (event: CompositionEvent) => void;
+    onCompositionstart?: (event: CompositionEvent) => void;
+    onCompositionstartCapture?: (event: CompositionEvent) => void;
+    onCompositionupdate?: (event: CompositionEvent) => void;
+    onCompositionupdateCapture?: (event: CompositionEvent) => void;
+    onBeforeToggle?: (event: ToggleEvent) => void;
+    onBeforeToggleCapture?: (event: ToggleEvent) => void;
+    onToggle?: (event: ToggleEvent) => void;
+    onToggleCapture?: (event: ToggleEvent) => void;
+    onFocus?: (event: FocusEvent) => void;
+    onFocusCapture?: (event: FocusEvent) => void;
+    onFocusin?: (event: FocusEvent) => void;
+    onFocusinCapture?: (event: FocusEvent) => void;
+    onFocusout?: (event: FocusEvent) => void;
+    onFocusoutCapture?: (event: FocusEvent) => void;
+    onBlur?: (event: FocusEvent) => void;
+    onBlurCapture?: (event: FocusEvent) => void;
+    onChange?: (event: Event$1) => void;
+    onChangeCapture?: (event: Event$1) => void;
+    onInput?: (event: InputEvent) => void;
+    onInputCapture?: (event: InputEvent) => void;
+    onReset?: (event: Event$1) => void;
+    onResetCapture?: (event: Event$1) => void;
+    onSubmit?: (event: Event$1) => void;
+    onSubmitCapture?: (event: Event$1) => void;
+    onInvalid?: (event: Event$1) => void;
+    onInvalidCapture?: (event: Event$1) => void;
+    onLoad?: (event: Event$1) => void;
+    onLoadCapture?: (event: Event$1) => void;
+    onError?: (event: Event$1) => void;
+    onErrorCapture?: (event: Event$1) => void;
+    onKeyDown?: (event: KeyboardEvent) => void;
+    onKeyDownCapture?: (event: KeyboardEvent) => void;
+    onKeyPress?: (event: KeyboardEvent) => void;
+    onKeyPressCapture?: (event: KeyboardEvent) => void;
+    onKeyUp?: (event: KeyboardEvent) => void;
+    onKeyUpCapture?: (event: KeyboardEvent) => void;
+    onAuxClick?: (event: MouseEvent) => void;
+    onClick?: (event: PointerEvent) => void;
+    onClickCapture?: (event: MouseEvent) => void;
+    onContextMenu?: (event: MouseEvent) => void;
+    onContextMenuCapture?: (event: MouseEvent) => void;
+    onDblClick?: (event: MouseEvent) => void;
+    onDblClickCapture?: (event: MouseEvent) => void;
+    onDrag?: (event: DragEvent) => void;
+    onDragCapture?: (event: DragEvent) => void;
+    onDragEnd?: (event: DragEvent) => void;
+    onDragEndCapture?: (event: DragEvent) => void;
+    onDragEnter?: (event: DragEvent) => void;
+    onDragEnterCapture?: (event: DragEvent) => void;
+    onDragExit?: (event: DragEvent) => void;
+    onDragExitCapture?: (event: DragEvent) => void;
+    onDragLeave?: (event: DragEvent) => void;
+    onDragLeaveCapture?: (event: DragEvent) => void;
+    onDragOver?: (event: DragEvent) => void;
+    onDragOverCapture?: (event: DragEvent) => void;
+    onDragStart?: (event: DragEvent) => void;
+    onDragStartCapture?: (event: DragEvent) => void;
+    onDrop?: (event: DragEvent) => void;
+    onDropCapture?: (event: DragEvent) => void;
+    onMouseDown?: (event: MouseEvent) => void;
+    onMouseDownCapture?: (event: MouseEvent) => void;
+    onMouseEnter?: (event: MouseEvent) => void;
+    onMouseLeave?: (event: MouseEvent) => void;
+    onMouseMove?: (event: MouseEvent) => void;
+    onMouseMoveCapture?: (event: MouseEvent) => void;
+    onMouseOut?: (event: MouseEvent) => void;
+    onMouseOutCapture?: (event: MouseEvent) => void;
+    onMouseOver?: (event: MouseEvent) => void;
+    onMouseOverCapture?: (event: MouseEvent) => void;
+    onMouseUp?: (event: MouseEvent) => void;
+    onMouseUpCapture?: (event: MouseEvent) => void;
+    onTouchCancel?: (event: TouchEvent) => void;
+    onTouchCancelCapture?: (event: TouchEvent) => void;
+    onTouchEnd?: (event: TouchEvent) => void;
+    onTouchEndCapture?: (event: TouchEvent) => void;
+    onTouchMove?: (event: TouchEvent) => void;
+    onTouchMoveCapture?: (event: TouchEvent) => void;
+    onTouchStart?: (event: TouchEvent) => void;
+    onTouchStartCapture?: (event: TouchEvent) => void;
+    onPointerDown?: (event: PointerEvent) => void;
+    onPointerDownCapture?: (event: PointerEvent) => void;
+    onPointerMove?: (event: PointerEvent) => void;
+    onPointerMoveCapture?: (event: PointerEvent) => void;
+    onPointerUp?: (event: PointerEvent) => void;
+    onPointerUpCapture?: (event: PointerEvent) => void;
+    onPointerCancel?: (event: PointerEvent) => void;
+    onPointerCancelCapture?: (event: PointerEvent) => void;
+    onPointerEnter?: (event: PointerEvent) => void;
+    onPointerEnterCapture?: (event: PointerEvent) => void;
+    onPointerLeave?: (event: PointerEvent) => void;
+    onPointerLeaveCapture?: (event: PointerEvent) => void;
+    onPointerOver?: (event: PointerEvent) => void;
+    onPointerOverCapture?: (event: PointerEvent) => void;
+    onPointerOut?: (event: PointerEvent) => void;
+    onPointerOutCapture?: (event: PointerEvent) => void;
+    onGotPointerCapture?: (event: PointerEvent) => void;
+    onGotPointerCaptureCapture?: (event: PointerEvent) => void;
+    onLostPointerCapture?: (event: PointerEvent) => void;
+    onLostPointerCaptureCapture?: (event: PointerEvent) => void;
+    onScroll?: (event: UIEvent) => void;
+    onScrollCapture?: (event: UIEvent) => void;
+    onWheel?: (event: WheelEvent) => void;
+    onWheelCapture?: (event: WheelEvent) => void;
+    onAnimationStart?: (event: AnimationEvent) => void;
+    onAnimationStartCapture?: (event: AnimationEvent) => void;
+    onAnimationEnd?: (event: AnimationEvent) => void;
+    onAnimationEndCapture?: (event: AnimationEvent) => void;
+    onAnimationIteration?: (event: AnimationEvent) => void;
+    onAnimationIterationCapture?: (event: AnimationEvent) => void;
+    onTransitionCancel?: (event: TransitionEvent) => void;
+    onTransitionCancelCapture?: (event: TransitionEvent) => void;
+    onTransitionEnd?: (event: TransitionEvent) => void;
+    onTransitionEndCapture?: (event: TransitionEvent) => void;
+    onTransitionRun?: (event: TransitionEvent) => void;
+    onTransitionRunCapture?: (event: TransitionEvent) => void;
+    onTransitionStart?: (event: TransitionEvent) => void;
+    onTransitionStartCapture?: (event: TransitionEvent) => void;
+    [key: `aria-${string}`]: string | boolean | undefined;
+    [key: `aria${string}`]: string | boolean | undefined;
+  }
+}
+interface JSXAttributes<T = Element$2> {
+  key?: string | number;
+  ref?: (elm?: T) => void;
+}
+interface CustomElementsDefineOptions {
+  exclude?: string[];
+  syncQueue?: boolean;
+  /** @deprecated in-favour of `setTagTransformer` and `transformTag` */
+  transformTagName?: (tagName: string) => string;
+  jmp?: (c: Function) => any;
+  raf?: (c: FrameRequestCallback) => number;
+  ael?: (el: EventTarget, eventName: string, listener: EventListenerOrEventListenerObject, options: boolean | AddEventListenerOptions) => void;
+  rel?: (el: EventTarget, eventName: string, listener: EventListenerOrEventListenerObject, options: boolean | AddEventListenerOptions) => void;
+  ce?: (eventName: string, opts?: any) => CustomEvent;
+}
+//#endregion
+//#region src/declarations/stencil-public-compiler.d.ts
+interface HydrateDocumentOptions {
+  /**
+   * Build ID that will be added to `<html data-stencil-build="BUILD_ID">`. By default
+   * a random ID will be generated
+   */
+  buildId?: string;
+  /**
+   * Sets the `href` attribute on the `<link rel="canonical">`
+   * tag within the `<head>`. If the value is not defined it will
+   * ensure a canonical link tag is no included in the `<head>`.
+   */
+  canonicalUrl?: string;
+  /**
+   * Include the HTML comments and attributes used by the client-side
+   * JavaScript to read the structure of the HTML and rebuild each
+   * component. Defaults to `true`.
+   */
+  clientHydrateAnnotations?: boolean;
+  /**
+   * Constrain `setTimeout()` to 1ms, but still async. Also
+   * only allows `setInterval()` to fire once, also constrained to 1ms.
+   * Defaults to `true`.
+   */
+  constrainTimeouts?: boolean;
+  /**
+   * Sets `document.cookie`
+   */
+  cookie?: string;
+  /**
+   * Sets the `dir` attribute on the top level `<html>`.
+   */
+  direction?: string;
+  /**
+   * Component tag names listed here will not be prerendered, nor will
+   * hydrated on the client-side. Components listed here will be ignored
+   * as custom elements and treated no differently than a `<div>`.
+   */
+  excludeComponents?: string[];
+  /**
+   * Sets the `lang` attribute on the top level `<html>`.
+   */
+  language?: string;
+  /**
+   * Maximum number of components to hydrate on one page. Defaults to `300`.
+   */
+  maxHydrateCount?: number;
+  /**
+   * Sets `document.referrer`
+   */
+  referrer?: string;
+  /**
+   * Removes every `<script>` element found in the `document`. Defaults to `false`.
+   */
+  removeScripts?: boolean;
+  /**
+   * Removes CSS not used by elements within the `document`. Defaults to `true`.
+   */
+  removeUnusedStyles?: boolean;
+  /**
+   * The url the runtime uses for the resources, such as the assets directory.
+   */
+  resourcesUrl?: string;
+  /**
+   * Prints out runtime console logs to the NodeJS process. Defaults to `false`.
+   */
+  runtimeLogging?: boolean;
+  /**
+   * Component tags listed here will only be prerendered or server-side-rendered
+   * and will not be client-side hydrated. This is useful for components that
+   * are not dynamic and do not need to be defined as a custom element within the
+   * browser. For example, a header or footer component would be a good example that
+   * may not require any client-side JavaScript.
+   */
+  staticComponents?: string[];
+  /**
+   * The amount of milliseconds to wait for a page to finish rendering until
+   * a timeout error is thrown. Defaults to `15000`.
+   */
+  timeout?: number;
+  /**
+   * Sets `document.title`.
+   */
+  title?: string;
+  /**
+   * Sets `location.href`
+   */
+  url?: string;
+  /**
+   * Sets `navigator.userAgent`
+   */
+  userAgent?: string;
+  /**
+   * Configure how Stencil serializes the components shadow root.
+   * - If set to `declarative-shadow-dom` the component will be rendered within a Declarative Shadow DOM.
+   * - If set to `scoped` Stencil will render the contents of the shadow root as a `scoped: true` component
+   *   and the shadow DOM will be created during client-side hydration.
+   * - Alternatively you can mix and match the two by providing an object with `declarative-shadow-dom` and `scoped` keys,
+   * the value arrays containing the tag names of the components that should be rendered in that mode.
+   *
+   * Examples:
+   * - `{ 'declarative-shadow-dom': ['my-component-1', 'another-component'], default: 'scoped' }`
+   * Render all components as `scoped` apart from `my-component-1` and `another-component`
+   * -  `{ 'scoped': ['an-option-component'], default: 'declarative-shadow-dom' }`
+   * Render all components within `declarative-shadow-dom` apart from `an-option-component`
+   * - `'scoped'` Render all components as `scoped`
+   * - `false` disables shadow root serialization
+   *
+   * *NOTE* `true` has been deprecated in favor of `declarative-shadow-dom` and `scoped`
+   * @default 'declarative-shadow-dom'
+   */
+  serializeShadowRoot?: 'declarative-shadow-dom' | 'scoped' | {
+    'declarative-shadow-dom'?: string[];
+    scoped?: string[];
+    default: 'declarative-shadow-dom' | 'scoped';
+  } | boolean;
+}
+interface SerializeDocumentOptions extends HydrateDocumentOptions {
+  /**
+   * Runs after the `document` has been hydrated.
+   */
+  afterHydrate?(document: any): any | Promise<any>;
+  /**
+   * Sets an approximate line width the HTML should attempt to stay within.
+   * Note that this is "approximate", in that HTML may often not be able
+   * to be split at an exact line width. Additionally, new lines created
+   * is where HTML naturally already has whitespace, such as before an
+   * attribute or spaces between words. Defaults to `100`.
+   */
+  approximateLineWidth?: number;
+  /**
+   * Runs before the `document` has been hydrated.
+   */
+  beforeHydrate?(document: any): any | Promise<any>;
+  /**
+   * Format the HTML in a nicely indented format.
+   * Defaults to `false`.
+   */
+  prettyHtml?: boolean;
+  /**
+   * Remove quotes from attribute values when possible.
+   * Defaults to `true`.
+   */
+  removeAttributeQuotes?: boolean;
+  /**
+   * Remove the `=""` from standardized `boolean` attributes,
+   * such as `hidden` or `checked`. Defaults to `true`.
+   */
+  removeBooleanAttributeQuotes?: boolean;
+  /**
+   * Remove these standardized attributes when their value is empty:
+   * `class`, `dir`, `id`, `lang`, and `name`, `title`. Defaults to `true`.
+   */
+  removeEmptyAttributes?: boolean;
+  /**
+   * Remove HTML comments. Defaults to `true`.
+   */
+  removeHtmlComments?: boolean;
+  /**
+   * The `fullDocument` flag determines the format of the rendered output. Set it to true to
+   * generate a complete HTML document, or false to render only the component.
+   * @default true
+   */
+  fullDocument?: boolean;
+  /**
+   * Style modes to render the component in.
+   * @see https://stenciljs.com/docs/styling#style-modes
+   */
+  modes?: ResolutionHandler[];
+}
+interface HydrateFactoryOptions extends SerializeDocumentOptions {
+  serializeToHtml: boolean;
+  destroyWindow: boolean;
+  destroyDocument: boolean;
+}
+//#endregion
+//#region src/declarations/stencil-private.d.ts
+interface ComponentConstructor {
+  is?: string;
+  properties?: ComponentConstructorProperties;
+  watchers?: ComponentConstructorChangeHandlers;
+  events?: ComponentConstructorEvent[];
+  listeners?: ComponentConstructorListener[];
+  style?: string;
+  styleId?: string;
+  encapsulation?: ComponentConstructorEncapsulation;
+  observedAttributes?: string[];
+  cmpMeta?: ComponentRuntimeMeta;
+  isProxied?: boolean;
+  isStyleRegistered?: boolean;
+  serializers?: ComponentConstructorChangeHandlers;
+  deserializers?: ComponentConstructorChangeHandlers;
+}
+/**
+ * A mapping from class member names to a list of methods which are watching
+ * them.
+ */
+interface ComponentConstructorChangeHandlers {
+  [propName: string]: {
+    [methodName: string]: number;
+  }[];
+}
+type ComponentConstructorEncapsulation = 'shadow' | 'scoped' | 'none';
+interface ComponentConstructorProperties {
+  [propName: string]: ComponentConstructorProperty;
+}
+interface ComponentConstructorProperty {
+  attribute?: string;
+  elementRef?: boolean;
+  method?: boolean;
+  mutable?: boolean;
+  reflect?: boolean;
+  state?: boolean;
+  type?: ComponentConstructorPropertyType;
+  watchCallbacks?: string[];
+}
+type ComponentConstructorPropertyType = StringConstructor | BooleanConstructor | NumberConstructor | 'string' | 'boolean' | 'number';
+interface ComponentConstructorEvent {
+  name: string;
+  method: string;
+  bubbles: boolean;
+  cancelable: boolean;
+  composed: boolean;
+}
+interface ComponentConstructorListener {
+  name: string;
+  method: string;
+  capture?: boolean;
+  passive?: boolean;
+}
+/**
+ * An interface extending `HTMLElement` which describes the fields added onto
+ * host HTML elements by the Stencil runtime.
+ */
+interface HostElement extends HTMLElement {
+  connectedCallback?: () => void;
+  attributeChangedCallback?: (attribName: string, oldVal: string, newVal: string, namespace: string) => void;
+  disconnectedCallback?: () => void;
+  host?: Element;
+  forceUpdate?: () => void;
+  __stencil__getHostRef?: () => HostRef;
+  /**
+   * Unique stencil id for this element
+   */
+  ['s-id']?: string;
+  /**
+   * Content Reference:
+   * Reference to the HTML Comment that's placed inside of the
+   * host element's original content. This comment is used to
+   * always represent where host element's light dom is.
+   */
+  ['s-cr']?: RenderNode;
+  /**
+   * Lifecycle ready
+   */
+  ['s-lr']?: boolean;
+  /**
+   * A reference to the `ElementInternals` object for the current host
+   *
+   * This is used for maintaining a reference to the object between HMR
+   * refreshes in the lazy build.
+   *
+   * "stencil-element-internals"
+   */
+  ['s-ei']?: ElementInternals;
+  /**
+   * On Render Callbacks:
+   * Array of callbacks to fire off after it has rendered.
+   */
+  ['s-rc']?: (() => void)[];
+  /**
+   * Scope Id
+   * The scope id of this component when using scoped css encapsulation
+   * or using shadow dom but the browser doesn't support it
+   */
+  ['s-sc']?: string;
+  /**
+   * Scope Ids
+   * All the possible scope ids of this component when using scoped css encapsulation
+   * or using shadow dom but the browser doesn't support it
+   */
+  ['s-scs']?: string[];
+  /**
+   * Hot Module Replacement, dev mode only
+   *
+   * This function should be defined by the HMR-supporting runtime and should
+   * do the work of actually updating the component in-place.
+   */
+  ['s-hmr']?: (versionId: string) => void;
+  /**
+   * A list of nested nested hydration promises that
+   * must be resolved for the top, ancestor component to be fully hydrated
+   */
+  ['s-p']?: Promise<void>[];
+  componentOnReady?: () => Promise<this>;
+}
+/**
+ * Generic node that represents all of the
+ * different types of nodes we'd see when rendering
+ */
+interface RenderNode extends HostElement {
+  /**
+   * Shadow root's host
+   */
+  host?: Element;
+  /**
+   * On Ref Function:
+   * Callback function to be called when the slotted node ref is ready.
+   */
+  ['s-rf']?: (elm: Element) => unknown;
+  /**
+   * Is initially hidden
+   * Whether this node was originally rendered with the `hidden` attribute.
+   *
+   * Used to reset the `hidden` state of a node during slot relocation.
+   */
+  ['s-ih']?: boolean;
+  /**
+   * Is Content Reference Node:
+   * This node is a content reference node.
+   */
+  ['s-cn']?: boolean;
+  /**
+   * Is a `slot` node when `shadow: false` (or `scoped: true`).
+   *
+   * This is a node (either empty text-node or `<slot-fb>` element)
+   * that represents where a `<slot>` is located in the original JSX.
+   */
+  ['s-sr']?: boolean;
+  /**
+   * Slot name of either the slot itself or the slotted node
+   */
+  ['s-sn']?: string;
+  /**
+   * Host element tag name:
+   * The tag name of the host element that this
+   * node was created in.
+   */
+  ['s-hn']?: string;
+  /**
+   * Slot host tag name:
+   * This is the tag name of the element where this node
+   * has been moved to during slot relocation.
+   *
+   * This allows us to check if the node has been moved and prevent
+   * us from thinking a node _should_ be moved when it may already be in
+   * its final destination.
+   *
+   * This value is set to `undefined` whenever the node is put back into its original location.
+   */
+  ['s-sh']?: string;
+  /**
+   * Original Location Reference:
+   * A reference pointing to the comment
+   * which represents the original location
+   * before it was moved to its slot.
+   */
+  ['s-ol']?: RenderNode;
+  /**
+   * Node reference:
+   * This is a reference from an original location node
+   * back to the node that's been moved around.
+   */
+  ['s-nr']?: PatchedSlotNode | RenderNode;
+  /**
+   * Original Order:
+   * During SSR; a number representing the order of a slotted node
+   */
+  ['s-oo']?: number;
+  /**
+   * Scope Id
+   */
+  ['s-si']?: string;
+  /**
+   * Host Id (hydrate only)
+   */
+  ['s-host-id']?: number;
+  /**
+   * Node Id (hydrate only)
+   */
+  ['s-node-id']?: number;
+  /**
+   * Used to know the components encapsulation.
+   * empty "" for shadow, "c" from scoped
+   */
+  ['s-en']?: '' | /*shadow*/'c';
+  /**
+   * On a `scoped: true` component
+   * with `experimentalSlotFixes` flag enabled,
+   * returns the internal `childNodes` of the component
+   */
+  readonly __childNodes?: NodeListOf<ChildNode>;
+  /**
+   * On a `scoped: true` component
+   * with `experimentalSlotFixes` flag enabled,
+   * returns the internal `children` of the component
+   */
+  readonly __children?: HTMLCollectionOf<Element>;
+  /**
+   * On a `scoped: true` component
+   * with `experimentalSlotFixes` flag enabled,
+   * returns the internal `firstChild` of the component
+   */
+  readonly __firstChild?: ChildNode;
+  /**
+   * On a `scoped: true` component
+   * with `experimentalSlotFixes` flag enabled,
+   * returns the internal `lastChild` of the component
+   */
+  readonly __lastChild?: ChildNode;
+  /**
+   * On a `scoped: true` component
+   * with `experimentalSlotFixes` flag enabled,
+   * returns the internal `textContent` of the component
+   */
+  __textContent?: string;
+  /**
+   * On a `scoped: true` component
+   * with `experimentalSlotFixes` flag enabled,
+   * gives access to the original `append` method
+   */
+  __append?: (...nodes: (Node | string)[]) => void;
+  /**
+   * On a `scoped: true` component
+   * with `experimentalSlotFixes` flag enabled,
+   * gives access to the original `prepend` method
+   */
+  __prepend?: (...nodes: (Node | string)[]) => void;
+  /**
+   * On a `scoped: true` component
+   * with `experimentalSlotFixes` flag enabled,
+   * gives access to the original `appendChild` method
+   */
+  __appendChild?: <T extends Node>(newChild: T) => T;
+  /**
+   * On a `scoped: true` component
+   * with `experimentalSlotFixes` flag enabled,
+   * gives access to the original `insertBefore` method
+   */
+  __insertBefore?: <T extends Node>(node: T, child: Node | null) => T;
+  /**
+   * On a `scoped: true` component
+   * with `experimentalSlotFixes` flag enabled,
+   * gives access to the original `removeChild` method
+   */
+  __removeChild?: <T extends Node>(child: T) => T;
+}
+interface PatchedSlotNode extends Node {
+  /**
+   * Slot name
+   */
+  ['s-sn']?: string;
+  /**
+   * Original Location Reference:
+   * A reference pointing to the comment
+   * which represents the original location
+   * before it was moved to its slot.
+   */
+  ['s-ol']?: RenderNode;
+  /**
+   * Slot host tag name:
+   * This is the tag name of the element where this node
+   * has been moved to during slot relocation.
+   *
+   * This allows us to check if the node has been moved and prevent
+   * us from thinking a node _should_ be moved when it may already be in
+   * its final destination.
+   *
+   * This value is set to `undefined` whenever the node is put back into its original location.
+   */
+  ['s-sh']?: string;
+  /**
+   * Is a `slot` node when `shadow: false` (or `scoped: true`).
+   *
+   * This is a node (either empty text-node or `<slot-fb>` element)
+   * that represents where a `<slot>` is located in the original JSX.
+   */
+  ['s-sr']?: boolean;
+  /**
+   * On a `scoped: true` component
+   * with `experimentalSlotFixes` flag enabled,
+   * returns the actual `parentNode` of the component
+   */
+  __parentNode?: RenderNode;
+  /**
+   * On a `scoped: true` component
+   * with `experimentalSlotFixes` flag enabled,
+   * returns the actual `nextSibling` of the component
+   */
+  __nextSibling?: RenderNode;
+  /**
+   * On a `scoped: true` component
+   * with `experimentalSlotFixes` flag enabled,
+   * returns the actual `previousSibling` of the component
+   */
+  __previousSibling?: RenderNode;
+  /**
+   * On a `scoped: true` component
+   * with `experimentalSlotFixes` flag enabled,
+   * returns the actual `nextElementSibling` of the component
+   */
+  __nextElementSibling?: RenderNode;
+  /**
+   * On a `scoped: true` component
+   * with `experimentalSlotFixes` flag enabled,
+   * returns the actual `nextElementSibling` of the component
+   */
+  __previousElementSibling?: RenderNode;
+}
+type LazyBundlesRuntimeData = LazyBundleRuntimeData[];
+type LazyBundleRuntimeData = [/** bundleIds */string, ComponentRuntimeMetaCompact[]];
+type ComponentRuntimeMetaCompact = [/** flags */number, /** tagname */string, /** members */{
+  [memberName: string]: ComponentRuntimeMember;
+}?, /** listeners */ComponentRuntimeHostListener[]?, /** watchers */ComponentConstructorChangeHandlers?, /** serializers */ComponentConstructorChangeHandlers?, /** deserializers */ComponentConstructorChangeHandlers?];
+/**
+ * Runtime metadata for a Stencil component
+ */
+interface ComponentRuntimeMeta {
+  /**
+   * This number is used to hold a series of bitflags for various features we
+   * support on components. The flags which this value is intended to store are
+   * documented in the `CMP_FLAGS` enum.
+   */
+  $flags$: number;
+  /**
+   * Just what it says on the tin - the tag name for the component, as set in
+   * the `@Component` decorator.
+   */
+  $tagName$: string;
+  /**
+   * A map of the component's members, which could include fields decorated
+   * with `@Prop`, `@State`, etc as well as methods.
+   */
+  $members$?: ComponentRuntimeMembers;
+  /**
+   * Information about listeners on the component.
+   */
+  $listeners$?: ComponentRuntimeHostListener[];
+  /**
+   * Tuples containing information about `@Prop` fields on the component which
+   * are set to be reflected (i.e. kept in sync) as HTML attributes when
+   * updated.
+   */
+  $attrsToReflect$?: ComponentRuntimeReflectingAttr[];
+  /**
+   * Information about which class members have watchers attached on the component.
+   */
+  $watchers$?: ComponentConstructorChangeHandlers;
+  /**
+   * A bundle ID used for lazy loading.
+   */
+  $lazyBundleId$?: string;
+  /**
+   * Information about which class members have prop > attribute serializers attached on the component.
+   */
+  $serializers$?: ComponentConstructorChangeHandlers;
+  /**
+   * Information about which class members have attribute > prop deserializers attached on the component.
+   */
+  $deserializers$?: ComponentConstructorChangeHandlers;
+}
+/**
+ * A mapping of the names of members on the component to some runtime-specific
+ * information about them.
+ */
+interface ComponentRuntimeMembers {
+  [memberName: string]: ComponentRuntimeMember;
+}
+/**
+ * A tuple with information about a class member that's relevant at runtime.
+ * The fields are:
+ *
+ * 1. A number used to hold bitflags for component members. The bit flags which
+ * this is intended to store are documented in the `MEMBER_FLAGS` enum.
+ * 2. The attribute name to observe.
+ */
+type ComponentRuntimeMember = [number, string?];
+/**
+ * A tuple holding information about a host listener which is relevant at
+ * runtime. The field are:
+ *
+ * 1. A number used to hold bitflags for listeners. The bit flags which this is
+ * intended to store are documented in the `LISTENER_FLAGS` enum.
+ * 2. The event name.
+ * 3. The method name.
+ */
+type ComponentRuntimeHostListener = [number, string, string];
+/**
+ * A tuple containing information about props which are "reflected" at runtime,
+ * meaning that HTML attributes on the component instance are kept in sync with
+ * the prop value.
+ *
+ * The fields are:
+ *
+ * 1. the prop name
+ * 2. the prop attribute.
+ */
+type ComponentRuntimeReflectingAttr = [string, string | undefined];
+/**
+ * A runtime component reference, consistent of either a host element _or_ an
+ * empty object. This is used in particular in a few different places as the
+ * keys in a `WeakMap` which maps {@link HostElement} instances to their
+ * associated {@link HostRef} instance.
+ */
+type RuntimeRef = HostElement | {
+  __stencil__getHostRef?: () => HostRef;
+};
+/**
+ * Interface used to track an Element, it's virtual Node (`VNode`), and other data
+ */
+interface HostRef {
+  $ancestorComponent$?: HostElement;
+  $flags$: number;
+  $cmpMeta$: ComponentRuntimeMeta;
+  $hostElement$: HostElement;
+  $instanceValues$?: Map<string, any>;
+  $serializerValues$?: Map<string, string>;
+  $lazyInstance$?: ComponentInterface;
+  /**
+   * A list of callback functions called immediately after a lazy component module has been fetched.
+   */
+  $fetchedCbList$?: ((elm: HostElement) => void)[];
+  /**
+   * A promise that gets resolved if `BUILD.asyncLoading` is enabled and after the `componentDidLoad`
+   * and before the `componentDidUpdate` lifecycle events are triggered.
+   */
+  $onReadyPromise$?: Promise<HostElement>;
+  /**
+   * A callback which resolves {@link HostRef.$onReadyPromise$}
+   * @param elm host element
+   */
+  $onReadyResolve$?: (elm: HostElement) => void;
+  /**
+   * A promise which resolves with the host component once it has finished rendering
+   * for the first time. This is primarily used to wait for the first `update` to be
+   * called on a component.
+   */
+  $onInstancePromise$?: Promise<HostElement>;
+  /**
+   * A callback which resolves {@link HostRef.$onInstancePromise$}
+   * @param elm host element
+   */
+  $onInstanceResolve$?: (elm: HostElement) => void;
+  /**
+   * A promise which resolves when the component has finished rendering for the first time.
+   * It is called after {@link HostRef.$onInstancePromise$} resolves.
+   */
+  $onRenderResolve$?: () => void;
+  $vnode$?: VNode;
+  $queuedListeners$?: [string, any][];
+  $rmListeners$?: (() => void)[];
+  $modeName$?: string;
+  $renderCount$?: number;
+  /**
+   * Defer connectedCallback until after first render for components with slot relocation.
+   */
+  $deferredConnectedCallback$?: boolean;
+}
+interface PlatformRuntime {
+  /**
+   * This number is used to hold a series of bitflags for various features we
+   * support within the runtime. The flags which this value is intended to store are
+   * documented in the {@link PLATFORM_FLAGS} enum.
+   */
+  $flags$: number;
+  /**
+   * Holds a map of nodes to be hydrated.
+   */
+  $orgLocNodes$?: Map<string, RenderNode>;
+  /**
+   * Holds the resource url for given platform environment.
+   */
+  $resourcesUrl$: string;
+  /**
+   * The nonce value to be applied to all script/style tags at runtime.
+   * If `null`, the nonce attribute will not be applied.
+   */
+  $nonce$?: string | null;
+  /**
+   * A utility function that executes a given function and returns the result.
+   * @param c The callback function to execute
+   */
+  jmp: (c: Function) => any;
+  /**
+   * A wrapper for {@link https://developer.mozilla.org/en-US/docs/Web/API/Window/requestAnimationFrame `requestAnimationFrame`}
+   */
+  raf: (c: FrameRequestCallback) => number;
+  /**
+   * A wrapper for {@link https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener `addEventListener`}
+   */
+  ael: (el: EventTarget, eventName: string, listener: EventListenerOrEventListenerObject, options: boolean | AddEventListenerOptions) => void;
+  /**
+   * A wrapper for {@link https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/removeEventListener `removeEventListener`}
+   */
+  rel: (el: EventTarget, eventName: string, listener: EventListenerOrEventListenerObject, options: boolean | AddEventListenerOptions) => void;
+  /**
+   * A wrapper for creating a {@link https://developer.mozilla.org/docs/Web/API/CustomEvent `CustomEvent`}
+   */
+  ce: (eventName: string, opts?: any) => CustomEvent;
+}
+type StyleMap = Map<string, CSSStyleSheet | string>;
+type ChildType = VNode | number | string;
+//#endregion
+//#region src/client/client-build.d.ts
+declare const Build: UserBuildConditionals;
+//#endregion
+//#region src/client/client-decorators.d.ts
+/**
+ * Runtime stubs for Stencil decorators.
+ *
+ * These decorators are compile-time metadata flags that Stencil's compiler parses
+ * and transforms. At runtime, they do nothing - the actual component behavior is
+ * wired up by the compiled output, not by these decorators.
+ *
+ * These stubs exist so that:
+ * 1. Component classes can be instantiated directly in tests without going through
+ *    Stencil's full compilation pipeline
+ * 2. The decorators don't throw "X is not a function" errors when used outside
+ *    of Stencil's build process
+ */
+/**
+ * No-op class decorator stub for @Component()
+ * @param _opts - component options (ignored at runtime)
+ * @returns a class decorator that returns the target unchanged
+ */
+declare const Component: (_opts?: any) => ClassDecorator;
+/**
+ * No-op property decorator stub for @Element()
+ * @returns a property decorator that does nothing
+ */
+declare const Element$1: () => PropertyDecorator;
+/**
+ * No-op property decorator stub for @Event()
+ * @param _opts - event options (ignored at runtime)
+ * @returns a property decorator that does nothing
+ */
+declare const Event: (_opts?: any) => PropertyDecorator;
+/**
+ * No-op property decorator stub for @AttachInternals()
+ * @param _opts - attach internals options (ignored at runtime)
+ * @returns a property decorator that does nothing
+ */
+declare const AttachInternals: (_opts?: any) => PropertyDecorator;
+/**
+ * No-op method decorator stub for @Listen()
+ * @param _eventName - event name to listen for (ignored at runtime)
+ * @param _opts - listen options (ignored at runtime)
+ * @returns a method decorator that does nothing
+ */
+declare const Listen: (_eventName: string, _opts?: any) => MethodDecorator;
+/**
+ * No-op method decorator stub for @Method()
+ * @param _opts - method options (ignored at runtime)
+ * @returns a method decorator that does nothing
+ */
+declare const Method: (_opts?: any) => MethodDecorator;
+/**
+ * No-op property decorator stub for @Prop()
+ * @param _opts - prop options (ignored at runtime)
+ * @returns a property decorator that does nothing
+ */
+declare const Prop: (_opts?: any) => PropertyDecorator;
+/**
+ * No-op property decorator stub for @State()
+ * @returns a property decorator that does nothing
+ */
+declare const State: () => PropertyDecorator;
+/**
+ * No-op method decorator stub for @Watch()
+ * @param _propName - property name to watch (ignored at runtime)
+ * @param _opts - watch options (ignored at runtime)
+ * @returns a method decorator that does nothing
+ */
+declare const Watch: (_propName: any, _opts?: any) => MethodDecorator;
+/**
+ * No-op method decorator stub for @PropSerialize()
+ * @param _propName - property name to serialize (ignored at runtime)
+ * @returns a method decorator that does nothing
+ */
+declare const PropSerialize: (_propName: any) => MethodDecorator;
+/**
+ * No-op method decorator stub for @AttrDeserialize()
+ * @param _propName - property name to deserialize (ignored at runtime)
+ * @returns a method decorator that does nothing
+ */
+declare const AttrDeserialize: (_propName: any) => MethodDecorator;
+/**
+ * No-op compile-time utility stub for resolveVar()
+ * At runtime, this just returns the string representation of whatever is passed in.
+ * @param variable - the variable to resolve
+ * @returns the string representation of the variable
+ */
+declare const resolveVar: <T>(variable: T) => string;
+//#endregion
+//#region src/client/client-host-ref.d.ts
+/**
+ * Given a {@link d.RuntimeRef} retrieve the corresponding {@link d.HostRef}
+ *
+ * @param ref the runtime ref of interest
+ * @returns the Host reference (if found) or undefined
+ */
+declare const getHostRef: (ref: RuntimeRef) => HostRef | undefined;
+/**
+ * Register a lazy instance with the {@link hostRefs} object so it's
+ * corresponding {@link d.HostRef} can be retrieved later.
+ *
+ * @param lazyInstance the lazy instance of interest
+ * @param hostRef that instances `HostRef` object
+ */
+declare const registerInstance: (lazyInstance: any, hostRef: HostRef) => void;
+/**
+ * Register a host element for a Stencil component, setting up various metadata
+ * and callbacks based on {@link BUILD} flags as well as the component's runtime
+ * metadata.
+ *
+ * @param hostElement the host element to register
+ * @param cmpMeta runtime metadata for that component
+ * @returns a reference to the host ref WeakMap
+ */
+declare const registerHost: (hostElement: HostElement, cmpMeta: ComponentRuntimeMeta) => HostRef;
+declare const isMemberInElement: (elm: any, memberName: string) => boolean;
+//#endregion
+//#region src/client/client-load-module.d.ts
+declare const cmpModules: Map<string, {
+  [exportName: string]: ComponentConstructor;
+}>;
+declare const loadModule: (cmpMeta: ComponentRuntimeMeta, hostRef: HostRef, hmrVersionId?: string) => Promise<ComponentConstructor | undefined> | ComponentConstructor | undefined;
+//#endregion
+//#region src/client/client-log.d.ts
+declare const consoleError: ErrorHandler;
+declare const STENCIL_DEV_MODE: string[];
+declare const consoleDevError: (...m: any[]) => void;
+declare const consoleDevWarn: (...m: any[]) => void;
+declare const consoleDevInfo: (...m: any[]) => void;
+declare const setErrorHandler: (handler: ErrorHandler) => ErrorHandler;
+//#endregion
+//#region src/client/client-style.d.ts
+declare const styles: StyleMap;
+declare const modeResolutionChain: ResolutionHandler[];
+declare const setScopedSSR: (_opts: HydrateFactoryOptions) => void;
+declare const needsScopedSSR: () => boolean;
+//#endregion
+//#region src/client/client-task-queue.d.ts
+declare const nextTick: (cb: () => void) => Promise<void>;
+declare const readTask: (cb: RafCallback) => void;
+declare const writeTask: (cb: RafCallback) => void;
+//#endregion
+//#region src/client/client-window.d.ts
+interface StencilWindow extends Omit<Window, 'document'> {
+  document?: Document;
+}
+declare const win: StencilWindow;
+declare const H: HTMLElement;
+declare const plt: PlatformRuntime;
+declare const setPlatformHelpers: (helpers: {
+  jmp?: (c: any) => any;
+  raf?: (c: any) => number;
+  ael?: (el: any, eventName: string, listener: any, options: any) => void;
+  rel?: (el: any, eventName: string, listener: any, options: any) => void;
+  ce?: (eventName: string, opts?: any) => any;
+}) => void;
+declare const supportsShadow: boolean;
+declare const supportsListenerOptions: boolean;
+declare const promiseResolve: (v?: any) => Promise<any>;
+declare const supportsConstructableStylesheets: boolean;
+declare const supportsMutableAdoptedStyleSheets: boolean;
+//#endregion
+//#region src/runtime/asset-path.d.ts
+declare const getAssetPath: (path: string) => string;
+declare const setAssetPath: (path: string) => string;
+//#endregion
+//#region src/runtime/bootstrap-custom-element.d.ts
+declare const defineCustomElement: (Cstr: any, compactMeta: ComponentRuntimeMetaCompact) => void;
+declare const proxyCustomElement: (Cstr: any, compactMeta: ComponentRuntimeMetaCompact) => any;
+declare const forceModeUpdate: (elm: RenderNode) => void;
+//#endregion
+//#region src/runtime/bootstrap-lazy.d.ts
+declare const bootstrapLazy: (lazyBundles: LazyBundlesRuntimeData, options?: CustomElementsDefineOptions) => void;
+//#endregion
+//#region src/runtime/connected-callback.d.ts
+declare const connectedCallback: (elm: HostElement) => void;
+//#endregion
+//#region src/runtime/disconnected-callback.d.ts
+declare const disconnectedCallback: (elm: HostElement) => Promise<void>;
+//#endregion
+//#region src/runtime/element.d.ts
+declare const getElement: (ref: any) => HostElement;
+//#endregion
+//#region src/runtime/event-emitter.d.ts
+declare const createEvent: (ref: RuntimeRef, name: string, flags: number) => {
+  emit: (detail: any) => CustomEvent<any>;
+};
+//#endregion
+//#region src/runtime/fragment.d.ts
+declare const Fragment: FunctionalComponent;
+//#endregion
+//#region src/runtime/host-listener.d.ts
+declare const addHostEventListeners: (elm: HostElement, hostRef: HostRef, listeners?: ComponentRuntimeHostListener[], attachParentListeners?: boolean) => void;
+//#endregion
+//#region src/runtime/mixin.d.ts
+type Ctor<T = {}> = new (...args: any[]) => T;
+declare function Mixin(...mixins: ((base: Ctor) => Ctor)[]): Ctor<{}>;
+//#endregion
+//#region src/runtime/mode.d.ts
+declare const setMode: (handler: ResolutionHandler) => number;
+declare const getMode: (ref: RuntimeRef) => string;
+//#endregion
+//#region src/runtime/nonce.d.ts
+/**
+ * Assigns the given value to the nonce property on the runtime platform object.
+ * During runtime, this value is used to set the nonce attribute on all dynamically created script and style tags.
+ * @param nonce The value to be assigned to the platform nonce property.
+ * @returns void
+ */
+declare const setNonce: (nonce: string) => string;
+//#endregion
+//#region src/runtime/parse-property-value.d.ts
+/**
+ * Parse a new property value for a given property type.
+ *
+ * While the prop value can reasonably be expected to be of `any` type as far as TypeScript's type checker is concerned,
+ * it is not safe to assume that the string returned by evaluating `typeof propValue` matches:
+ *   1. `any`, the type given to `propValue` in the function signature
+ *   2. the type stored from `propType`.
+ *
+ * This function provides the capability to parse/coerce a property's value to potentially any other JavaScript type.
+ *
+ * Property values represented in TSX preserve their type information. In the example below, the number 0 is passed to
+ * a component. This `propValue` will preserve its type information (`typeof propValue === 'number'`). Note that is
+ * based on the type of the value being passed in, not the type declared of the class member decorated with `@Prop`.
+ * ```tsx
+ * <my-cmp prop-val={0}></my-cmp>
+ * ```
+ *
+ * HTML prop values on the other hand, will always a string
+ *
+ * @param propValue the new value to coerce to some type
+ * @param propType the type of the prop, expressed as a binary number
+ * @param isFormAssociated whether the component is form-associated (optional)
+ * @returns the parsed/coerced value
+ */
+declare const parsePropertyValue: (propValue: unknown, propType: number, isFormAssociated?: boolean) => any;
+//#endregion
+//#region src/runtime/platform-options.d.ts
+interface SetPlatformOptions {
+  raf?: (c: FrameRequestCallback) => number;
+  ael?: (el: EventTarget, eventName: string, listener: EventListenerOrEventListenerObject, options: boolean | AddEventListenerOptions) => void;
+  rel?: (el: EventTarget, eventName: string, listener: EventListenerOrEventListenerObject, options: boolean | AddEventListenerOptions) => void;
+  ce?: (eventName: string, opts?: any) => CustomEvent;
+}
+declare const setPlatformOptions: (opts: SetPlatformOptions) => PlatformRuntime & SetPlatformOptions;
+//#endregion
+//#region src/runtime/proxy-component.d.ts
+/**
+ * Attach a series of runtime constructs to a compiled Stencil component
+ * constructor, including getters and setters for the `@Prop` and `@State`
+ * decorators, callbacks for when attributes change, and so on.
+ *
+ * On a lazy loaded component, this is wired up to both the class instance
+ * and the element separately. A `hostRef` keeps the 2 in sync.
+ *
+ * On a traditional component, this is wired up to the element only.
+ *
+ * @param Cstr - the constructor for a component that we need to process
+ * @param cmpMeta - metadata collected previously about the component
+ * @param flags - a number used to store a series of bit flags
+ * @returns a reference to the same constructor passed in (but now mutated)
+ */
+declare const proxyComponent: (Cstr: ComponentConstructor, cmpMeta: ComponentRuntimeMeta, flags: number) => ComponentConstructor;
+//#endregion
+//#region src/runtime/render.d.ts
+/**
+ * Method to render a virtual DOM tree to a container element.
+ *
+ * @example
+ * ```tsx
+ * import { render } from '@stencil/core';
+ *
+ * const vnode = (
+ *   <div>
+ *     <h1>Hello, world!</h1>
+ *   </div>
+ * );
+ * render(vnode, document.body);
+ * ```
+ *
+ * @param vnode - The virtual DOM tree to render
+ * @param container - The container element to render the virtual DOM tree to
+ */
+declare function render(vnode: VNode, container: Element): void;
+//#endregion
+//#region src/runtime/runtime-constants.d.ts
+declare const HYDRATED_STYLE_ID = "sty-id";
+//#endregion
+//#region src/runtime/set-value.d.ts
+declare const getValue: (ref: RuntimeRef, propName: string) => any;
+declare const setValue: (ref: RuntimeRef, propName: string, newVal: any, cmpMeta: ComponentRuntimeMeta) => void;
+//#endregion
+//#region src/runtime/tag-transform.d.ts
+/**
+ * Transforms a tag name using the current tag transformer
+ * @param tag - the tag to transform e.g. `my-tag`
+ * @returns the transformed tag e.g. `new-my-tag`
+ */
+declare function transformTag<T extends string>(tag: T): T;
+/**
+ * Sets the tag transformer to be used when rendering custom elements
+ * @param transformer the transformer function to use. Must return a string
+ */
+declare function setTagTransformer(transformer: TagTransformer): void;
+//#endregion
+//#region src/runtime/update-component.d.ts
+declare const getRenderingRef: () => any;
+declare const postUpdateComponent: (hostRef: HostRef) => void;
+declare const forceUpdate: (ref: any) => boolean;
+//#endregion
+//#region src/runtime/vdom/h.d.ts
+declare const h: (nodeName: any, vnodeData: any, ...children: ChildType[]) => VNode;
+declare const Host: {};
+//#endregion
+//#region src/runtime/vdom/jsx-runtime.d.ts
+/**
+ * JSX runtime function for creating elements in production mode.
+ * Called by TypeScript's jsx transform for elements without static children.
+ *
+ * @param type - The element type (string tag name or functional component)
+ * @param props - The element props (includes children)
+ * @param key - Optional key for the element
+ * @returns A virtual DOM node
+ */
+declare function jsx(type: any, props: any, key?: string): VNode;
+/**
+ * JSX runtime function for creating elements with static children.
+ * Called by TypeScript's jsx transform as an optimization when children are static.
+ *
+ * @param type - The element type (string tag name or functional component)
+ * @param props - The element props (includes children)
+ * @param key - Optional key for the element
+ * @returns A virtual DOM node
+ */
+declare function jsxs(type: any, props: any, key?: string): VNode;
+//#endregion
+//#region src/runtime/vdom/vdom-annotations.d.ts
+/**
+ * Updates the DOM generated on the server with annotations such as node attributes and
+ * comment nodes to facilitate future client-side hydration. These annotations are used for things
+ * like moving elements back to their original hosts if using Shadow DOM on the client, and for quickly
+ * reconstructing the vNode representations of the DOM.
+ *
+ * @param doc The DOM generated by the server.
+ * @param staticComponents Any components that should be considered static and do not need client-side hydration.
+ */
+declare const insertVdomAnnotations: (doc: Document, staticComponents: string[]) => void;
+//#endregion
+//#region src/runtime/vdom/vdom-render.d.ts
+/**
+ * The main entry point for Stencil's virtual DOM-based rendering engine
+ *
+ * Given a {@link d.HostRef} container and some virtual DOM nodes, this
+ * function will handle creating a virtual DOM tree with a single root, patching
+ * the current virtual DOM tree onto an old one (if any), dealing with slot
+ * relocation, and reflecting attributes.
+ *
+ * @param hostRef data needed to root and render the virtual DOM tree, such as
+ * the DOM node into which it should be rendered.
+ * @param renderFnResults the virtual DOM nodes to be rendered
+ * @param isInitialLoad whether or not this is the first call after page load
+ */
+declare const renderVdom: (hostRef: HostRef, renderFnResults: VNode | VNode[], isInitialLoad?: boolean) => void;
+//#endregion
+export { AttachInternals, AttrDeserialize, BUILD, Build, Component, Element$1 as Element, Env, Event, Fragment, H, H as HTMLElement, type HTMLStencilElement, HYDRATED_STYLE_ID, Host, type JSXBase, Listen, Method, Mixin, NAMESPACE, Prop, PropSerialize, STENCIL_DEV_MODE, State, Watch, addHostEventListeners, bootstrapLazy, cmpModules, connectedCallback, consoleDevError, consoleDevInfo, consoleDevWarn, consoleError, createEvent, defineCustomElement, disconnectedCallback, forceModeUpdate, forceUpdate, getAssetPath, getElement, getHostRef, getMode, getRenderingRef, getValue, h, insertVdomAnnotations, isMemberInElement, jsx, jsxs, loadModule, modeResolutionChain, needsScopedSSR, nextTick, parsePropertyValue, plt, postUpdateComponent, promiseResolve, proxyComponent, proxyCustomElement, readTask, registerHost, registerInstance, render, renderVdom, resolveVar, setAssetPath, setErrorHandler, setMode, setNonce, setPlatformHelpers, setPlatformOptions, setScopedSSR, setTagTransformer, setValue, styles, supportsConstructableStylesheets, supportsListenerOptions, supportsMutableAdoptedStyleSheets, supportsShadow, transformTag, win, writeTask };