@daikin-oss/design-system-web-components 1.2.0 → 1.3.0

package/dist/cjs/components/time-picker/daikin-time-picker.d.cts

@@ -0,0 +1,165 @@
+import { PropertyValues } from 'lit';
+import { DDSFormElement } from "../../base/dds-form-element.cjs";
+import { default as DaikinInputGroup } from "../input-group/daikin-input-group.cjs";
+/**
+ * Represents the hour and minute parts of a time value.
+ * The `hour` and `minute` values can be placeholder strings ('hh', 'mm') or numeric strings representing time values.
+ */
+type TimeParts = {
+    hour: string;
+    minute: string;
+};
+/**
+ * Type for time input item: hour or minute.
+ */
+type TimeItem = "hour" | "minute";
+/**
+ * Converts a 12-hour time string and AM/PM to 24-hour format (e.g. "02:30", "PM" => "14:30").
+ */
+export declare function to24HourFormat(time: string, meridiem: "AM" | "PM"): string;
+/**
+ * Converts a 24-hour time string to 12-hour format and AM/PM (e.g. "14:30" => { time: "02:30", meridiem: "PM" }).
+ */
+export declare function from24HourFormat(time: string): {
+    time: string;
+    meridiem: "AM" | "PM";
+};
+/**
+ * Validates if a time string matches the 24-hour format.
+ */
+export declare function isValidValueTime(str: string): boolean;
+/**
+ * Checks if a time is out of the given range.
+ */
+export declare function isTimeOutOfRange(time: string, min: string, max: string): boolean;
+/**
+ * Formats a time object as a UI display string (HH:MM).
+ * The hour/minute values do not have to be valid.
+ */
+export declare function formatPartsForUI({ hour, minute, }: Readonly<TimeParts>): string;
+/**
+ * Parses a UI time string (HH:MM) and returns an hour/minute object.
+ * The result is not guaranteed to be valid.
+ */
+export declare function parsePartsFromUIValue(value: string): TimeParts;
+/**
+ * Attempts to parse a valid time string from a UI value (HH:MM).
+ * Returns null if invalid.
+ */
+export declare function tryParseTimeFromUIValue(value: string): string | null;
+/**
+ * Formats a valid time string as a UI display string (HH:MM).
+ */
+export declare function formatTimeForUI(timeString: string): string;
+/**
+ * Determines whether the current selection is on the hour or minute part.
+ * Returns null if no match.
+ */
+export declare function getTimeItemInSelection(selectionStart: number, selectionEnd: number): TimeItem | null;
+/**
+ * Calculate digit key input, returns new time parts and whether input is complete.
+ * @returns { parts, done } or null
+ */
+export declare function calcDigitInput(parts: Readonly<TimeParts>, item: TimeItem, digit: string, hourDigitIndex: number): {
+    parts: TimeParts;
+    done: boolean;
+} | null;
+/**
+ * The time picker provides a time input field and a dropdown button for selecting AM/PM, allowing users to quickly enter a specific time in 12-hour format.
+ * Please note that while the value displayed on the UI is in 12-hour format, the value you get from the component's value property will be automatically converted to 24-hour format.
+ *
+ * @fires change - A custom event emitted when the value of component changed. Validation errors will not trigger this event.
+ * @fires input - A retargeted event of a [input event](https://developer.mozilla.org/en-US/docs/Web/API/Element/input_event). Triggered when user type value to input area and change the value of component. change dropdown or validation errors will not trigger this event.
+ *
+ * @example
+ *
+ * ```js
+ * import "@daikin-oss/design-system-web-components/components/time-picker/index.js";
+ * ```
+ *
+ * ```html
+ * <daikin-time-picker></daikin-time-picker>
+ * ```
+ */
+export declare class DaikinTimePicker extends DDSFormElement {
+    static readonly styles: import('lit').CSSResult;
+    /**
+     * Placeholder text.
+     */
+    placeholder: string | null;
+    /**
+     * Minimum time (00:00 - 23:59). If the user's input value is less than this value, the component will display an error state.
+     * Please note that while the UI displays time in a 12-hour format (AM/PM), the component's value is stored in a 24-hour format. The `min` property must also be provided in 24-hour format.
+     */
+    min: string;
+    /**
+     * Maximum time (00:00 - 23:59). If the user's input value is more than this value, the component will display an error state.
+     * Please note that while the UI displays time in a 12-hour format (AM/PM), the component's value is stored in a 24-hour format. The `max` property must also be provided in 24-hour format.
+     */
+    max: string;
+    /**
+     * Whether the field is disabled. Controlled by daikin-input-group.
+     */
+    disabled: boolean;
+    /**
+     * Whether the field is required. Controlled by daikin-input-group.
+     */
+    required: boolean;
+    /**
+     * Whether to show error state. Controlled by daikin-input-group. Ignored if disabled.
+     */
+    error: boolean;
+    /**
+     * Minutes step. Specify the step size for the minutes when using the up and down arrow keys.
+     */
+    minutesStep: string;
+    private _label;
+    private _inputValue;
+    private _currentSelection;
+    private _meridiem;
+    private _timeInputElement;
+    /**
+     * Tracks the current digit index for hour input (0: first digit, 1: second digit).
+     */
+    private _hourDigitIndex;
+    /**
+     * Returns the value to display in the input field (from _inputValue state).
+     */
+    private get _timeValue();
+    /**
+     * Syncs the AM/PM value with the current value (24-hour) if value changes externally.
+     */
+    private _syncMeridiemWithValue;
+    private get _min();
+    private get _max();
+    private _convertZeroHourToTwelve;
+    private _handleFocusIn;
+    private _handleFocusOut;
+    private _handleChange;
+    private _handleMouseUp;
+    private _handleDigitInput;
+    private _handleKeyDown;
+    private _updateTimeByOffset;
+    private _handleBeforeInput;
+    /**
+     * Updates the value in 24-hour format if the input is valid, keeps UI in 12-hour format.
+     */
+    private _updateValue;
+    private _updateInputSelection;
+    private _updateSelection;
+    private _handleDropdownChange;
+    render(): import('lit-html').TemplateResult<1>;
+    protected willUpdate(changedProperties: PropertyValues<this>): void;
+    protected updated(changedProperties: PropertyValues<this>): void;
+    /**
+     * This method is used by `daikin-input-group` to reflect it's attributes to this component.
+     * @private
+     */
+    reflectInputGroup(inputGroup: DaikinInputGroup): void;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        "daikin-time-picker": DaikinTimePicker;
+    }
+}
+export {};

