@hyalo/angular 0.0.0-stage → 0.3.1

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

@@ -0,0 +1,122 @@
+import * as i0 from "@angular/core";
+import { TemplateRef } from "@angular/core";
+import { HySelectOption } from "@hyalo/angular/select";
+export type HyFilterScalar = string | number | boolean;
+export type HyDatePreset = '24H' | '7D' | '30D' | '1Y';
+export type HyDateRangeValue = {
+  readonly kind: 'preset';
+  readonly preset: HyDatePreset;
+  readonly timeZone: string;
+} | {
+  readonly kind: 'absolute';
+  readonly start: string;
+  readonly end: string;
+  readonly timeZone: string;
+};
+export type HyFilterRule = {
+  readonly operator: 'eq';
+  readonly value: HyFilterScalar;
+} | {
+  readonly operator: 'in';
+  readonly value: readonly HyFilterScalar[];
+} | {
+  readonly operator: 'contains';
+  readonly value: string;
+} | {
+  readonly operator: 'between';
+  readonly value: readonly [number, number] | HyDateRangeValue;
+};
+export type HyFilterClause<S> = { [K in keyof S]: {
+  readonly id: string;
+  readonly field: K;
+} & S[K]; }[keyof S];
+export type HyFilterToken = {
+  readonly id: string;
+  readonly field: string;
+} & HyFilterRule;
+export interface HyFilterCodec<C extends HyFilterToken> {
+  readonly accepts: (value: unknown) => value is C;
+}
+export declare function encodeFilters<C extends HyFilterToken>(clauses: readonly C[]): string;
+export declare function decodeFilters<C extends HyFilterToken>(text: string, codec: HyFilterCodec<C>): readonly C[];
+export declare function isFilterToken(value: unknown): value is HyFilterToken;
+/** Presets are rolling elapsed intervals; both editors use start-inclusive/end-exclusive instants. */
+export declare function resolveDateRange(value: HyDateRangeValue, now: Date): {
+  readonly start: string;
+  readonly end: string;
+};
+export interface HyFilterEditorContext<C> {
+  readonly $implicit: C;
+  readonly update: (clause: C) => void;
+}
+export interface HyFilterField<C extends HyFilterToken> {
+  readonly field: C['field'];
+  readonly label: string;
+  readonly options?: readonly HySelectOption<string>[];
+  readonly create: (id: string, value: string) => C | null;
+  readonly editor?: TemplateRef<HyFilterEditorContext<C>>;
+  readonly format?: (clause: C) => string;
+}
+export declare class HyFilterBar<C extends HyFilterToken> {
+  readonly fields: import("@angular/core").InputSignal<readonly HyFilterField<C>[]>;
+  readonly clauses: import("@angular/core").ModelSignal<readonly C[]>;
+  readonly label: import("@angular/core").InputSignal<string>;
+  readonly clearLabel: import("@angular/core").InputSignal<string>;
+  readonly removeLabel: import("@angular/core").InputSignal<string>;
+  readonly anyLabel: import("@angular/core").InputSignal<string>;
+  readonly activeLabel: import("@angular/core").InputSignal<string>;
+  protected readonly view: import("@angular/core").Signal<{
+    clause: C;
+    label: string;
+    text: string;
+    editor: TemplateRef<HyFilterEditorContext<C>> | undefined;
+    context: {
+      $implicit: C;
+      update: (next: C) => void;
+    };
+  }[]>;
+  protected raw(field: string): string;
+  protected change(field: HyFilterField<C>, raw: string): void;
+  protected remove(id: string): void;
+  private update;
+  static ɵfac: i0.ɵɵFactoryDeclaration<HyFilterBar<any>, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<HyFilterBar<any>, "hy-filter-bar", never, {
+    "fields": {
+      "alias": "fields";
+      "required": true;
+      "isSignal": true;
+    };
+    "clauses": {
+      "alias": "clauses";
+      "required": false;
+      "isSignal": true;
+    };
+    "label": {
+      "alias": "label";
+      "required": false;
+      "isSignal": true;
+    };
+    "clearLabel": {
+      "alias": "clearLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "removeLabel": {
+      "alias": "removeLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "anyLabel": {
+      "alias": "anyLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "activeLabel": {
+      "alias": "activeLabel";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "clauses": "clausesChange";
+  }, never, ["*"], true, never>;
+}

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

@@ -0,0 +1,70 @@
+import { HyMotion } from "@hyalo/angular/motion";
+import { HyPlacement } from "@hyalo/angular/overlay";
+import * as i0 from "@angular/core";
+export type HyHotspotMode = 'label' | 'pin';
+export interface HyHotspotPosition {
+  readonly x: number;
+  readonly y: number;
+  readonly visible?: boolean;
+}
+/** Pass screen coordinates from your scene's projection. Position is relative to its frame. */
+export declare class HyHotspot {
+  protected readonly motion: HyMotion;
+  readonly label: import("@angular/core").InputSignal<string>;
+  readonly position: import("@angular/core").InputSignal<HyHotspotPosition>;
+  readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Optional detail panel. Without a description this stays a plain action button. */
+  readonly description: import("@angular/core").InputSignal<string>;
+  readonly mode: import("@angular/core").InputSignal<HyHotspotMode>;
+  readonly open: import("@angular/core").ModelSignal<boolean>;
+  readonly placement: import("@angular/core").InputSignal<HyPlacement>;
+  readonly closeLabel: import("@angular/core").InputSignal<string>;
+  readonly activated: import("@angular/core").OutputEmitterRef<void>;
+  protected readonly visible: import("@angular/core").Signal<boolean>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<HyHotspot, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<HyHotspot, "hy-hotspot", never, {
+    "label": {
+      "alias": "label";
+      "required": true;
+      "isSignal": true;
+    };
+    "position": {
+      "alias": "position";
+      "required": true;
+      "isSignal": true;
+    };
+    "disabled": {
+      "alias": "disabled";
+      "required": false;
+      "isSignal": true;
+    };
+    "description": {
+      "alias": "description";
+      "required": false;
+      "isSignal": true;
+    };
+    "mode": {
+      "alias": "mode";
+      "required": false;
+      "isSignal": true;
+    };
+    "open": {
+      "alias": "open";
+      "required": false;
+      "isSignal": true;
+    };
+    "placement": {
+      "alias": "placement";
+      "required": false;
+      "isSignal": true;
+    };
+    "closeLabel": {
+      "alias": "closeLabel";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "open": "openChange";
+    "activated": "activated";
+  }, never, never, true, never>;
+}

package/types/hyalo-angular-hover-card.d.ts

@@ -0,0 +1,47 @@
+import * as i0 from "@angular/core";
+import { TemplateRef } from "@angular/core";
+import { HyPlacement } from "@hyalo/angular/overlay";
+export declare class HyHoverCard {
+  readonly content: import("@angular/core").InputSignal<TemplateRef<unknown>>;
+  readonly hoverCardLabel: import("@angular/core").InputSignal<string>;
+  readonly placement: import("@angular/core").InputSignal<HyPlacement>;
+  readonly open: import("@angular/core").WritableSignal<boolean>;
+  protected readonly id: string;
+  private readonly injector;
+  private readonly host;
+  private readonly container;
+  private readonly fidelity;
+  private readonly document;
+  private readonly intent;
+  private ref;
+  private timer;
+  private disposed;
+  private suppressFocus;
+  protected focusTrigger(): void;
+  constructor();
+  protected enter(event: PointerEvent): void;
+  protected leave(event?: PointerEvent): void;
+  protected focusOut(event: FocusEvent): void;
+  protected escape(event: Event): void;
+  protected focusCard(event: Event): void;
+  show(): void;
+  hide(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<HyHoverCard, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<HyHoverCard, "[hyHoverCard]", ["hyHoverCard"], {
+    "content": {
+      "alias": "hyHoverCard";
+      "required": true;
+      "isSignal": true;
+    };
+    "hoverCardLabel": {
+      "alias": "hoverCardLabel";
+      "required": true;
+      "isSignal": true;
+    };
+    "placement": {
+      "alias": "placement";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}

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 {};

package/types/hyalo-angular-image-compare.d.ts

@@ -0,0 +1,55 @@
+import * as i0 from "@angular/core";
+/** Native range input provides pointer, touch, keyboard and screen reader controls. */
+export declare class HyImageCompare {
+  readonly before: import("@angular/core").InputSignal<string>;
+  readonly after: import("@angular/core").InputSignal<string>;
+  readonly beforeAlt: import("@angular/core").InputSignal<string>;
+  readonly afterAlt: import("@angular/core").InputSignal<string>;
+  readonly label: import("@angular/core").InputSignal<string>;
+  readonly value: import("@angular/core").ModelSignal<number>;
+  readonly ratio: import("@angular/core").InputSignal<string>;
+  protected readonly id: string;
+  protected readonly position: import("@angular/core").Signal<number>;
+  protected readonly clip: import("@angular/core").Signal<string>;
+  protected change(event: Event): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<HyImageCompare, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<HyImageCompare, "hy-image-compare", never, {
+    "before": {
+      "alias": "before";
+      "required": true;
+      "isSignal": true;
+    };
+    "after": {
+      "alias": "after";
+      "required": true;
+      "isSignal": true;
+    };
+    "beforeAlt": {
+      "alias": "beforeAlt";
+      "required": true;
+      "isSignal": true;
+    };
+    "afterAlt": {
+      "alias": "afterAlt";
+      "required": true;
+      "isSignal": true;
+    };
+    "label": {
+      "alias": "label";
+      "required": false;
+      "isSignal": true;
+    };
+    "value": {
+      "alias": "value";
+      "required": false;
+      "isSignal": true;
+    };
+    "ratio": {
+      "alias": "ratio";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "value": "valueChange";
+  }, never, never, true, never>;
+}

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

@@ -0,0 +1,131 @@
+import * as i0 from "@angular/core";
+/** Where a revealed element comes from. */
+export type HyRevealFrom = 'up' | 'fade' | 'scale';
+/**
+ * Fades and lifts an element in when it scrolls into view.
+ *
+ * ```html
+ * @for (item of items; track item.id; let i = $index) {
+ *   <article hyReveal [revealDelay]="i * 60">...</article>
+ * }
+ * ```
+ *
+ * Content is never hidden by default. The directive only hides an element
+ * after hydration, only when it is below the fold, and only when motion is
+ * enabled. Elements already on screen are left alone, so server-rendered
+ * content does not flash. CSS transitions do the work, so it also runs on the
+ * low tier when reduced motion is off.
+ *
+ * Put it on the glass element itself (`<hy-card hyReveal>`), not on a
+ * wrapper around glass. While a wrapper fades, its glass children cannot
+ * blur what is behind it, and the blur snaps in when the fade ends.
+ */
+export declare class HyReveal {
+  private readonly el;
+  private readonly motion;
+  /** Delay in milliseconds, for staggering. */
+  readonly revealDelay: import("@angular/core").InputSignalWithTransform<number, unknown>;
+  /** The starting pose. */
+  readonly revealFrom: import("@angular/core").InputSignal<HyRevealFrom>;
+  /** Reveal again each time the element re-enters the viewport. */
+  readonly revealRepeat: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  constructor();
+  static ɵfac: i0.ɵɵFactoryDeclaration<HyReveal, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<HyReveal, "[hyReveal]", never, {
+    "revealDelay": {
+      "alias": "revealDelay";
+      "required": false;
+      "isSignal": true;
+    };
+    "revealFrom": {
+      "alias": "revealFrom";
+      "required": false;
+      "isSignal": true;
+    };
+    "revealRepeat": {
+      "alias": "revealRepeat";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+/**
+ * Tilts the element toward the cursor and moves a soft glow under it.
+ *
+ * ```html
+ * <hy-card hyTilt [tiltMax]="8">...</hy-card>
+ * ```
+ *
+ * Runs only with a fine pointer, with motion enabled and above the low
+ * fidelity tier. The glow uses `--hy-px`, `--hy-py` and `--hy-glow`, which the
+ * glass material already reads.
+ */
+export declare class HyTilt {
+  private readonly el;
+  private readonly motion;
+  /** Maximum rotation in degrees. */
+  readonly tiltMax: import("@angular/core").InputSignalWithTransform<number, unknown>;
+  /** Whether to show the pointer glow. */
+  readonly tiltGlow: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  constructor();
+  static ɵfac: i0.ɵɵFactoryDeclaration<HyTilt, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<HyTilt, "[hyTilt]", never, {
+    "tiltMax": {
+      "alias": "tiltMax";
+      "required": false;
+      "isSignal": true;
+    };
+    "tiltGlow": {
+      "alias": "tiltGlow";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+/**
+ * Pulls the element a little toward the cursor while it hovers.
+ *
+ * Uses the `translate` property, so it never fights with a `transform` the
+ * element already has.
+ */
+export declare class HyMagnetic {
+  private readonly el;
+  private readonly motion;
+  /** How far the element follows the cursor, as a share of the distance. */
+  readonly magneticStrength: import("@angular/core").InputSignalWithTransform<number, unknown>;
+  /** Upper limit for the offset in pixels. */
+  readonly magneticMax: import("@angular/core").InputSignalWithTransform<number, unknown>;
+  constructor();
+  static ɵfac: i0.ɵɵFactoryDeclaration<HyMagnetic, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<HyMagnetic, "[hyMagnetic]", never, {
+    "magneticStrength": {
+      "alias": "magneticStrength";
+      "required": false;
+      "isSignal": true;
+    };
+    "magneticMax": {
+      "alias": "magneticMax";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+/**
+ * A soft light ripple from the press point. Purely decorative: it is
+ * skipped with reduced motion and never affects layout.
+ */
+export declare class HyRipple {
+  private readonly el;
+  private readonly motion;
+  /** Turns the ripple off without removing the directive. */
+  readonly rippleDisabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  constructor();
+  static ɵfac: i0.ɵɵFactoryDeclaration<HyRipple, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<HyRipple, "[hyRipple]", never, {
+    "rippleDisabled": {
+      "alias": "rippleDisabled";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}

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

@@ -0,0 +1,5 @@
+import * as i0 from "@angular/core";
+export declare class HyKbd {
+  static ɵfac: i0.ɵɵFactoryDeclaration<HyKbd, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<HyKbd, "kbd[hyKbd]", never, {}, {}, never, ["*"], true, never>;
+}

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

@@ -0,0 +1,67 @@
+import { HyDialogRef } from "@hyalo/angular/dialog";
+import * as i0 from "@angular/core";
+export interface HyGalleryImage {
+  readonly src: string;
+  readonly alt: string;
+  readonly thumbnail?: string;
+  readonly caption?: string;
+}
+export interface HyLightboxOptions {
+  readonly index?: number;
+  readonly label?: string;
+  readonly closeLabel?: string;
+  readonly previousLabel?: string;
+  readonly nextLabel?: string;
+}
+interface GalleryData extends HyLightboxOptions {
+  readonly images: readonly HyGalleryImage[];
+}
+export declare class HyLightboxView {
+  protected readonly data: GalleryData;
+  protected readonly ref: HyDialogRef<any>;
+  protected readonly index: import("@angular/core").WritableSignal<number>;
+  protected readonly image: import("@angular/core").Signal<HyGalleryImage | undefined>;
+  protected move(delta: number): void;
+  protected onKey(event: KeyboardEvent): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<HyLightboxView, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<HyLightboxView, "hy-lightbox-view", never, {}, {}, never, never, true, never>;
+}
+/** Opens a gallery using the kit dialog's focus trap, Escape handling and focus restore. */
+export declare class HyLightbox {
+  private readonly dialog;
+  open(images: readonly HyGalleryImage[], options?: HyLightboxOptions): HyDialogRef | null;
+  static ɵfac: i0.ɵɵFactoryDeclaration<HyLightbox, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+export declare class HyGallery {
+  private readonly lightbox;
+  readonly images: import("@angular/core").InputSignal<readonly HyGalleryImage[]>;
+  readonly label: import("@angular/core").InputSignal<string>;
+  readonly openLabel: import("@angular/core").InputSignal<string>;
+  readonly options: import("@angular/core").InputSignal<HyLightboxOptions>;
+  open(index: number): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<HyGallery, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<HyGallery, "hy-gallery", never, {
+    "images": {
+      "alias": "images";
+      "required": true;
+      "isSignal": true;
+    };
+    "label": {
+      "alias": "label";
+      "required": false;
+      "isSignal": true;
+    };
+    "openLabel": {
+      "alias": "openLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "options": {
+      "alias": "options";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+export {};

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

@@ -0,0 +1,5 @@
+import * as i0 from "@angular/core";
+export declare class HyLink {
+  static ɵfac: i0.ɵɵFactoryDeclaration<HyLink, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<HyLink, "a[hyLink]", never, {}, {}, never, ["*"], true, never>;
+}

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

@@ -0,0 +1,30 @@
+import * as i0 from "@angular/core";
+export declare class HyList {
+  readonly label: import("@angular/core").InputSignal<string>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<HyList, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<HyList, "hy-list", never, {
+    "label": {
+      "alias": "label";
+      "required": true;
+      "isSignal": true;
+    };
+  }, {}, never, ["*"], true, never>;
+}
+export declare class HyListItem {
+  readonly heading: import("@angular/core").InputSignal<string>;
+  readonly description: import("@angular/core").InputSignal<string>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<HyListItem, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<HyListItem, "li[hyListItem]", never, {
+    "heading": {
+      "alias": "heading";
+      "required": true;
+      "isSignal": true;
+    };
+    "description": {
+      "alias": "description";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, ["*"], true, never>;
+}
+export declare const HY_LIST: readonly [typeof HyList, typeof HyListItem];