@arcgis/lumina 5.2.0-next.4 → 5.2.0-next.41

package/dist/jsx/types.d.ts

@@ -1,33 +1,120 @@
-import { TemplateResult } from 'lit';
-import { DirectiveResult } from 'lit/directive.js';
-import { HTMLElementTags, HTMLAttributes, GlobalEventHandlersCamelCase, SvgElementTags, DOMAttributes, AriaAttributes } from './generatedTypes.ts';
-import { CustomAttributes } from './baseTypes.ts';
+import type { TemplateResult } from "lit";
+import type { DirectiveResult } from "lit/directive.js";
+import type { HTMLElementTags as HTMLElementTagsAlias, HTMLAttributes as HTMLAttributesAlias, GlobalEventHandlersCamelCase, SvgElementTags as SvgElementTagsAlias, DOMAttributes as DOMAttributesAlias, AriaAttributes as AriaAttributesAlias, HTMLAttributes } from "./generatedTypes.js";
+import type { CustomAttributes as CustomAttributesAlias } from "./baseTypes.js";
+
+
+
 /**
  * The "h" namespace is used to import JSX types for elements and attributes.
  * It is imported in order to avoid conflicting global JSX issues.
+ *
+ * @public
  */
 export declare namespace h {
-    export function h(sel: any, data?: any, text?: any): TemplateResult;
-    export type { LuminaJsx as JSX };
+  // TypeScript does not type-check the JSX function signature
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  export function h(sel: any, data?: any, text?: any): TemplateResult;
+
+  export type { LuminaJsx as JSX };
 }
+
+
+
 /**
- * The references to this function are removed at build time.
+ * These types are based on dom-expressions typed (used by Solid and Preact):
+ * https://github.com/ryansolid/dom-expressions/blob/main/packages/dom-expressions/src/jsx.d.ts
+ *
+ * They in turn are based on Surplus and Inferno:
+ * - https://github.com/adamhaile/surplus/blob/master/index.d.ts
+ * - https://github.com/infernojs/inferno/blob/master/packages/inferno/src/core/types.ts
+ *
+ * Documentation about how to type JSX in TypeScript:
+ * https://www.typescriptlang.org/docs/handbook/jsx.html
+ *
+ * @public
  */
-export declare const Fragment: (props: {
-    children?: JsxNode;
-}) => TemplateResult;
+export declare namespace LuminaJsx {
+  export type Element = TemplateResult;
+
+  export type ElementType = JsxNode;
+
+  /*
+   * Class-based components are not supported. All custom elements are to be
+   * invoked as <intrinsic-elements>.
+   */
+  // eslint-disable-next-line @typescript-eslint/no-empty-object-type
+  export interface ElementClass {}
+
+  // eslint-disable-next-line @typescript-eslint/no-empty-object-type
+  export interface ElementAttributesProperty {}
+
+  // eslint-disable-next-line @typescript-eslint/no-empty-object-type
+  export interface IntrinsicClassAttributes {}
+
+  export interface ElementChildrenAttribute {
+    children: JsxNode;
+  }
+
+  export interface IntrinsicAttributes {
+    /**
+     * The `key` is a special attribute that can be set on any element.
+     *
+     * At build-time it is translated into the `keyed()` directive:
+     * https://lit.dev/docs/templates/directives/#keyed
+     *
+     * @remarks
+     * Unlike in React or Stencil, any JavaScript value is acceptable as a key
+     */
+    key?: unknown;
+  }
+
+  export interface IntrinsicElements
+    extends
+      HTMLElementTags,
+      SvgElementTags,
+      ReMappedComponents<DeclareElements>,
+      ReMapStencilComponents<ImportStencilElements> {}
+
+  /** @deprecated import type { CustomAttributes } from "@arcgis/lumina/jsx/baseTypes"; instead  */
+  export interface CustomAttributes<T = HTMLElement> extends CustomAttributesAlias<T> {}
+  /** @deprecated import type { DOMAttributes } from "@arcgis/lumina/jsx/generatedTypes"; instead  */
+  export interface DOMAttributes<T = HTMLElement> extends DOMAttributesAlias<T> {}
+  /** @deprecated import type { HTMLAttributes } from "@arcgis/lumina/jsx/generatedTypes"; instead  */
+  export interface HTMLAttributes<T = HTMLElement> extends HTMLAttributesAlias<T> {}
+  /** @deprecated import type { HTMLElementTags } from "@arcgis/lumina/jsx/generatedTypes"; instead  */
+  export interface HTMLElementTags extends HTMLElementTagsAlias {}
+  /** @deprecated import type { SvgElementTags } from "@arcgis/lumina/jsx/generatedTypes"; instead  */
+  export interface SvgElementTags extends SvgElementTagsAlias {}
+  /** @deprecated import type { AriaAttributes } from "@arcgis/lumina/jsx/generatedTypes"; instead  */
+  export interface AriaAttributes extends AriaAttributesAlias {}
+}
+
+/** The references to this function are removed at build time. */
+export const Fragment: (props: { children?: JsxNode; }) => TemplateResult;
+
 /**
- * @private
  * The references to this function are removed at build time. You do not need
  * to import it directly
+ *
+ * @param type
+ * @param props
+ * @param key
+ * @internal
  */