package/dist/cjs/components/time-picker/index.cjs

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const daikinTimePicker = require("./daikin-time-picker.cjs");
+Object.defineProperty(exports, "DaikinTimePicker", {
+  enumerable: true,
+  get: () => daikinTimePicker.DaikinTimePicker
+});
+exports.calcDigitInput = daikinTimePicker.calcDigitInput;
+exports.formatPartsForUI = daikinTimePicker.formatPartsForUI;
+exports.formatTimeForUI = daikinTimePicker.formatTimeForUI;
+exports.from24HourFormat = daikinTimePicker.from24HourFormat;
+exports.getTimeItemInSelection = daikinTimePicker.getTimeItemInSelection;
+exports.isTimeOutOfRange = daikinTimePicker.isTimeOutOfRange;
+exports.isValidValueTime = daikinTimePicker.isValidValueTime;
+exports.parsePartsFromUIValue = daikinTimePicker.parsePartsFromUIValue;
+exports.to24HourFormat = daikinTimePicker.to24HourFormat;
+exports.tryParseTimeFromUIValue = daikinTimePicker.tryParseTimeFromUIValue;

package/dist/cjs/components/time-picker/index.d.cts

@@ -0,0 +1 @@
+export * from "./daikin-time-picker.cjs";

package/dist/cjs/components/toast-notification-manager/daikin-toast-notification-manager.d.cts

