@hyalo/angular 0.0.0-stage → 0.1.0

package/types/hyalo-angular-choice.d.ts

@@ -0,0 +1,259 @@
+import { FormCheckboxControl, FormValueControl } from "@angular/forms/signals";
+import * as i0 from "@angular/core";
+/**
+ * A checkbox with a label. It wraps a real `<input type="checkbox">`, so
+ * Space toggles it, clicking the label works and forms see it.
+ *
+ * ```html
+ * <hy-checkbox [formField]="form.terms">I accept the terms</hy-checkbox>
+ * <hy-checkbox [(checked)]="all" [indeterminate]="some">Select all</hy-checkbox>
+ * ```
+ */
+export declare class HyCheckbox implements FormCheckboxControl {
+  protected readonly descriptionId: string;
+  /** Whether the box is checked. Two-way bindable and works with `[formField]`. */
+  readonly checked: import("@angular/core").ModelSignal<boolean>;
+  /** Shows a dash for a partly selected group. Cleared when the user toggles. */
+  readonly indeterminate: import("@angular/core").ModelSignal<boolean>;
+  /** Secondary text under the label. */
+  readonly description: import("@angular/core").InputSignal<string | undefined>;
+  readonly name: import("@angular/core").InputSignal<string>;
+  readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly required: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly invalid: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly touched: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Emits when focus leaves the checkbox. */
+  readonly touch: import("@angular/core").OutputEmitterRef<void>;
+  protected onChange(event: Event): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<HyCheckbox, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<HyCheckbox, "hy-checkbox", never, {
+    "checked": {
+      "alias": "checked";
+      "required": false;
+      "isSignal": true;
+    };
+    "indeterminate": {
+      "alias": "indeterminate";
+      "required": false;
+      "isSignal": true;
+    };
+    "description": {
+      "alias": "description";
+      "required": false;
+      "isSignal": true;
+    };
+    "name": {
+      "alias": "name";
+      "required": false;
+      "isSignal": true;
+    };
+    "disabled": {
+      "alias": "disabled";
+      "required": false;
+      "isSignal": true;
+    };
+    "required": {
+      "alias": "required";
+      "required": false;
+      "isSignal": true;
+    };
+    "invalid": {
+      "alias": "invalid";
+      "required": false;
+      "isSignal": true;
+    };
+    "touched": {
+      "alias": "touched";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "checked": "checkedChange";
+    "indeterminate": "indeterminateChange";
+    "touch": "touch";
+  }, never, ["*"], true, never>;
+}
+/**
+ * A group of radio buttons. Holds the value; the radios inside only say
+ * which value they stand for.
+ *
+ * ```html
+ * <hy-radio-group label="Delivery" [formField]="form.delivery">
+ *   <hy-radio value="standard" description="3 to 5 days">Standard</hy-radio>
+ *   <hy-radio value="express">Express</hy-radio>
+ * </hy-radio-group>
+ * ```
+ *
+ * The radios are native inputs sharing one name, so arrow keys move the
+ * selection the way the platform does, including in RTL.
+ */
+export declare class HyRadioGroup<T> implements FormValueControl<T | undefined> {
+  protected readonly labelId: string;
+  private readonly generatedName;
+  /** Selected value. Two-way bindable and works with `[formField]`. */
+  readonly value: import("@angular/core").ModelSignal<T | undefined>;
+  /** Visible group label. */
+  readonly label: import("@angular/core").InputSignal<string | undefined>;
+  /** Shared input name. Generated when not set. */
+  readonly name: import("@angular/core").InputSignal<string>;
+  readonly orientation: import("@angular/core").InputSignal<"vertical" | "horizontal">;
+  readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly required: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly invalid: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly touched: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly errors: import("@angular/core").InputSignal<readonly {
+    readonly kind: string;
+    readonly message?: string;
+  }[]>;
+  /** Emits when focus leaves a radio. */
+  readonly touch: import("@angular/core").OutputEmitterRef<void>;
+  readonly groupName: import("@angular/core").Signal<string>;
+  protected readonly showsError: import("@angular/core").Signal<boolean>;
+  protected readonly errorMessage: import("@angular/core").Signal<string>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<HyRadioGroup<any>, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<HyRadioGroup<any>, "hy-radio-group", never, {
+    "value": {
+      "alias": "value";
+      "required": false;
+      "isSignal": true;
+    };
+    "label": {
+      "alias": "label";
+      "required": false;
+      "isSignal": true;
+    };
+    "name": {
+      "alias": "name";
+      "required": false;
+      "isSignal": true;
+    };
+    "orientation": {
+      "alias": "orientation";
+      "required": false;
+      "isSignal": true;
+    };
+    "disabled": {
+      "alias": "disabled";
+      "required": false;
+      "isSignal": true;
+    };
+    "required": {
+      "alias": "required";
+      "required": false;
+      "isSignal": true;
+    };
+    "invalid": {
+      "alias": "invalid";
+      "required": false;
+      "isSignal": true;
+    };
+    "touched": {
+      "alias": "touched";
+      "required": false;
+      "isSignal": true;
+    };
+    "errors": {
+      "alias": "errors";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "value": "valueChange";
+    "touch": "touch";
+  }, never, ["*"], true, never>;
+}
+/** One option inside a `hy-radio-group`. */
+export declare class HyRadio<T> {
+  protected readonly group: HyRadioGroup<T>;
+  protected readonly descriptionId: string;
+  /** The value this radio selects. */
+  readonly value: import("@angular/core").InputSignal<T>;
+  /** Secondary text under the label. */
+  readonly description: import("@angular/core").InputSignal<string | undefined>;
+  readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  protected readonly checked: import("@angular/core").Signal<boolean>;
+  protected readonly isDisabled: import("@angular/core").Signal<boolean>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<HyRadio<any>, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<HyRadio<any>, "hy-radio", never, {
+    "value": {
+      "alias": "value";
+      "required": true;
+      "isSignal": true;
+    };
+    "description": {
+      "alias": "description";
+      "required": false;
+      "isSignal": true;
+    };
+    "disabled": {
+      "alias": "disabled";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, ["*"], true, never>;
+}
+/**
+ * An on/off switch for settings that apply right away. For choices that
+ * are submitted with a form, a checkbox is usually clearer.
+ *
+ * It is a native checkbox with `role="switch"`, so screen readers say
+ * "on" and "off" and Space toggles it. The thumb can also be dragged: it
+ * follows the pointer, and lands on whichever side it is let go nearer.
+ *
+ * ```html
+ * <hy-switch [(checked)]="notifications">Email notifications</hy-switch>
+ * ```
+ */
+export declare class HySwitch implements FormCheckboxControl {
+  protected readonly descriptionId: string;
+  /** Physical thumb offset in px while it is dragged, otherwise null. */
+  protected readonly drag: import("@angular/core").WritableSignal<number | null>;
+  private press;
+  /** Where a finished drag landed, until the click it causes is handled. */
+  private landed;
+  /** Whether the switch is on. Two-way bindable and works with `[formField]`. */
+  readonly checked: import("@angular/core").ModelSignal<boolean>;
+  /** Secondary text under the label. */
+  readonly description: import("@angular/core").InputSignal<string | undefined>;
+  readonly name: import("@angular/core").InputSignal<string>;
+  readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly required: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Emits when focus leaves the switch. */
+  readonly touch: import("@angular/core").OutputEmitterRef<void>;
+  protected onChange(event: Event): void;
+  protected onDown(event: PointerEvent): void;
+  protected onMove(event: PointerEvent): void;
+  protected onUp(cancelled?: boolean): void;
+  protected onClick(event: MouseEvent): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<HySwitch, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<HySwitch, "hy-switch", never, {
+    "checked": {
+      "alias": "checked";
+      "required": false;
+      "isSignal": true;
+    };
+    "description": {
+      "alias": "description";
+      "required": false;
+      "isSignal": true;
+    };
+    "name": {
+      "alias": "name";
+      "required": false;
+      "isSignal": true;
+    };
+    "disabled": {
+      "alias": "disabled";
+      "required": false;
+      "isSignal": true;
+    };
+    "required": {
+      "alias": "required";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "checked": "checkedChange";
+    "touch": "touch";
+  }, never, ["*"], true, never>;
+}

package/types/hyalo-angular-dialog.d.ts

@@ -0,0 +1,170 @@
+import { DialogConfig, DialogRef } from "@angular/cdk/dialog";
+import * as i0 from "@angular/core";
+import { InjectionToken, TemplateRef } from "@angular/core";
+import { ComponentType } from "@angular/cdk/portal";
+import { HyMaterial, HyTone } from "@hyalo/angular";
+import "@angular/cdk/overlay";
+/** Data passed to a dialog or drawer through `open(..., { data })`. */
+export declare const HY_DIALOG_DATA: InjectionToken<unknown>;
+/**
+ * Handle to an open dialog or drawer. Inject it in the content component to
+ * close it, or keep the one `open()` returns.
+ */
+export declare class HyDialogRef<R = unknown> {
+  private readonly cdkRef;
+  private closing;
+  /** Resolves with the result once the surface has closed. */
+  readonly closed: Promise<R | undefined>;
+  /**
+   * @internal Set by surfaces that drive their own exit, like a sheet on a
+   * spring. Calls `finish` once the surface is out of view.
+   */
+  exit: ((finish: () => void) => void) | null;
+  /** @internal */
+  constructor(cdkRef: DialogRef<R>);
+  /** Id of the dialog container element. */
+  get id(): string;
+  /** The element with `role="dialog"`. */
+  get containerElement(): HTMLElement | null;
+  /**
+   * Plays the exit animation, then closes. With reduced motion the exit is
+   * a short fade. Calling it again while the animation runs does nothing.
+   */
+  close(result?: R): void;
+  /**
+   * @internal A sheet grabbed while it was closing stays open, and a later
+   * `close()` works again.
+   */
+  cancelClose(): void;
+}
+/**
+ * The dialog or drawer heading. Its id becomes the container's
+ * `aria-labelledby`, so screen readers announce it on open.
+ */
+export declare class HyDialogTitle {
+  protected readonly id: string;
+  constructor();
+  static ɵfac: i0.ɵɵFactoryDeclaration<HyDialogTitle, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<HyDialogTitle, "[hyDialogTitle]", never, {}, {}, never, never, true, never>;
+}
+/** The scrollable body. */
+export declare class HyDialogContent {
+  static ɵfac: i0.ɵɵFactoryDeclaration<HyDialogContent, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<HyDialogContent, "[hyDialogContent]", never, {}, {}, never, never, true, never>;
+}
+/** The button row at the bottom. Primary action goes last. */
+export declare class HyDialogActions {
+  static ɵfac: i0.ɵɵFactoryDeclaration<HyDialogActions, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<HyDialogActions, "[hyDialogActions]", never, {}, {}, never, never, true, never>;
+}
+/** Closes the surrounding dialog or drawer with an optional result. */
+export declare class HyDialogClose {
+  protected readonly ref: HyDialogRef<any> | null;
+  /** The result to close with. A bare attribute closes with `undefined`. */
+  readonly hyDialogClose: import("@angular/core").InputSignalWithTransform<unknown, unknown>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<HyDialogClose, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<HyDialogClose, "button[hyDialogClose]", never, {
+    "hyDialogClose": {
+      "alias": "hyDialogClose";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+/** Everything needed to lay out dialog or drawer content. */
+export declare const HY_DIALOG_PARTS: readonly [typeof HyDialogTitle, typeof HyDialogContent, typeof HyDialogActions, typeof HyDialogClose];
+/**
+ * Which edge the drawer slides from. `start` and `end` follow the text
+ * direction, so `end` is the right edge in LTR and the left edge in RTL.
+ * `bottom` gives a sheet, handy on phones.
+ */
+export type HyDrawerSide = 'start' | 'end' | 'bottom';
+/** Options for {@link HyDrawer.open}. */
+export interface HyDrawerConfig<D = unknown> extends HySurfaceConfig<D> {
+  readonly side?: HyDrawerSide;
+  /** Any CSS length. Width for side drawers, height for the bottom sheet. */
+  readonly size?: string;
+}
+/**
+ * Opens a modal drawer: navigation on phones, a cart, filters. It behaves
+ * like a dialog (focus trap, Escape, backdrop, focus restore) and uses the
+ * same content parts and `HyDialogRef`.
+ *
+ * It runs on a spring and follows the pointer: drag it toward its edge, or
+ * flick it, to close it, and grab it again while it moves. A bottom sheet
+ * shows a grabber. With reduced motion it cross-fades instead.
+ *
+ * ```ts
+ * this.drawer.open(CartPanel, { side: 'end', label: 'Cart' });
+ * ```
+ */
+export declare class HyDrawer {
+  private readonly cdk;
+  private readonly motion;
+  private readonly fidelity;
+  private readonly injector;
+  /** Opens a component or template in a drawer. */
+  open<R = unknown, D = unknown>(content: ComponentType<unknown> | TemplateRef<unknown>, config?: HyDrawerConfig<D>): HyDialogRef<R>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<HyDrawer, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+/** Options shared by dialogs and drawers. */
+interface HySurfaceConfig<D> {
+  /** Passed to the content as `HY_DIALOG_DATA`. */
+  readonly data?: D;
+  /** Accessible name, when the content has no `hyDialogTitle`. */
+  readonly label?: string;
+  /** Close on Escape and backdrop click. Defaults to true. */
+  readonly dismissible?: boolean;
+  /** Glass material of the panel. */
+  readonly material?: HyMaterial;
+  /** Where focus goes on open. Defaults to the first tabbable element. */
+  readonly autoFocus?: DialogConfig['autoFocus'];
+  /** `alertdialog` for messages that need an answer. */
+  readonly role?: 'dialog' | 'alertdialog';
+}
+/** Dialog width. `full` fills the screen on small viewports. */
+export type HyDialogSize = 'sm' | 'md' | 'lg' | 'full';
+/** Options for {@link HyDialog.open}. */
+export interface HyDialogConfig<D = unknown> extends HySurfaceConfig<D> {
+  readonly size?: HyDialogSize;
+}
+/** Options for {@link HyDialog.confirm}. */
+export interface HyConfirmOptions {
+  readonly title: string;
+  readonly message?: string;
+  readonly confirmLabel?: string;
+  readonly cancelLabel?: string;
+  /** Use `danger` for destructive actions. */
+  readonly tone?: HyTone;
+}
+/**
+ * Opens modal dialogs. Focus is trapped inside while open and returns to
+ * the element that opened it. Escape and a backdrop click close it unless
+ * `dismissible` is false.
+ *
+ * ```ts
+ * const ref = this.dialog.open(EditAddress, { data: address, size: 'md' });
+ * const saved = await ref.closed;
+ *
+ * if (await this.dialog.confirm({ title: 'Delete this draft?', tone: 'danger', confirmLabel: 'Delete' })) {
+ *   ...
+ * }
+ * ```
+ *
+ * In the content component, inject `HyDialogRef` to close and
+ * `HY_DIALOG_DATA` to read the data. Lay it out with `hyDialogTitle`,
+ * `hyDialogContent` and `hyDialogActions`.
+ */
+export declare class HyDialog {
+  private readonly cdk;
+  private readonly motion;
+  private readonly fidelity;
+  /** Opens a component or template as a dialog. */
+  open<R = unknown, D = unknown>(content: ComponentType<unknown> | TemplateRef<unknown>, config?: HyDialogConfig<D>): HyDialogRef<R>;
+  /** Asks a yes or no question. Resolves to true only when confirmed. */
+  confirm(options: HyConfirmOptions): Promise<boolean>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<HyDialog, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+export type { HySurfaceConfig };

package/types/hyalo-angular-field.d.ts

@@ -0,0 +1,135 @@
+import * as i0 from "@angular/core";
+import { InjectionToken, Signal } from "@angular/core";
+import { HySize } from "@hyalo/angular";
+/**
+ * What a control tells the field around it. Implemented by `hyInput` and
+ * `hy-select`. Custom controls can implement it too, so `hy-field` can
+ * label them and show their errors.
+ */
+export interface HyFieldControl {
+  /** Id of the focusable element. */
+  readonly id: Signal<string>;
+  /** True when the field should show as invalid. */
+  readonly invalid: Signal<boolean>;
+  /** First error message to show, if any. */
+  readonly errorMessage: Signal<string | undefined>;
+  readonly required: Signal<boolean>;
+  readonly disabled: Signal<boolean>;
+  /**
+   * True when the control is a native labelable element (input, textarea,
+   * select, button). Those get `<label for>`. Others rely on
+   * `aria-labelledby`.
+   */
+  readonly labelable: boolean;
+}
+/** The field a control sits in. */
+export interface HyFieldContext {
+  readonly labelId: string;
+  readonly hintId: string;
+  readonly errorId: string;
+  /** True while the field displays an error. */
+  readonly errorShown: Signal<boolean>;
+  /** Space-separated ids for `aria-describedby`. */
+  readonly describedBy: Signal<string | null>;
+  register(control: HyFieldControl): void;
+}
+/** Provided by `hy-field` to the control inside it. */
+export declare const HY_FIELD: InjectionToken<HyFieldContext>;
+/**
+ * Marks a native `<input>` or `<textarea>` as the control of a `hy-field`.
+ * It wires the label, hint and error ids, and reads validity from Signal
+ * Forms when `[formField]` is on the same element.
+ *
+ * The element stays native, so Signal Forms, `ngModel`, autofill and
+ * mobile keyboards all work as usual.
+ */
+export declare class HyInput implements HyFieldControl {
+  protected readonly field: import("@hyalo/angular/field").HyFieldContext | null;
+  private readonly formField;
+  readonly labelable = true;
+  /** The element's own static `id` attribute, or a generated one. */
+  readonly id: import("@angular/core").Signal<string>;
+  readonly invalid: import("@angular/core").Signal<boolean>;
+  readonly errorMessage: import("@angular/core").Signal<string | undefined>;
+  protected readonly showsError: import("@angular/core").Signal<boolean>;
+  readonly required: import("@angular/core").Signal<boolean>;
+  readonly disabled: import("@angular/core").Signal<boolean>;
+  constructor();
+  static ɵfac: i0.ɵɵFactoryDeclaration<HyInput, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<HyInput, "input[hyInput], textarea[hyInput]", never, {}, {}, never, never, true, never>;
+}
+/** Content before the control inside the field box, such as an icon. */
+export declare class HyPrefix {
+  static ɵfac: i0.ɵɵFactoryDeclaration<HyPrefix, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<HyPrefix, "[hyPrefix]", never, {}, {}, never, never, true, never>;
+}
+/** Content after the control inside the field box, such as a unit or a button. */
+export declare class HySuffix {
+  static ɵfac: i0.ɵɵFactoryDeclaration<HySuffix, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<HySuffix, "[hySuffix]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Label, hint and error around one form control.
+ *
+ * ```html
+ * <hy-field label="Email" hint="Only used for the receipt">
+ *   <hy-icon hyPrefix name="mail" />
+ *   <input hyInput type="email" [formField]="form.email" />
+ * </hy-field>
+ * ```
+ *
+ * With Signal Forms the error comes from the field state and shows once the
+ * field is touched. An explicit `error` input always wins, which is how
+ * server-side errors are shown.
+ */
+export declare class HyField implements HyFieldContext {
+  readonly labelId: string;
+  readonly hintId: string;
+  readonly errorId: string;
+  /** Visible label. Always set one, placeholders are not labels. */
+  readonly label: import("@angular/core").InputSignal<string | undefined>;
+  /** Help text under the control. Hidden while an error shows. */
+  readonly hint: import("@angular/core").InputSignal<string | undefined>;
+  /** Error text. Overrides errors from the form. */
+  readonly error: import("@angular/core").InputSignal<string | undefined>;
+  /** Show errors before the field is touched, for example after submit. */
+  readonly forceError: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Height of the field box. */
+  readonly size: import("@angular/core").InputSignal<HySize>;
+  protected readonly control: import("@angular/core").WritableSignal<HyFieldControl | undefined>;
+  protected readonly labelFor: import("@angular/core").Signal<string | null>;
+  protected readonly errorText: import("@angular/core").Signal<string | undefined>;
+  readonly errorShown: import("@angular/core").Signal<boolean>;
+  readonly describedBy: import("@angular/core").Signal<string | null>;
+  register(control: HyFieldControl): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<HyField, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<HyField, "hy-field", never, {
+    "label": {
+      "alias": "label";
+      "required": false;
+      "isSignal": true;
+    };
+    "hint": {
+      "alias": "hint";
+      "required": false;
+      "isSignal": true;
+    };
+    "error": {
+      "alias": "error";
+      "required": false;
+      "isSignal": true;
+    };
+    "forceError": {
+      "alias": "forceError";
+      "required": false;
+      "isSignal": true;
+    };
+    "size": {
+      "alias": "size";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, ["[hyPrefix]", "*", "[hySuffix]"], true, never>;
+}
+/** Everything needed to build a text field. */
+export declare const HY_TEXT_FIELD: readonly [typeof HyField, typeof HyInput, typeof HyPrefix, typeof HySuffix];

package/types/hyalo-angular-icon.d.ts

@@ -0,0 +1,122 @@
+import * as i0 from "@angular/core";
+import { InjectionToken, Provider } from "@angular/core";
+/**
+ * Icon data in the same shape Lucide uses (`IconNode`), so any Lucide icon
+ * can be registered as is:
+ *
+ * ```ts
+ * import { ArrowRight } from 'lucide';
+ * provideHyaloIcons({ 'arrow-right': ArrowRight })
+ * ```
+ *
+ * Icons are data, not SVG strings, so nothing is ever parsed as HTML.
+ */
+export type HyIconNode = readonly (readonly [string, Readonly<Record<string, string | number>>])[];
+/** An icon plus how it behaves in right-to-left layouts. */
+export interface HyIconDef {
+  readonly node: HyIconNode;
+  /** Mirror the icon in RTL. Set it for icons that point somewhere, like arrows. */
+  readonly mirrorRtl?: boolean;
+}
+export declare const HY_BUILTIN_ICONS: Readonly<Record<string, HyIconDef>>;
+type HyIconSet = Readonly<Record<string, HyIconDef | HyIconNode>>;
+/** Icons added with {@link provideHyaloIcons}. Collected from every provider. */
+export declare const HY_ICONS: InjectionToken<readonly Readonly<Record<string, HyIconDef | HyIconNode>>[]>;
+/**
+ * Registers icons by name. Only the icons you import end up in the bundle.
+ *
+ * ```ts
+ * provideHyaloIcons({ search: Search, 'arrow-end': { node: ArrowRight, mirrorRtl: true } })
+ * ```
+ *
+ * Works in `app.config.ts` and in a route's or component's `providers`.
+ * Icons from the nearest provider win over app-wide ones.
+ */
+export declare function provideHyaloIcons(icons: Readonly<Record<string, HyIconDef | HyIconNode>>): Provider;
+/** Looks up icons by name: built-ins first, then registered sets in order. */
+export declare class HyIconRegistry {
+  private readonly icons;
+  private readonly sets;
+  constructor();
+  /** Adds or replaces an icon at runtime. */
+  register(name: string, icon: HyIconDef | HyIconNode): void;
+  /** Returns the icon, or undefined when the name is unknown. */
+  get(name: string): HyIconDef | undefined;
+  /**
+   * @internal Looks in sets from a route or component injector first. This
+   * registry lives in the root injector, so it never sees those itself.
+   */
+  lookup(name: string, sets: readonly HyIconSet[] | null): HyIconDef | undefined;
+  static ɵfac: i0.ɵɵFactoryDeclaration<HyIconRegistry, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+/** Copies whitelisted geometry attributes onto an SVG child element. */
+export declare class HyIconAttrs {
+  private readonly el;
+  private readonly renderer;
+  readonly hyIconAttrs: import("@angular/core").InputSignal<Readonly<Record<string, string | number>>>;
+  constructor();
+  static ɵfac: i0.ɵɵFactoryDeclaration<HyIconAttrs, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<HyIconAttrs, "[hyIconAttrs]", never, {
+    "hyIconAttrs": {
+      "alias": "hyIconAttrs";
+      "required": true;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+/**
+ * An SVG icon from the registry, or passed in directly.
+ *
+ * ```html
+ * <hy-icon name="check" />
+ * <hy-icon [icon]="ArrowRight" label="Next" />
+ * ```
+ *
+ * Icons are decorative (`aria-hidden`) unless `label` is set, in which case
+ * they get `role="img"` and that label. The size follows the font size.
+ */
+export declare class HyIcon {
+  private readonly registry;
+  private readonly sets;
+  /** Registered icon name. */
+  readonly name: import("@angular/core").InputSignal<string | undefined>;
+  /** Icon data, used instead of `name`. */
+  readonly icon: import("@angular/core").InputSignal<HyIconDef | HyIconNode | undefined>;
+  /** Accessible name. Leave empty for decorative icons. */
+  readonly label: import("@angular/core").InputSignal<string | undefined>;
+  /** Any CSS length. Defaults to 1.25em. */
+  readonly size: import("@angular/core").InputSignal<string | undefined>;
+  /** Stroke width in viewBox units. */
+  readonly strokeWidth: import("@angular/core").InputSignal<number>;
+  protected readonly def: import("@angular/core").Signal<HyIconDef | undefined>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<HyIcon, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<HyIcon, "hy-icon", never, {
+    "name": {
+      "alias": "name";
+      "required": false;
+      "isSignal": true;
+    };
+    "icon": {
+      "alias": "icon";
+      "required": false;
+      "isSignal": true;
+    };
+    "label": {
+      "alias": "label";
+      "required": false;
+      "isSignal": true;
+    };
+    "size": {
+      "alias": "size";
+      "required": false;
+      "isSignal": true;
+    };
+    "strokeWidth": {
+      "alias": "strokeWidth";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+export {};