-export declare function jsx(type: string, props: unknown, key?: unknown): JsxNode;
+export function jsx(type: string, props: unknown, key?: unknown): JsxNode;
+
 /**
- * @private
  * The references to this function are removed at build time. You do not need
  * to import it directly
+ *
+ * @param type
+ * @param props
+ * @param key
+ * @internal
  */
-export declare function jsxs(type: string, props: unknown, key?: unknown): JsxNode;
+export function jsxs(type: string, props: unknown, key?: unknown): JsxNode;
+
 /**
  * The JSX to lit-html conversion has a heuristic to determine whether a prop
  * should be converted to a property or attribute at runtime. In cases where
@@ -38,6 +125,10 @@ export declare function jsxs(type: string, props: unknown, key?: unknown): JsxNo
  * impact. But that also means you should not call this function anywhere other
  * than at the top level of a JSX prop value
  *
+ * If you often encounter cases where the JSX to lit-html incorrectly converts
+ * the prop to a property necessitating the use of `bindAttribute()`, please open
+ * an issue for Lumina.
+ *
  * @example
  * ```tsx
  * <my-component
@@ -49,13 +140,9 @@ export declare function jsxs(type: string, props: unknown, key?: unknown): JsxNo
  * ```ts
  * html`<my-component name="Pass name as attribute rather than property"></my-component>`
  * ```
- *
- * @remarks
- * If you often encounter cases where the JSX to lit-html incorrectly converts
- * the prop to a property necessitating the use of `bindAttribute()`, please open
- * an issue for Lumina.
  */
-export declare const bindAttribute: <T>(value: T) => T;
+export const bindAttribute: <T>(value: T) => T;
+
 /**
  * The JSX to lit-html conversion has a heuristic to determine whether a prop
  * should be converted to a property, attribute or boolean attribute at runtime.
@@ -67,8 +154,11 @@ export declare const bindAttribute: <T>(value: T) => T;
  * impact. But that also means you should not call this function anywhere other
  * than at the top level of a JSX prop value
  *
- * @see https://lit.dev/docs/templates/expressions/#boolean-attribute-expressions
+ * If you often encounter cases where the JSX to lit-html incorrectly converts
+ * the prop necessitating the use of `bindBooleanAttribute()`, please open
+ * an issue for Lumina.
  *
+ * @see https://lit.dev/docs/templates/expressions/#boolean-attribute-expressions
  * @example
  * ```tsx
  * <my-component
@@ -80,13 +170,9 @@ export declare const bindAttribute: <T>(value: T) => T;
  * ```ts
  * html`<my-component ?checked=${myBoolean}></my-component>`
  * ```
- *
- * @remarks
- * If you often encounter cases where the JSX to lit-html incorrectly converts
- * the prop necessitating the use of `bindBooleanAttribute()`, please open
- * an issue for Lumina.
  */