@@ -1,7 +1,7 @@
 import { DDSElement } from "../../base/index.cjs";
 import { MergeVariantProps } from "../../type-utils.cjs";
 declare const cvaContainer: (props?: ({
-    position?: "top" | "bottom" | "top-left" | "top-right" | "bottom-left" | "bottom-right" | null | undefined;
+    position?: "bottom" | "top" | "top-left" | "top-right" | "bottom-left" | "bottom-right" | null | undefined;
 } & import('class-variance-authority/types').ClassProp) | undefined) => string;
 export type ToastPosition = MergeVariantProps<typeof cvaContainer>["position"];
 /**

package/dist/cjs/components/tooltip/daikin-tooltip.cjs

@@ -63,6 +63,7 @@ exports.DaikinTooltip = class DaikinTooltip extends ddsElement.DDSElement {
     this.description = "";
     this.popoverValue = "auto";
     this.trigger = "hover";
+    this._willBeFocusedByPress = false;
     this._autoUpdateController = new floatingUiAutoUpdate.FloatingUIAutoUpdateController(this);
     this._hostStyles = isClient.isClient ? window.getComputedStyle(this) : null;
   }
@@ -84,10 +85,14 @@ exports.DaikinTooltip = class DaikinTooltip extends ddsElement.DDSElement {
     }
   }
   _handleFocusIn() {
-    this.open = true;
+    if (this.trigger !== "manual" && !this._willBeFocusedByPress) {
+      this.open = true;
+    }
   }
   _handleFocusOut() {
-    this.open = false;
+    if (this.trigger !== "manual") {
+      this.open = false;
+    }
   }
   _handlePointerEnter(event) {
     if (this.trigger === "hover" && event.pointerType === "mouse") {
@@ -99,7 +104,11 @@ exports.DaikinTooltip = class DaikinTooltip extends ddsElement.DDSElement {
       this.open = false;
     }
   }
+  _handlePointerDown() {
+    this._willBeFocusedByPress = this.trigger === "click" && !this.matches(":focus-within");
+  }
   _handlePointerUp(event) {
+    this._willBeFocusedByPress = false;
     if (this.trigger === "hover" && event.pointerType === "touch") {
       this.open = !this.open;
     }
@@ -133,6 +142,7 @@ exports.DaikinTooltip = class DaikinTooltip extends ddsElement.DDSElement {
           @focusout=${this._handleFocusOut}
           @pointerenter=${this._handlePointerEnter}
           @pointerleave=${this._handlePointerLeave}
+          @pointerdown=${this._handlePointerDown}
           @pointerup=${this._handlePointerUp}
         ></slot>
       </div>

package/dist/cjs/components/tooltip/daikin-tooltip.d.cts

@@ -12,7 +12,7 @@ type TooltipVariantProps = MergeVariantProps<typeof cvaTooltip>;
  * @fires toggle - A event emitted when the tooltip is opened or closed.
  *
  * @slot - A slot for the element to which the tooltip is attached (the trigger element).
- * @slot description - A slot for the tooltip description content.
+ * @slot description - A slot for the tooltip description content. Tooltips don't have a prescribed maximum or minimum width. If you plan to use longer text, please note that you'll need to manually implement line breaks.
  *
  * @cssprop [--ddc-tooltip-spacing=20px] - Spacing between the tooltip and the trigger.
  *
@@ -55,6 +55,7 @@ export declare class DaikinTooltip extends DDSElement {
     /**
      * Specifies the content of the tooltip.
      * Ignored if the `tooltip` slot exists.
+     * Tooltips don't have a prescribed maximum or minimum width. If you plan to use longer text, please note that you'll need to manually implement line breaks.
      */
     description: string;
     /**
@@ -70,6 +71,11 @@ export declare class DaikinTooltip extends DDSElement {
      * - `manual`: The tooltip does not respond to user interaction. Use this to control the tooltip programmatically.
      */
     trigger: "hover" | "click" | "manual";
+    /**
+     * Internal state to track whether the element will be focused by a press interaction.
+     * In this case, the tooltip will not be open via focus to prevent it from disappearing immediately afterward.
+     */
+    private _willBeFocusedByPress;
     private _autoUpdateController;
     private _hostStyles;
     private _handleClick;
