@hyalo/angular 0.0.0-stage → 0.3.1

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

@@ -0,0 +1,59 @@
+import * as i0 from "@angular/core";
+export declare class HyPagination {
+  readonly page: import("@angular/core").ModelSignal<number>;
+  readonly total: import("@angular/core").InputSignal<number>;
+  readonly pageSize: import("@angular/core").InputSignal<number>;
+  readonly locale: import("@angular/core").InputSignal<string | undefined>;
+  private readonly globalLocale;
+  private readonly effectiveLocale;
+  readonly label: import("@angular/core").InputSignal<string>;
+  readonly previousLabel: import("@angular/core").InputSignal<string>;
+  readonly nextLabel: import("@angular/core").InputSignal<string>;
+  readonly pageCount: import("@angular/core").Signal<number>;
+  readonly current: import("@angular/core").Signal<number>;
+  readonly pages: import("@angular/core").Signal<({
+    value: number;
+    label: string;
+  } | null)[]>;
+  go(page: number): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<HyPagination, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<HyPagination, "hy-pagination", never, {
+    "page": {
+      "alias": "page";
+      "required": false;
+      "isSignal": true;
+    };
+    "total": {
+      "alias": "total";
+      "required": true;
+      "isSignal": true;
+    };
+    "pageSize": {
+      "alias": "pageSize";
+      "required": false;
+      "isSignal": true;
+    };
+    "locale": {
+      "alias": "locale";
+      "required": false;
+      "isSignal": true;
+    };
+    "label": {
+      "alias": "label";
+      "required": false;
+      "isSignal": true;
+    };
+    "previousLabel": {
+      "alias": "previousLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "nextLabel": {
+      "alias": "nextLabel";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "page": "pageChange";
+  }, never, never, true, never>;
+}

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

@@ -0,0 +1,152 @@
+import { HyPlacement } from "@hyalo/angular/overlay";
+import * as i0 from "@angular/core";
+import { TemplateRef } from "@angular/core";
+import { HyMaterial } from "@hyalo/angular/core";
+export declare class HyTooltipPanel {
+  readonly message: import("@angular/core").WritableSignal<string>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<HyTooltipPanel, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<HyTooltipPanel, "hy-tooltip-panel", never, {}, {}, never, never, true, never>;
+}
+/**
+ * A short text hint on hover or keyboard focus.
+ *
+ * ```html
+ * <button hyButton iconOnly aria-label="Copy link" hyTooltip="Copy link">...</button>
+ * ```
+ *
+ * The text is also added to the trigger's `aria-describedby` through a
+ * hidden element, so screen readers get it without the visual tooltip. The
+ * tooltip stays open while the pointer is over it and closes on Escape, as
+ * WCAG 1.4.13 asks. Keep it short and never put interactive content in it;
+ * use `hyPopover` for that.
+ */
+export declare class HyTooltip {
+  private readonly injector;
+  private readonly host;
+  private readonly describer;
+  private overlayRef;
+  private position;
+  private panel;
+  private panelEl;
+  private readonly presence;
+  private showTimer;
+  private hideTimer;
+  /** True from show() until hide(), so a late overlay load knows to stop. */
+  private wanted;
+  private destroyed;
+  /** The tooltip text. */
+  readonly message: import("@angular/core").InputSignal<string>;
+  /** Preferred side. Flips when there is no room. */
+  readonly tooltipPlacement: import("@angular/core").InputSignal<HyPlacement>;
+  /** Hover delay in milliseconds. Focus shows it right away. */
+  readonly tooltipDelay: import("@angular/core").InputSignalWithTransform<number, unknown>;
+  readonly tooltipDisabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  constructor();
+  protected onPointerEnter(event: PointerEvent): void;
+  /** Shows the tooltip after the given delay. */
+  show(delay?: number): void;
+  /** Starts hiding the tooltip now. It fades out quickly. */
+  hide(): void;
+  protected scheduleHide(): void;
+  private attach;
+  static ɵfac: i0.ɵɵFactoryDeclaration<HyTooltip, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<HyTooltip, "[hyTooltip]", never, {
+    "message": {
+      "alias": "hyTooltip";
+      "required": false;
+      "isSignal": true;
+    };
+    "tooltipPlacement": {
+      "alias": "tooltipPlacement";
+      "required": false;
+      "isSignal": true;
+    };
+    "tooltipDelay": {
+      "alias": "tooltipDelay";
+      "required": false;
+      "isSignal": true;
+    };
+    "tooltipDisabled": {
+      "alias": "tooltipDisabled";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+/**
+ * A non-modal glass panel anchored to a trigger, for content that does not
+ * fit in a tooltip: a short form, a menu of links, details.
+ *
+ * ```html
+ * <button hyButton variant="glass" [hyPopover]="share" popoverLabel="Share">Share</button>
+ * <ng-template #share>
+ *   <a href="...">Copy link</a>
+ * </ng-template>
+ * ```
+ *
+ * Click or Enter toggles it. On open, focus moves to the first focusable
+ * element inside. Escape closes it and returns focus to the trigger, and so
+ * does clicking outside or tabbing out of it.
+ */
+export declare class HyPopover {
+  private readonly injector;
+  private readonly host;
+  private readonly viewContainer;
+  private readonly focusTraps;
+  private readonly fidelity;
+  protected readonly panelId: string;
+  private overlayRef;
+  private position;
+  private readonly presence;
+  private destroyed;
+  private positioned;
+  /** The content. */
+  readonly content: import("@angular/core").InputSignal<TemplateRef<unknown>>;
+  /** Accessible name of the panel. */
+  readonly popoverLabel: import("@angular/core").InputSignal<string | undefined>;
+  /** Use solid over image content when the background would reduce text contrast. */
+  readonly popoverMaterial: import("@angular/core").InputSignal<HyMaterial>;
+  /** Preferred side. Flips when there is no room. */
+  readonly popoverPlacement: import("@angular/core").InputSignal<HyPlacement>;
+  /** Whether the panel is open. Two-way bindable as `[(popoverOpen)]`. */
+  readonly open: import("@angular/core").ModelSignal<boolean>;
+  constructor();
+  toggle(): void;
+  /** Closes the panel, optionally moving focus back to the trigger. */
+  close(restoreFocus?: boolean): void;
+  protected preload(): void;
+  private attach;
+  private reveal;
+  private detach;
+  private readonly onFocusOut;
+  static ɵfac: i0.ɵɵFactoryDeclaration<HyPopover, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<HyPopover, "[hyPopover]", ["hyPopover"], {
+    "content": {
+      "alias": "hyPopover";
+      "required": true;
+      "isSignal": true;
+    };
+    "popoverLabel": {
+      "alias": "popoverLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "popoverMaterial": {
+      "alias": "popoverMaterial";
+      "required": false;
+      "isSignal": true;
+    };
+    "popoverPlacement": {
+      "alias": "popoverPlacement";
+      "required": false;
+      "isSignal": true;
+    };
+    "open": {
+      "alias": "popoverOpen";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "open": "popoverOpenChange";
+  }, never, never, true, never>;
+}

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

@@ -0,0 +1,46 @@
+import { HyMotion } from "@hyalo/angular/motion";
+import * as i0 from "@angular/core";
+export declare class HyProgress {
+  protected readonly motion: HyMotion;
+  private readonly host;
+  private readonly document;
+  private readonly visible;
+  private readonly foreground;
+  protected readonly moving: import("@angular/core").Signal<boolean>;
+  constructor();
+  readonly value: import("@angular/core").InputSignal<number | null>;
+  readonly label: import("@angular/core").InputSignal<string>;
+  readonly variant: import("@angular/core").InputSignal<"bar" | "circle">;
+  readonly amount: import("@angular/core").Signal<number | null>;
+  readonly offset: import("@angular/core").Signal<number>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<HyProgress, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<HyProgress, "hy-progress", never, {
+    "value": {
+      "alias": "value";
+      "required": false;
+      "isSignal": true;
+    };
+    "label": {
+      "alias": "label";
+      "required": true;
+      "isSignal": true;
+    };
+    "variant": {
+      "alias": "variant";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+export declare class HySpinner {
+  readonly label: import("@angular/core").InputSignal<string>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<HySpinner, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<HySpinner, "hy-spinner", never, {
+    "label": {
+      "alias": "label";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+export declare const HY_PROGRESS: readonly [typeof HyProgress, typeof HySpinner];

package/types/hyalo-angular-progressive-blur.d.ts

@@ -0,0 +1,14 @@
+import * as i0 from "@angular/core";
+export declare class HyProgressiveBlur {
+  readonly edge: import("@angular/core").InputSignal<"top" | "bottom">;
+  private readonly fidelity;
+  protected readonly blur: import("@angular/core").Signal<boolean>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<HyProgressiveBlur, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<HyProgressiveBlur, "hy-progressive-blur", never, {
+    "edge": {
+      "alias": "edge";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}

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

@@ -0,0 +1,46 @@
+import * as i0 from "@angular/core";
+import * as i1 from "@hyalo/angular/core";
+/** One WebGL context shared by all surfaces; each surface receives a 2D copy. */
+interface RefractionTarget {
+  readonly canvas: HTMLCanvasElement;
+  readonly src: string;
+  readonly strength: () => number;
+}
+export declare class HyRefractionRenderer {
+  private readonly document;
+  private renderer;
+  constructor();
+  register(target: RefractionTarget): Promise<() => void>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<HyRefractionRenderer, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+/** Supply the scene image explicitly. WebGL cannot sample arbitrary DOM backdrops. */
+export declare class HyRefraction {
+  private readonly fidelity;
+  private readonly renderer;
+  private readonly ready;
+  private readonly canvas;
+  readonly src: import("@angular/core").InputSignal<string>;
+  readonly strength: import("@angular/core").InputSignal<number>;
+  constructor();
+  static ɵfac: i0.ɵɵFactoryDeclaration<HyRefraction, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<HyRefraction, "hy-refraction", never, {
+    "src": {
+      "alias": "src";
+      "required": false;
+      "isSignal": true;
+    };
+    "strength": {
+      "alias": "strength";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, ["*"], true, [{
+    directive: typeof i1.HyMaterialDirective;
+    inputs: {
+      "hyMaterial": "material";
+    };
+    outputs: {};
+  }]>;
+}
+export {};

package/types/hyalo-angular-scroll-area.d.ts

@@ -0,0 +1,18 @@
+import * as i0 from "@angular/core";
+export declare class HyScrollArea {
+  readonly label: import("@angular/core").InputSignal<string>;
+  readonly maxHeight: import("@angular/core").InputSignal<string>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<HyScrollArea, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<HyScrollArea, "hy-scroll-area", never, {
+    "label": {
+      "alias": "label";
+      "required": true;
+      "isSignal": true;
+    };
+    "maxHeight": {
+      "alias": "maxHeight";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, ["*"], true, never>;
+}

package/types/hyalo-angular-scroll-to-top.d.ts

@@ -0,0 +1,31 @@
+import * as i0 from "@angular/core";
+export declare class HyScrollToTop {
+  private readonly document;
+  private readonly motion;
+  private readonly browser;
+  readonly label: import("@angular/core").InputSignal<string>;
+  readonly threshold: import("@angular/core").InputSignal<number>;
+  /** Focus this heading or landmark after scrolling, so keyboard users return too. */
+  readonly targetId: import("@angular/core").InputSignal<string | null>;
+  protected readonly visible: import("@angular/core").WritableSignal<boolean>;
+  constructor();
+  scroll(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<HyScrollToTop, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<HyScrollToTop, "hy-scroll-to-top", never, {
+    "label": {
+      "alias": "label";
+      "required": false;
+      "isSignal": true;
+    };
+    "threshold": {
+      "alias": "threshold";
+      "required": false;
+      "isSignal": true;
+    };
+    "targetId": {
+      "alias": "targetId";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}

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

@@ -0,0 +1,79 @@
+import { FormValueControl } from "@angular/forms/signals";
+import { HySize } from "@hyalo/angular/core";
+import * as i0 from "@angular/core";
+/** One choice in a segmented control. */
+export interface HySegmentedOption<T> {
+  readonly value: T;
+  readonly label: string;
+  readonly icon?: string;
+  readonly disabled?: boolean;
+}
+/**
+ * A segmented control: a small set of mutually exclusive choices with the
+ * same sliding indicator as tabs. Use it to pick a value (billing period, a
+ * view mode). Use tabs when each choice shows a different panel.
+ *
+ * It is a group of native radio buttons, so arrow keys, form submission and
+ * screen readers behave as users expect. Works with Signal Forms through
+ * `[formField]`, or with `[(value)]`.
+ *
+ * ```html
+ * <hy-segmented label="Billing" [options]="periods" [(value)]="period" />
+ * ```
+ */
+export declare class HySegmented<T> implements FormValueControl<T | undefined> {
+  protected readonly groupName: string;
+  private readonly row;
+  private readonly items;
+  /** The choices. */
+  readonly options: import("@angular/core").InputSignal<readonly HySegmentedOption<T>[]>;
+  /** Selected value. Two-way bindable. */
+  readonly value: import("@angular/core").ModelSignal<T | undefined>;
+  /** Accessible name of the group. */
+  readonly label: import("@angular/core").InputSignal<string | undefined>;
+  /** Name shared by the radio inputs. Generated when not set. */
+  readonly name: import("@angular/core").InputSignal<string>;
+  /** Disables every option. */
+  readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Control size. */
+  readonly size: import("@angular/core").InputSignal<HySize>;
+  /** Emits when focus leaves an option, so forms can mark the field touched. */
+  readonly touch: import("@angular/core").OutputEmitterRef<void>;
+  protected readonly ready: import("@angular/core").Signal<boolean>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<HySegmented<any>, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<HySegmented<any>, "hy-segmented", never, {
+    "options": {
+      "alias": "options";
+      "required": true;
+      "isSignal": true;
+    };
+    "value": {
+      "alias": "value";
+      "required": false;
+      "isSignal": true;
+    };
+    "label": {
+      "alias": "label";
+      "required": false;
+      "isSignal": true;
+    };
+    "name": {
+      "alias": "name";
+      "required": false;
+      "isSignal": true;
+    };
+    "disabled": {
+      "alias": "disabled";
+      "required": false;
+      "isSignal": true;
+    };
+    "size": {
+      "alias": "size";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "value": "valueChange";
+    "touch": "touch";
+  }, never, never, true, never>;
+}

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

@@ -0,0 +1,176 @@
+import * as i0 from "@angular/core";
+import { TemplateRef } from "@angular/core";
+import { FormValueControl } from "@angular/forms/signals";
+import { HyFieldControl } from "@hyalo/angular/field";
+/** One choice in a select. */
+export interface HySelectOption<T> {
+  readonly key?: string | number;
+  readonly group?: {
+    readonly key: string;
+    readonly label: string;
+    readonly disabled?: boolean;
+  };
+  readonly value: T;
+  readonly label: string;
+  readonly disabled?: boolean;
+}
+export interface HySelectOptionContext<T> {
+  readonly $implicit: HySelectOption<T>;
+}
+/**
+ * A single-choice select with a glass dropdown, built on Angular Aria's
+ * combobox and listbox patterns.
+ *
+ * ```html
+ * <hy-field label="Strap">
+ *   <hy-select [options]="straps" [formField]="form.strap" placeholder="Choose a strap" />
+ * </hy-field>
+ * ```
+ *
+ * Focus stays on the trigger while the list is open, and options are
+ * announced through `aria-activedescendant`. Arrow keys move, Enter or
+ * Space picks, Escape closes, and typing jumps to a matching option.
+ *
+ * On the low fidelity tier, or with `native`, it renders a real `<select>`
+ * instead. That gives the platform picker on phones and costs nothing.
+ */
+export declare class HySelect<T> implements FormValueControl<T | undefined>, HyFieldControl {
+  private readonly fidelity;
+  private readonly host;
+  private readonly document;
+  private readonly destroy;
+  private readonly ready;
+  protected readonly field: import("@hyalo/angular/field").HyFieldContext | null;
+  private readonly trigger;
+  private readonly overlay;
+  private readonly presence;
+  /** The choices. */
+  readonly options: import("@angular/core").InputSignal<readonly HySelectOption<T>[]>;
+  /** Selected value. Two-way bindable and works with `[formField]`. */
+  readonly value: import("@angular/core").ModelSignal<T | undefined>;
+  /** Text shown while nothing is selected. */
+  readonly placeholder: import("@angular/core").InputSignal<string>;
+  readonly name: import("@angular/core").InputSignal<string>;
+  readonly optionTemplate: import("@angular/core").InputSignal<TemplateRef<HySelectOptionContext<T>> | undefined>;
+  /** Disables the select. Set automatically by Signal Forms. */
+  readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Marks the field as required. Set automatically by Signal Forms. */
+  readonly required: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Set by Signal Forms. */
+  readonly invalid: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Set by Signal Forms. Only the first message is shown. */
+  readonly errors: import("@angular/core").InputSignal<readonly {
+    readonly kind: string;
+    readonly message?: string;
+  }[]>;
+  /** Set by Signal Forms. Errors show only after the field is touched. */
+  readonly touched: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Always render a native `<select>`. */
+  readonly native: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Emits when the control loses focus, so forms can mark it touched. */
+  readonly touch: import("@angular/core").OutputEmitterRef<void>;
+  readonly labelable = true;
+  protected readonly nativeId: string;
+  protected readonly triggerId: string;
+  readonly id: import("@angular/core").Signal<string>;
+  readonly errorMessage: import("@angular/core").Signal<string | undefined>;
+  protected readonly expanded: import("@angular/core").WritableSignal<boolean>;
+  /** Stays true while the panel fades out after `expanded` turns false. */
+  protected readonly rendered: import("@angular/core").WritableSignal<boolean>;
+  protected readonly positions: import("@angular/cdk/overlay").ConnectedPosition[];
+  protected readonly panelWidth: import("@angular/core").WritableSignal<number>;
+  protected readonly useNative: import("@angular/core").WritableSignal<boolean>;
+  protected readonly keyedOptions: import("@angular/core").Signal<{
+    option: HySelectOption<T>;
+    key: string;
+    disabled: boolean;
+    context: {
+      $implicit: HySelectOption<T>;
+    };
+  }[]>;
+  protected readonly groups: import("@angular/core").Signal<{
+    key: string;
+    label: string;
+    options: {
+      option: HySelectOption<T>;
+      key: string;
+      disabled: boolean;
+      context: HySelectOptionContext<T>;
+    }[];
+  }[]>;
+  protected readonly selectedOption: import("@angular/core").Signal<HySelectOption<T> | undefined>;
+  protected readonly listValue: import("@angular/core").Signal<(T & ({} | null))[]>;
+  protected readonly showsError: import("@angular/core").Signal<boolean>;
+  constructor();
+  protected setExpanded(open: boolean): void;
+  /** Runs when the overlay attaches a fresh panel. */
+  protected onAttach(): void;
+  private panelElement;
+  protected pick(values: readonly T[]): void;
+  /** Closes after a click on an option, including the one already selected. */
+  protected onPanelClick(event: MouseEvent): void;
+  protected close(): void;
+  protected scheduleMode(): void;
+  protected pickNative(event: Event): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<HySelect<any>, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<HySelect<any>, "hy-select", never, {
+    "options": {
+      "alias": "options";
+      "required": true;
+      "isSignal": true;
+    };
+    "value": {
+      "alias": "value";
+      "required": false;
+      "isSignal": true;
+    };
+    "placeholder": {
+      "alias": "placeholder";
+      "required": false;
+      "isSignal": true;
+    };
+    "name": {
+      "alias": "name";
+      "required": false;
+      "isSignal": true;
+    };
+    "optionTemplate": {
+      "alias": "optionTemplate";
+      "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;
+    };
+    "errors": {
+      "alias": "errors";
+      "required": false;
+      "isSignal": true;
+    };
+    "touched": {
+      "alias": "touched";
+      "required": false;
+      "isSignal": true;
+    };
+    "native": {
+      "alias": "native";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "value": "valueChange";
+    "touch": "touch";
+  }, never, never, true, never>;
+}

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

@@ -0,0 +1,57 @@
+import * as i0 from "@angular/core";
+export declare class HySidebar {
+  readonly collapsed: import("@angular/core").ModelSignal<boolean>;
+  protected readonly toggle: (value: boolean) => boolean;
+  readonly label: import("@angular/core").InputSignal<string>;
+  readonly collapseLabel: import("@angular/core").InputSignal<string>;
+  readonly expandLabel: import("@angular/core").InputSignal<string>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<HySidebar, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<HySidebar, "hy-sidebar", never, {
+    "collapsed": {
+      "alias": "collapsed";
+      "required": false;
+      "isSignal": true;
+    };
+    "label": {
+      "alias": "label";
+      "required": false;
+      "isSignal": true;
+    };
+    "collapseLabel": {
+      "alias": "collapseLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "expandLabel": {
+      "alias": "expandLabel";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "collapsed": "collapsedChange";
+  }, never, ["[hySidebarBrand]", "*", "[hySidebarFooter]"], true, never>;
+}
+export declare class HySidebarItem {
+  readonly label: import("@angular/core").InputSignal<string>;
+  readonly icon: import("@angular/core").InputSignal<string>;
+  readonly active: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<HySidebarItem, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<HySidebarItem, "a[hySidebarItem]", never, {
+    "label": {
+      "alias": "label";
+      "required": true;
+      "isSignal": true;
+    };
+    "icon": {
+      "alias": "icon";
+      "required": true;
+      "isSignal": true;
+    };
+    "active": {
+      "alias": "active";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, ["*"], true, never>;
+}
+export declare const HY_SIDEBAR: readonly [typeof HySidebar, typeof HySidebarItem];