-export declare const bindBooleanAttribute: <T>(value: T) => T;
+export const bindBooleanAttribute: <T>(value: T) => T;
+
 /**
  * The JSX to lit-html conversion has a heuristic to determine whether a prop
  * should be converted to a property or attribute at runtime. In cases where
@@ -97,6 +183,10 @@ export declare const bindBooleanAttribute: <T>(value: T) => T;
  * impact. But that also means you should not call this function anywhere other
  * than at the top level of a JSX prop value
  *
+ * If you often encounter cases where the JSX to lit-html incorrectly converts
+ * the prop to an attribute necessitating the use of `bindProperty()`, please open
+ * an issue for Lumina.
+ *
  * @example
  * ```tsx
  * <my-component
@@ -108,17 +198,9 @@ export declare const bindBooleanAttribute: <T>(value: T) => T;
  * ```ts
  * html`<my-component .my-prop="Pass my-prop as a property rather than attribute"></my-component>`
  * ```
- *
- * @remarks
- * If you often encounter cases where the JSX to lit-html incorrectly converts
- * the prop to an attribute necessitating the use of `bindProperty()`, please open
- * an issue for Lumina.
- *
- * @remarks
- * This function is not named `property()` because that is already taken by
- * Lit's \@property() decorator
  */
-export declare const bindProperty: <T>(value: T) => T;
+export const bindProperty: <T>(value: T) => T;
+
 /**
  * The `bindEvent()` function lets you customize the event binding behavior by
  * providing options like passive, capture, once and other options that you
@@ -127,6 +209,10 @@ export declare const bindProperty: <T>(value: T) => T;
  * This function call will be erased at build-time, thus it has no runtime
  * impact.
  *
+ * This function is a _JSX to lit-html_ adaptation of the Lit's event listener
+ * customization syntax.
+ * See https://lit.dev/docs/components/events/#event-options-decorator
+ *
  * @example
  * ```tsx
  * <my-component
@@ -137,23 +223,13 @@ export declare const bindProperty: <T>(value: T) => T;
  * ```ts
  * html`<my-component onScroll=${{ handleEvent: console.log, passive:true }}></my-component>`
  * ```
- *
- * @remarks
- * This function is a _JSX to lit-html_ adaptation of the Lit's event listener
- * customization syntax.
- * See https://lit.dev/docs/components/events/#event-options-decorator
- *
- *
- * @remarks
- * This function is not named `event` because there is a legacy `window.event`
- * global that was interfering with auto-imports of this function.
  */
-export declare const bindEvent: <T>(descriptor: T | (AddEventListenerOptions & {
-    handleEvent: T;
-})) => T;
+export const bindEvent: <T>(descriptor: T | (AddEventListenerOptions & { handleEvent: T; })) => T;
+
 export type JsxNode = DirectiveResult<any> | JsxNodeArray | Node | TemplateResult | boolean | number | (NonNullable<unknown> & string) | null | undefined;
-interface JsxNodeArray extends Array<JsxNode> {
-}
+
+export interface JsxNodeArray extends Array<JsxNode> {}
+
 /**
  * By not requiring to have some sort of typings generation watcher to run
  * in the background and generate types for the components based on the
@@ -174,11 +250,10 @@ interface JsxNodeArray extends Array<JsxNode> {
  * information and can generate the typings that expose only the actual
  * properties component declared.
  *
- * @remarks
- * Do not exclude "manager" and "componentOnReady" since these properties are
- * available both on lazy and non-lazy instance.
+ * @internal
  */
-type ExcludedProperties = "addController" | "attributeChangedCallback" | "connectedCallback" | "disconnectedCallback" | "el" | "elementInternals" | "hasUpdated" | "isUpdatePending" | "listen" | "load" | "loaded" | "removeController" | "render" | "renderOptions" | "renderRoot" | "requestUpdate" | "updateComplete" | "updated" | "willUpdate";
+export type ExcludedProperties = "addController" | "attributeChangedCallback" | "connectedCallback" | "disconnectedCallback" | "el" | "elementInternals" | "hasUpdated" | "isUpdatePending" | "listen" | "load" | "loaded" | "removeController" | "render" | "renderOptions" | "renderRoot" | "requestUpdate" | "updateComplete" | "updated" | "willUpdate";
+
 /**
  * this.el property on a component only has the public properties of the
  * component. All internal methods, properties, as well as LitElement methods
@@ -189,12 +264,9 @@ type ExcludedProperties = "addController" | "attributeChangedCallback" | "connec
  * Usually, you don't need to use this type directly. If you have an
  * `ArcgisCounter` element, you can get its el type by using
  * `ArcgisCounter["el"]`
- *
- * @remarks
- * By using Omit<>, TypeScript also "forgets" all private members of the
- * passed in type, which is convenient for us.
  */
 export type ToElement<Component> = Omit<Component, ExcludedProperties>;