@@ -77,6 +83,7 @@ export declare class DaikinTooltip extends DDSElement {
     private _handleFocusOut;
     private _handlePointerEnter;
     private _handlePointerLeave;
+    private _handlePointerDown;
     private _handlePointerUp;
     private _handleBeforeToggle;
     private _handleToggle;

package/dist/cjs/controllers/floating-ui-auto-update.cjs

@@ -5,7 +5,7 @@ const lit = require("lit");
 const ref_js = require("lit/directives/ref.js");
 const controllerDirective = require("./helpers/controller-directive.cjs");
 const floatingUIAutoUpdateDirective = controllerDirective.createControllerDirective(
-  (referenceElement, floatingElement, options) => {
+  (referenceElement, floatingElement, options, _isOptionsUpdated, triggerContext) => {
     const cleanupAutoUpdate = dom.autoUpdate(
       referenceElement,
       floatingElement,
@@ -18,7 +18,10 @@ const floatingUIAutoUpdateDirective = controllerDirective.createControllerDirect
           floatingElement.style.setProperty("--floating-y", `${y}px`);
           floatingElement.setAttribute("data-floating-ready", "");
           if (isFirst) {
-            floatingElement.dispatchEvent(new Event("floating-ready"));
+            const event = new CustomEvent("floating-ready", {
+              detail: triggerContext
+            });
+            floatingElement.dispatchEvent(event);
           }
         }).catch((error) => {
         });
@@ -36,7 +39,8 @@ const floatingUIAutoUpdateDirective = controllerDirective.createControllerDirect
       current[0] !== previous[0] || // Check if the floating element is changed
       current[1] !== previous[1] || // Check if the options is changed.
       // If option comparison function (current[3]) is provided, use it to compare options. Otherwise, use `!==` to compare options.
-      (((_a = current[3]) == null ? void 0 : _a.call(current, current[2], previous[2])) ?? current[2] !== previous[2])
+      (((_a = current[3]) == null ? void 0 : _a.call(current, current[2], previous[2])) ?? current[2] !== previous[2]) || // Check if the trigger context is changed
+      current[4] !== previous[4]
     );
   }
 );
@@ -44,6 +48,7 @@ class FloatingUIAutoUpdateController {
   constructor(_host, _isOptionsUpdated) {
     this._host = _host;
     this._isOptionsUpdated = _isOptionsUpdated;
+    this._triggerContext = {};
     this._refCallbackFloating = (element) => {
       this._floatingElement = element;
       this._host.requestUpdate();
@@ -54,6 +59,18 @@ class FloatingUIAutoUpdateController {
     };
     _host.addController(this);
   }
+  /**
+   * Set context information that will be included in the floating-ready event
+   */
+  setTriggerContext(context) {
+    this._triggerContext = { ...context };
+  }
+  /**
+   * Clear the trigger context
+   */
+  clearTriggerContext() {
+    this._triggerContext = {};
+  }
   get floatingElement() {
     return this._floatingElement;
   }
@@ -74,7 +91,8 @@ class FloatingUIAutoUpdateController {
       this._referenceElement,
       this._floatingElement,
       options,
-      this._isOptionsUpdated
+      this._isOptionsUpdated,
+      this._triggerContext
     );
   }
 }

package/dist/cjs/controllers/floating-ui-auto-update.d.cts

@@ -13,7 +13,19 @@ export declare class FloatingUIAutoUpdateController<T extends ReactiveController
     private readonly _isOptionsUpdated?;
     private _floatingElement;
     private _referenceElement;
+    /**
+     * Context information to be passed with floating-ready event
+     */
+    private _triggerContext;
     constructor(_host: T, _isOptionsUpdated?: ((current: Partial<ComputePositionConfig>, previous: Partial<ComputePositionConfig>) => boolean) | undefined);
+    /**
+     * Set context information that will be included in the floating-ready event
+     */
+    setTriggerContext(context: Record<string, unknown>): void;
+    /**
+     * Clear the trigger context
+     */
+    clearTriggerContext(): void;
     private readonly _refCallbackFloating;
     private readonly _refCallbackReference;
     get floatingElement(): HTMLElement | undefined;

package/dist/cjs/icon-registry.cjs