+
 /**
  * Utility type for getting the JSX prop types for a given component. In particular:
  *
@@ -211,29 +283,31 @@ export type ToElement<Component> = Omit<Component, ExcludedProperties>;
  * absence of decorator does not change the type). Thus, if we don't mark all
  * properties as optional, TypeScript will force us to provide a value for all
  * methods, and regular properties component may have.
+ *
+ * @internal
  */
-export type ToJsx<Component extends {
-    el: unknown;
-}> = HTMLAttributes<Component["el"]> & Partial<Omit<Component, ExcludedProperties | keyof HTMLElement | keyof RemapEvents<Component>>> & RemapEvents<Component>;
+export type ToJsx<Component extends { el: unknown; }> = HTMLAttributesAlias<Component["el"]>
+  & Partial<Omit<Component, ExcludedProperties | keyof HTMLElement | keyof RemapEvents<Component>>>
+  & RemapEvents<Component>;
+
 /**
  * From event emitters create event listener callbacks
+ *
+ * @internal
  */
-type RemapEvents<Component extends {
-    el: unknown;
-}> = {
-    [Key in keyof Component as `on${Key & string}`]?: unknown extends Component[Key] ? never : Component[Key] extends {
-        emit: (...rest: never[]) => infer PayloadType;
-    } ? (event: PayloadType & {
+export type RemapEvents<Component extends { el: unknown; }> = {
+    [Key in keyof Component as `on${Key & string}`]?: unknown extends Component[Key] ? never : Component[Key] extends { emit: (...rest: never[]) => infer PayloadType; } ? (event: PayloadType & {
         currentTarget: Component["el"];
         target: Component["el"];
     }) => void : never;
 };
+
 /**
  * This interface will be automatically extended in src/lumina.ts files to add
  * typings for Stencil elements usages in Lumina. You do not need to manually
  * extend this interface.
  *
- * @private
+ * @internal
  * @example
  * ```ts
  * import type { JSX as CalciteJSX } from "@esri/calcite-components/dist/types/components";
@@ -247,8 +321,8 @@ type RemapEvents<Component extends {
  * }
  * ```
  */
-export interface ImportStencilElements {
-}
+export interface ImportStencilElements {}
+
 /**
  * Get the type of all events for a given component. Includes native DOM events
  * and custom events.
@@ -263,132 +337,102 @@ export interface ImportStencilElements {
  *   // event.currentTarget
  * }
  * ```
- *
- * @remarks
- * This helper is intended to be used on components defined within the same
- * package. For external components, you can use
- * `HTMLArcgisMapElement["arcgisViewClick"]` directly, without need for
- * `ToEvents<>`.
- *
- * @remarks
- * Alternative implementation of this type that is simpler, and potentially
- * more performant, but looses "go to definition" information.
- *
- * ```tsx
- * export type ToEvents<Component extends { el: unknown }> = {
- *   [Key in keyof ToJsx<Component> as Key extends `on${infer EventName}`
- *     ? Uncapitalize<EventName>
- *     : never]-?: ListenerToPayloadType<ToJsx<Component>[Key]>;
- * };
- *
- * type ListenerToPayloadType<Listener> = Listener extends (event: infer EventType) => unknown ? EventType : never;
- * ```
- *
- * TypeScript issues that may fix this:
- * - https://github.com/microsoft/TypeScript/issues/49909
- * - https://github.com/microsoft/TypeScript/issues/50715
  */
-export type ToEvents<Component> = GlobalEventTypes<MaybeEl<Component>> & {
+export type ToEvents<Component> = GlobalEventTypes<MaybeEl<Component>>
+  & {
     [Key in keyof Component as ListenerToPayloadType<Component[Key]> extends BaseEvent ? Key : never]-?: ListenerToPayloadType<Component[Key]> & {
         currentTarget: MaybeEl<Component>;
         target: MaybeEl<Component>;
     };
 };
-type MaybeEl<Component> = Component extends {
-    el: unknown;
-} ? Component["el"] : Component;
+
+export type MaybeEl<Component> = Component extends { el: unknown; } ? Component["el"] : Component;
+
 export interface TargetedEvent<Target = EventTarget | null, Payload = void> extends BaseEvent {
-    /**
-     * Returns any custom data event was created with.
-     *
-     * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CustomEvent/detail)
-     */
-    readonly detail: Payload;
-    /**
-     * Returns the object whose event listener's callback is currently being invoked.
-     *
-     * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Event/currentTarget)
-     */
-    readonly currentTarget: Target;
-    /**
-     * Returns the object to which event is dispatched (its target).
-     *
-     * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Event/target)
-     */
-    readonly target: Target;
+  /**
+   * Returns any custom data event was created with.
+   *
+   * @see [MDN Reference](https://developer.mozilla.org/docs/Web/API/CustomEvent/detail)
+   */
+  readonly detail: Payload;
+  /**
+   * Returns the object whose event listener's callback is currently being invoked.
+   *
+   * @see [MDN Reference](https://developer.mozilla.org/docs/Web/API/Event/currentTarget)
+   */
+  readonly currentTarget: Target;
+  /**
+   * Returns the object to which event is dispatched (its target).
+   *
+   * @see [MDN Reference](https://developer.mozilla.org/docs/Web/API/Event/target)
+   */
+  readonly target: Target;
 }
-interface BaseEvent extends Omit<Event, "currentTarget" | "target"> {
-    /** @deprecated */
-    initCustomEvent(type: string, bubbles?: boolean, cancelable?: boolean, detail?: any): void;
+
+/** @internal */
+export interface BaseEvent extends Omit<Event, "currentTarget" | "target"> {
+  /**
+   * @deprecated Deprecated DOM method. Do not use.
+   * @param type
+   * @param bubbles
+   * @param cancelable
+   * @param detail
+   */
+  initCustomEvent(type: string, bubbles?: boolean, cancelable?: boolean, detail?: any): void;
 }
+
 /**
  * From "GlobalEventHandlersCamelCase" extract event names and their payloads.
  * Not using "HTMLElementEventMap" because that map has all events in lowercase.
+ *
+ * @internal
  */
-type GlobalEventTypes<Target = HTMLElement> = {
+export type GlobalEventTypes<Target = HTMLElement> = {
     [Key in keyof GlobalEventHandlersCamelCase<Target> as Key extends `on${infer EventName}` ? Uncapitalize<EventName> : never]-?: Parameters<NonNullable<GlobalEventHandlersCamelCase<Target>[Key]>>[0];
 };
-type ListenerToPayloadType<Listener> = unknown extends Listener ? void : Listener extends {
-    emit: (...rest: never[]) => infer PayloadType;
-} ? PayloadType : Listener extends BaseEvent ? Listener : void;
+
+/** @internal */
+export type ListenerToPayloadType<Listener> = unknown extends Listener ? void : Listener extends { emit: (...rest: never[]) => infer PayloadType; } ? PayloadType : Listener extends BaseEvent ? Listener : void;
+
 /**
  * Defined Lumina custom elements. This interface is used only for internal
  * type-checking.
  */
-export interface DeclareElements {
-}
-type ReMappedComponents<Components> = {
-    [Key in keyof Components]: Components[Key] extends {
-        el: unknown;
-    } ? ToJsx<Components[Key]> : never;
+export interface DeclareElements {}
+
+/** @internal */
+export type ReMappedComponents<Components> = {
+    [Key in keyof Components]: Components[Key] extends { el: unknown; } ? ToJsx<Components[Key]> : never;
 };
+
 /**
  * For common properties, add Lumina's types rather than use Stencil's types
+ *
+ * @internal
  */
-type ReMapStencilComponents<Components> = {
+export type ReMapStencilComponents<Components> = {
     [Key in keyof Pick<Components, keyof Components & keyof HTMLElementTagNameMap>]: HTMLAttributes<HTMLElementTagNameMap[Key]> & ReMapStencilComponent<Components[Key]>;
 };
-type ReMapStencilComponent<Component> = {
+
+/** @internal */
+export type ReMapStencilComponent<Component> = {
     [Key in keyof Component as FixupStencilEventCasing<Key>]: Component[Key];
 };
-type FixupStencilEventCasing<PropertyName extends PropertyKey> = PropertyName extends `on${infer EventName}` ? `on${Uncapitalize<EventName>}` : PropertyName;
+
 /**
- * These typings are based on dom-expressions typings:
- * https://github.com/ryansolid/dom-expressions/blob/main/packages/dom-expressions/src/jsx.d.ts
- *
- * They in turn based the typings on Surplus and Inferno:
- * - https://github.com/adamhaile/surplus/blob/master/index.d.ts
- * - https://github.com/infernojs/inferno/blob/master/packages/inferno/src/core/types.ts
+ * Uncapitalize the event properties to match the syntax of React 19, Preact and
+ * Lumina
  *
- * Documentation about how to type JSX in TypeScript:
- * https://www.typescriptlang.org/docs/handbook/jsx.html
+ * @internal
  */
-export declare namespace LuminaJsx {
-    export type Element = TemplateResult;
-    export type ElementType = JsxNode;
-    export interface ElementClass {
-    }
-    export interface ElementAttributesProperty {
-    }
-    export interface IntrinsicClassAttributes {
-    }
-    export interface ElementChildrenAttribute {
-        children: JsxNode;
-    }
-    export interface IntrinsicAttributes {
-        /**
-         * The `key` is a special attribute that can be set on any element.
-         *
-         * At build-time it is translated into the `keyed()` directive:
-         * https://lit.dev/docs/templates/directives/#keyed
-         *
-         * @remarks
-         * Unlike in React or Stencil, any JavaScript value is acceptable as a key
-         */
-        key?: unknown;
-    }
-    export interface IntrinsicElements extends HTMLElementTags, SvgElementTags, ReMappedComponents<DeclareElements>, ReMapStencilComponents<ImportStencilElements> {
-    }
-    export type { CustomAttributes, DOMAttributes, HTMLAttributes, HTMLElementTags, SvgElementTags, AriaAttributes };
-}
-export {};
+export type FixupStencilEventCasing<PropertyName extends PropertyKey> = PropertyName extends `on${infer EventName}` ? `on${Uncapitalize<EventName>}` : PropertyName;
+
+/** @internal */
+export type _TypeHelper<_ extends [
+    CustomAttributesAlias,
+    DOMAttributesAlias,
+    HTMLAttributesAlias,
+    HTMLElementTagsAlias,
+    SvgElementTagsAlias,
+    AriaAttributesAlias
+]> = void;

package/dist/jsx/utils.d.ts

@@ -6,32 +6,37 @@
  * value (which is interpreted by HTML as "true"). To tell Lit that you don't
  * want the attribute to be present, use the `nothing` value.
  *
- * @example
- * ```tsx
- * <a href={this.href ?? nothing}>{this.label}</a>
- * ```
- *
- * @remarks
  * This is not a concern for properties as they are passed as is without
  * serialization. For this reason, during _JSX to lit-html_ conversion, most JSX
  * props are converted properties, except for the few cases when an attribute
  * has no equivalent property.
+ *
+ * @example
+ * ```tsx
+ * <a href={this.href ?? nothing}>{this.label}</a>
+ * ```
  */
-export declare const nothing: never;
+export const nothing: never;
+
 /**
  * A sentinel value that signals that a value was handled by a directive and
  * should not be written to the DOM.
  *
- * @remarks
  * This is equivalent to Lit's native "noChange", but has type "never" to allow
  * it be set as a value for any JSX attribute.
  */
-export declare const noChange: never;
+export const noChange: never;
+
 /**
  * Like native element.setAttribute(), but instead of stringifying nullish
  * values, will call element.removeAttribute()
+ *
+ * @param element
+ * @param attributeName
+ * @param value
  */
-export declare function setAttribute(element: Element, attributeName: string, value: unknown): void;
+export function setAttribute(element: Element, attributeName: string, value: unknown): void;
+
 /**
  * If you have a property that can be both of string or boolean type, there is
  * no automatic boolean conversion in place - that means the attribute is
@@ -44,13 +49,13 @@ export declare function setAttribute(element: Element, attributeName: string, va
  * be either `null` or `""`). This matches the behavior in Stencil.
  *
  * ```tsx
- * @property({ reflects:true, converter: stringOrBoolean }) icon: string | boolean;
+ *
+ * @property({
+ * reflects:true, converter: stringOrBoolean }) icon: string | boolean;
  * // ...
  * this.icon = false;  // attribute is removed
  * this.icon = true;  // attribute is ""
  * this.icon = "name";  // attribute is "name"
  * ```
  */
-export declare const stringOrBoolean: {
-    toAttribute: (value: unknown) => string | null;
-};
+export const stringOrBoolean: { toAttribute: (value: string) => string | null; };