@@ -0,0 +1,170 @@
+"use strict";
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var _instance, _icons, _dynamicRegistrations, _cache;
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+function isDynamicRegistration(registration) {
+  return "match" in registration && "fetch" in registration;
+}
+function isDirectRegistration(registration) {
+  return "name" in registration && "svg" in registration;
+}
+function normalizeIconData(svg) {
+  if (typeof svg === "string") {
+    return { mode: "mask", svg };
+  }
+  return { mode: "mask", ...svg };
+}
+const _IconRegistry = class _IconRegistry {
+  constructor() {
+    /** Map of registered icons by name */
+    __privateAdd(this, _icons, /* @__PURE__ */ new Map());
+    /** Array of dynamic icon registrations */
+    __privateAdd(this, _dynamicRegistrations, []);
+    /** Cache for dynamically fetched icons */
+    __privateAdd(this, _cache, /* @__PURE__ */ new Map());
+  }
+  /**
+   * Get the singleton instance of IconRegistry
+   */
+  static getGlobalInstance() {
+    const instance = __privateGet(_IconRegistry, _instance) ?? __privateSet(_IconRegistry, _instance, new _IconRegistry());
+    return instance;
+  }
+  /**
+   * Register an icon or dynamic icon fetcher
+   * @param registration Icon registration configuration
+   *
+   * @example
+   * // Direct registration
+   * registry.register({ name: "custom-icon", svg: "<svg>...</svg>" });
+   *
+   * // Dynamic registration
+   * registry.register({
+   *   match: /^custom-/,
+   *   fetch: async (name) => {
+   *     const response = await fetch(`/icons/${name}.svg`);
+   *     return response.text();
+   *   }
+   * });
+   */
+  register(registration) {
+    if (isDirectRegistration(registration)) {
+      const iconData = normalizeIconData(registration.svg);
+      __privateGet(this, _icons).set(registration.name, iconData);
+    } else if (isDynamicRegistration(registration)) {
+      __privateGet(this, _dynamicRegistrations).push(registration);
+    }
+  }
+  /**
+   * Get an icon by name
+   * @param name Icon name
+   * @returns Promise that resolves to IconData or null if not found
+   */
+  async getIcon(name) {
+    const registered = __privateGet(this, _icons).get(name);
+    if (registered) {
+      return registered;
+    }
+    for (const registration of __privateGet(this, _dynamicRegistrations)) {
+      if (registration.match.test(name)) {
+        return this.fetchDynamicIcon(registration, name);
+      }
+    }
+    return null;
+  }
+  /**
+   * Check if an icon is registered (either directly or through dynamic registration)
+   * @param name Icon name
+   * @returns true if icon is available
+   */
+  hasIcon(name) {
+    if (__privateGet(this, _icons).has(name)) {
+      return true;
+    }
+    return __privateGet(this, _dynamicRegistrations).some(
+      (registration) => registration.match.test(name)
+    );
+  }
+  /**
+   * Get all directly registered icon names
+   * @returns Array of icon names
+   */
+  getRegisteredIconNames() {
+    return Array.from(__privateGet(this, _icons).keys());
+  }
+  /**
+   * Get all dynamic registration patterns
+   * @returns Array of regex patterns
+   */
+  getDynamicPatterns() {
+    return __privateGet(this, _dynamicRegistrations).map((reg) => reg.match);
+  }
+  /**
+   * Clear all registrations and cache
+   */
+  clear() {
+    __privateGet(this, _icons).clear();
+    __privateGet(this, _dynamicRegistrations).length = 0;
+    __privateGet(this, _cache).clear();
+  }
+  /**
+   * Remove a specific icon registration
+   * @param name Icon name to remove
+   */
+  unregister(name) {
+    const existed = __privateGet(this, _icons).has(name);
+    __privateGet(this, _icons).delete(name);
+    return existed;
+  }
+  /**
+   * Fetch icon from dynamic registration
+   * @param registration Dynamic registration
+   * @param name Icon name
+   * @returns Promise that resolves to IconData or null
+   */
+  async fetchDynamicIcon(registration, name) {
+    const cacheKey = `${registration.match.source}\0${name}`;
+    const cached = __privateGet(this, _cache).get(cacheKey);
+    if (cached) {
+      return cached;
+    }
+    const fetchPromise = this.performDynamicFetch(registration, name).then(
+      (result) => {
+        __privateGet(this, _cache).set(cacheKey, result);
+        return result;
+      }
+    );
+    __privateGet(this, _cache).set(cacheKey, fetchPromise);
+    return fetchPromise;
+  }
+  /**
+   * Perform the actual dynamic fetch
+   * @param registration Dynamic registration
+   * @param name Icon name
+   * @returns Promise that resolves to IconData or null
+   */
+  async performDynamicFetch(registration, name) {
+    try {
+      const result = await registration.fetch(name);
+      return normalizeIconData(result);
+    } catch (error) {
+      console.warn(`Failed to fetch dynamic icon "${name}":`, error);
+      return null;
+    }
+  }
+};
+_instance = new WeakMap();
+_icons = new WeakMap();
+_dynamicRegistrations = new WeakMap();
+_cache = new WeakMap();
+__privateAdd(_IconRegistry, _instance);
+let IconRegistry = _IconRegistry;
+const iconRegistry = IconRegistry.getGlobalInstance();
+exports.IconRegistry = IconRegistry;
+exports.iconRegistry = iconRegistry;

package/dist/cjs/icon-registry.d.cts

@@ -0,0 +1,120 @@
+/**
+ * Icon data structure containing SVG information
+ */
+export interface IconData {
+    /** SVG content as a string */
+    svg: string;
+    /** Default color for the icon */
+    defaultColor?: string | null;
+    /**
+     * Determines how the SVG is rendered.
+     * This affects the styling and behavior of the icon.
+     *
+     * - "mask": Uses the SVG as a CSS mask, allowing for color customization. Use this for monochrome icons.
+     * - "background": Uses the SVG as a CSS background image. Use this for colorful icons with no complex styling.
+     * - "inline": Renders the SVG inline, allowing for more complex styling.
+     *   **Be cautious with this mode as it can introduce security risks if the SVG content is not trusted.**
+     *
+     * @default "mask"
+     */
+    mode?: "mask" | "background" | "inline";
+}
+/**
+ * Direct icon registration configuration
+ */
+export interface DirectIconRegistration {
+    /** Icon name */
+    name: string;
+    /** SVG content or icon data */
+    svg: string | IconData;
+}
+/**
+ * Dynamic icon registration configuration using regex pattern matching
+ */
+export interface DynamicIconRegistration {
+    /** Regular expression to match icon names */
+    match: RegExp;
+    /** Function to fetch SVG content for matched names */
+    fetch: (name: string) => Promise<string | IconData> | string | IconData;
+}
+/**
+ * Icon registration configuration
+ */
+export type IconRegistration = DirectIconRegistration | DynamicIconRegistration;
+/**
+ * Icon registry class that manages icon registration and retrieval
+ */
+export declare class IconRegistry {
+    #private;
+    /**
+     * Get the singleton instance of IconRegistry
+     */
+    static getGlobalInstance(): IconRegistry;
+    /**
+     * Register an icon or dynamic icon fetcher
+     * @param registration Icon registration configuration
+     *
+     * @example
+     * // Direct registration
+     * registry.register({ name: "custom-icon", svg: "<svg>...</svg>" });
+     *
+     * // Dynamic registration
+     * registry.register({
+     *   match: /^custom-/,
+     *   fetch: async (name) => {
+     *     const response = await fetch(`/icons/${name}.svg`);
+     *     return response.text();
+     *   }
+     * });
+     */
+    register(registration: IconRegistration): void;
+    /**
+     * Get an icon by name
+     * @param name Icon name
+     * @returns Promise that resolves to IconData or null if not found
+     */
+    getIcon(name: string): Promise<IconData | null>;
+    /**
+     * Check if an icon is registered (either directly or through dynamic registration)
+     * @param name Icon name
+     * @returns true if icon is available
+     */
+    hasIcon(name: string): boolean;
+    /**
+     * Get all directly registered icon names
+     * @returns Array of icon names
+     */
+    getRegisteredIconNames(): string[];
+    /**
+     * Get all dynamic registration patterns
+     * @returns Array of regex patterns
+     */
+    getDynamicPatterns(): RegExp[];
+    /**
+     * Clear all registrations and cache
+     */
+    clear(): void;
+    /**
+     * Remove a specific icon registration
+     * @param name Icon name to remove
+     */
+    unregister(name: string): boolean;
+    /**
+     * Fetch icon from dynamic registration
+     * @param registration Dynamic registration
+     * @param name Icon name
+     * @returns Promise that resolves to IconData or null
+     */
+    private fetchDynamicIcon;
+    /**
+     * Perform the actual dynamic fetch
+     * @param registration Dynamic registration
+     * @param name Icon name
+     * @returns Promise that resolves to IconData or null
+     */
+    private performDynamicFetch;
+}
+/**
+ * Global icon registry instance
+ */
+export declare const iconRegistry: IconRegistry;