@billy_mcdowell/prmn-angular-v3 0.0.1

package/index.d.ts

@@ -0,0 +1,2790 @@
+import * as i0 from '@angular/core';
+import { ValueProvider, TemplateRef, DoCheck, Signal, InjectionToken, ElementRef, Type, ExistingProvider, Injector } from '@angular/core';
+import * as i1 from '@spartan-ng/brain/accordion';
+import * as class_variance_authority_types from 'class-variance-authority/types';
+import { VariantProps } from 'class-variance-authority';
+import * as i1$2 from '@spartan-ng/brain/alert-dialog';
+import { BrnAlertDialog } from '@spartan-ng/brain/alert-dialog';
+import * as i1$1 from '@spartan-ng/brain/button';
+import { ClassValue } from 'clsx';
+import { NumberInput, BooleanInput } from '@angular/cdk/coercion';
+import * as i1$3 from '@spartan-ng/brain/autocomplete';
+import * as i1$4 from '@spartan-ng/brain/popover';
+import * as i1$5 from '@spartan-ng/brain/avatar';
+import { BrnAvatar } from '@spartan-ng/brain/avatar';
+import * as _angular_router from '@angular/router';
+import * as i1$6 from '@spartan-ng/brain/separator';
+import * as _spartan_ng_brain_date_time from '@spartan-ng/brain/date-time';
+import * as _spartan_ng_brain_calendar from '@spartan-ng/brain/calendar';
+import { Weekday } from '@spartan-ng/brain/calendar';
+import { ControlValueAccessor, NgControl } from '@angular/forms';
+import { ChangeFn, TouchFn } from '@spartan-ng/brain/forms';
+import * as i1$7 from '@spartan-ng/brain/collapsible';
+import * as i1$8 from '@spartan-ng/brain/command';
+import * as i1$a from '@spartan-ng/brain/dialog';
+import { BrnDialogState, BrnDialog, BrnDialogOptions } from '@spartan-ng/brain/dialog';
+import * as _spartan_ng_brain_core from '@spartan-ng/brain/core';
+import { MenuAlign, MenuSide } from '@spartan-ng/brain/core';
+import * as i1$9 from '@angular/cdk/menu';
+import * as i1$b from '@spartan-ng/brain/label';
+import { BrnFormFieldControl } from '@spartan-ng/brain/form-field';
+import * as i1$c from '@spartan-ng/brain/hover-card';
+import { NgIcon } from '@ng-icons/core';
+import * as i1$d from '@spartan-ng/brain/navigation-menu';
+import * as i1$e from '@spartan-ng/brain/progress';
+import * as i1$f from '@spartan-ng/brain/radio-group';
+import { BrnRadioChange } from '@spartan-ng/brain/radio-group';
+import * as i1$g from '@spartan-ng/brain/resizable';
+import { BrnResizableHandle } from '@spartan-ng/brain/resizable';
+import * as i1$h from '@spartan-ng/brain/select';
+import { BrnSelectOption, BrnSelect } from '@spartan-ng/brain/select';
+import * as i1$i from '@spartan-ng/brain/sheet';
+import { BrnSheet } from '@spartan-ng/brain/sheet';
+import * as i1$j from '@spartan-ng/brain/tooltip';
+import * as i1$k from '@spartan-ng/brain/slider';
+import { BrnSlider } from '@spartan-ng/brain/slider';
+import * as ngx_sonner from 'ngx-sonner';
+import * as i1$l from '@spartan-ng/brain/tabs';
+import { BrnTabsPaginatedList, BrnTabsTrigger, BrnPaginatedTabHeaderItem } from '@spartan-ng/brain/tabs';
+import { Observable } from 'rxjs';
+import * as i1$m from '@spartan-ng/brain/toggle';
+import * as i1$n from '@spartan-ng/brain/toggle-group';
+import * as _billy_mcdowell_prmn_angular_v3 from '@billy_mcdowell/prmn-angular-v3';
+import { ComponentType } from '@angular/cdk/portal';
+
+declare class HlmAccordion {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmAccordion, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmAccordion, "[hlmAccordion], hlm-accordion", never, {}, {}, never, never, true, [{ directive: typeof i1.BrnAccordion; inputs: { "type": "type"; "dir": "dir"; "orientation": "orientation"; }; outputs: {}; }]>;
+}
+
+declare class HlmAccordionContent {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmAccordionContent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HlmAccordionContent, "hlm-accordion-content", never, {}, {}, never, ["*"], true, [{ directive: typeof i1.BrnAccordionContent; inputs: { "style": "style"; }; outputs: {}; }]>;
+}
+
+declare class HlmAccordionIcon {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmAccordionIcon, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmAccordionIcon, "ng-icon[hlmAccordionIcon], ng-icon[hlmAccIcon]", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmAccordionItem {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmAccordionItem, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmAccordionItem, "[hlmAccordionItem],brn-accordion-item[hlm],hlm-accordion-item", never, {}, {}, never, never, true, [{ directive: typeof i1.BrnAccordionItem; inputs: { "isOpened": "isOpened"; }; outputs: { "openedChange": "openedChange"; }; }]>;
+}
+
+declare class HlmAccordionTrigger {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmAccordionTrigger, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmAccordionTrigger, "[hlmAccordionTrigger]", never, {}, {}, never, never, true, [{ directive: typeof i1.BrnAccordionTrigger; inputs: {}; outputs: {}; }]>;
+}
+
+declare const HlmAccordionImports: readonly [typeof HlmAccordion, typeof HlmAccordionItem, typeof HlmAccordionTrigger, typeof HlmAccordionIcon, typeof HlmAccordionContent];
+
+declare const alertVariants: (props?: ({
+    variant?: "default" | "destructive" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type AlertVariants = VariantProps<typeof alertVariants>;
+declare class HlmAlert {
+    readonly variant: i0.InputSignal<"default" | "destructive" | null | undefined>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmAlert, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmAlert, "[hlmAlert]", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class HlmAlertDescription {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmAlertDescription, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmAlertDescription, "[hlmAlertDesc],[hlmAlertDescription]", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmAlertIcon {
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmAlertIcon, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmAlertIcon, "[hlmAlertIcon]", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmAlertTitle {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmAlertTitle, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmAlertTitle, "[hlmAlertTitle]", never, {}, {}, never, never, true, never>;
+}
+
+declare const HlmAlertImports: readonly [typeof HlmAlert, typeof HlmAlertTitle, typeof HlmAlertDescription, typeof HlmAlertIcon];
+
+declare class HlmAlertDialog extends BrnAlertDialog {
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmAlertDialog, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HlmAlertDialog, "hlm-alert-dialog", ["hlmAlertDialog"], {}, {}, never, ["*"], true, never>;
+}
+
+declare const buttonVariants: (props?: ({
+    variant?: "default" | "destructive" | "outline" | "secondary" | "ghost" | "link" | null | undefined;
+    size?: "xs" | "sm" | "lg" | "default" | "icon" | "icon-xs" | "icon-sm" | "icon-lg" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type ButtonVariants = VariantProps<typeof buttonVariants>;
+declare class HlmButton {
+    private readonly _config;
+    private readonly _additionalClasses;
+    readonly variant: i0.InputSignal<"default" | "destructive" | "outline" | "secondary" | "ghost" | "link" | null | undefined>;
+    readonly size: i0.InputSignal<"xs" | "sm" | "lg" | "default" | "icon" | "icon-xs" | "icon-sm" | "icon-lg" | null | undefined>;
+    constructor();
+    setClass(classes: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmButton, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmButton, "button[hlmBtn], a[hlmBtn]", ["hlmBtn"], { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1$1.BrnButton; inputs: { "disabled": "disabled"; }; outputs: {}; }]>;
+}
+
+declare class HlmAlertDialogAction {
+    readonly type: i0.InputSignal<"button" | "submit" | "reset">;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmAlertDialogAction, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmAlertDialogAction, "button[hlmAlertDialogAction]", never, { "type": { "alias": "type"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof HlmButton; inputs: { "variant": "variant"; "size": "size"; }; outputs: {}; }]>;
+}
+
+declare class HlmAlertDialogCancel {
+    readonly type: i0.InputSignal<"button" | "submit" | "reset">;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmAlertDialogCancel, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmAlertDialogCancel, "button[hlmAlertDialogCancel]", never, { "type": { "alias": "type"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof HlmButton; inputs: { "variant": "variant"; "size": "size"; }; outputs: {}; }]>;
+}
+
+declare class HlmAlertDialogContent {
+    private readonly _stateProvider;
+    readonly state: i0.Signal<"open" | "closed">;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmAlertDialogContent, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmAlertDialogContent, "[hlmAlertDialogContent],hlm-alert-dialog-content", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmAlertDialogDescription {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmAlertDialogDescription, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmAlertDialogDescription, "[hlmAlertDialogDescription]", never, {}, {}, never, never, true, [{ directive: typeof i1$2.BrnAlertDialogDescription; inputs: {}; outputs: {}; }]>;
+}
+
+declare class HlmAlertDialogFooter {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmAlertDialogFooter, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmAlertDialogFooter, "[hlmAlertDialogFooter],hlm-alert-dialog-footer", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmAlertDialogHeader {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmAlertDialogHeader, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmAlertDialogHeader, "[hlmAlertDialogHeader],hlm-alert-dialog-header", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmAlertDialogOverlay {
+    private readonly _classSettable;
+    readonly userClass: i0.InputSignal<ClassValue>;
+    protected readonly _computedClass: i0.Signal<string>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmAlertDialogOverlay, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmAlertDialogOverlay, "[hlmAlertDialogOverlay],hlm-alert-dialog-overlay", never, { "userClass": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1$2.BrnAlertDialogOverlay; inputs: {}; outputs: {}; }]>;
+}
+
+declare class HlmAlertDialogPortal {
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmAlertDialogPortal, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmAlertDialogPortal, "[hlmAlertDialogPortal]", never, {}, {}, never, never, true, [{ directive: typeof i1$2.BrnAlertDialogContent; inputs: { "context": "context"; "class": "class"; }; outputs: {}; }]>;
+}
+
+declare class HlmAlertDialogTitle {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmAlertDialogTitle, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmAlertDialogTitle, "[hlmAlertDialogTitle]", never, {}, {}, never, never, true, [{ directive: typeof i1$2.BrnAlertDialogTitle; inputs: {}; outputs: {}; }]>;
+}
+
+declare class HlmAlertDialogTrigger {
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmAlertDialogTrigger, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmAlertDialogTrigger, "button[hlmAlertDialogTrigger],button[hlmAlertDialogTriggerFor]", never, {}, {}, never, never, true, [{ directive: typeof i1$2.BrnAlertDialogTrigger; inputs: { "id": "id"; "brnAlertDialogTriggerFor": "hlmAlertDialogTriggerFor"; "type": "type"; }; outputs: {}; }]>;
+}
+
+declare const HlmAlertDialogImports: readonly [typeof HlmAlertDialog, typeof HlmAlertDialogAction, typeof HlmAlertDialogCancel, typeof HlmAlertDialogContent, typeof HlmAlertDialogDescription, typeof HlmAlertDialogFooter, typeof HlmAlertDialogHeader, typeof HlmAlertDialogOverlay, typeof HlmAlertDialogPortal, typeof HlmAlertDialogTitle, typeof HlmAlertDialogTrigger];
+
+declare class HlmAspectRatio {
+    /**
+     * Aspect ratio of the element, defined as width / height.
+     */
+    readonly ratio: i0.InputSignalWithTransform<number, NumberInput>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmAspectRatio, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmAspectRatio, "[hlmAspectRatio]", never, { "ratio": { "alias": "hlmAspectRatio"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare const HlmAspectRatioImports: readonly [typeof HlmAspectRatio];
+
+declare class HlmAutocomplete {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmAutocomplete, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmAutocomplete, "[hlmAutocomplete],hlm-autocomplete", never, {}, {}, never, never, true, [{ directive: typeof i1$3.BrnAutocomplete; inputs: { "autoHighlight": "autoHighlight"; "disabled": "disabled"; "value": "value"; "search": "search"; "itemToString": "itemToString"; "isItemEqualToValue": "isItemEqualToValue"; }; outputs: { "valueChange": "valueChange"; "searchChange": "searchChange"; }; }, { directive: typeof i1$4.BrnPopover; inputs: { "align": "align"; "autoFocus": "autoFocus"; "closeDelay": "closeDelay"; "closeOnOutsidePointerEvents": "closeOnOutsidePointerEvents"; "sideOffset": "sideOffset"; "state": "state"; "offsetX": "offsetX"; "restoreFocus": "restoreFocus"; }; outputs: { "stateChanged": "stateChanged"; "closed": "closed"; }; }]>;
+}
+
+declare class HlmAutocompleteContent {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmAutocompleteContent, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmAutocompleteContent, "[hlmAutocompleteContent],hlm-autocomplete-content", never, {}, {}, never, never, true, [{ directive: typeof i1$3.BrnAutocompleteContent; inputs: {}; outputs: {}; }]>;
+}
+
+declare class HlmAutocompleteEmpty {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmAutocompleteEmpty, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmAutocompleteEmpty, "[hlmAutocompleteEmpty],hlm-autocomplete-empty", never, {}, {}, never, never, true, [{ directive: typeof i1$3.BrnAutocompleteEmpty; inputs: {}; outputs: {}; }]>;
+}
+
+declare class HlmAutocompleteGroup {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmAutocompleteGroup, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmAutocompleteGroup, "[hlmAutocompleteGroup]", never, {}, {}, never, never, true, [{ directive: typeof i1$3.BrnAutocompleteGroup; inputs: {}; outputs: {}; }]>;
+}
+
+declare class HlmAutocompleteInput {
+    readonly placeholder: i0.InputSignal<string>;
+    readonly showSearch: i0.InputSignalWithTransform<boolean, BooleanInput>;
+    readonly showClear: i0.InputSignalWithTransform<boolean, BooleanInput>;
+    readonly ariaInvalid: i0.InputSignalWithTransform<boolean, BooleanInput>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmAutocompleteInput, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HlmAutocompleteInput, "hlm-autocomplete-input", never, { "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "showSearch": { "alias": "showSearch"; "required": false; "isSignal": true; }; "showClear": { "alias": "showClear"; "required": false; "isSignal": true; }; "ariaInvalid": { "alias": "aria-invalid"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, [{ directive: typeof i1$3.BrnAutocompleteInputWrapper; inputs: {}; outputs: {}; }]>;
+}
+
+declare class HlmAutocompleteItem {
+    private readonly _brnAutocompleteItem;
+    protected readonly _active: i0.Signal<boolean>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmAutocompleteItem, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HlmAutocompleteItem, "hlm-autocomplete-item", never, {}, {}, never, ["*"], true, [{ directive: typeof i1$3.BrnAutocompleteItem; inputs: { "id": "id"; "disabled": "disabled"; "value": "value"; }; outputs: {}; }]>;
+}
+
+declare class HlmAutocompleteLabel {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmAutocompleteLabel, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmAutocompleteLabel, "[hlmAutocompleteLabel]", never, {}, {}, never, never, true, [{ directive: typeof i1$3.BrnAutocompleteLabel; inputs: { "id": "id"; }; outputs: {}; }]>;
+}
+
+declare class HlmAutocompleteList {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmAutocompleteList, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmAutocompleteList, "[hlmAutocompleteList]", never, {}, {}, never, never, true, [{ directive: typeof i1$3.BrnAutocompleteList; inputs: { "id": "id"; }; outputs: {}; }]>;
+}
+
+declare class HlmAutocompletePortal {
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmAutocompletePortal, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmAutocompletePortal, "[hlmAutocompletePortal]", never, {}, {}, never, never, true, [{ directive: typeof i1$4.BrnPopoverContent; inputs: { "context": "context"; "class": "class"; }; outputs: {}; }]>;
+}
+
+declare class HlmAutocompleteSearch {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmAutocompleteSearch, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmAutocompleteSearch, "[hlmAutocompleteSearch],hlm-autocomplete-search", never, {}, {}, never, never, true, [{ directive: typeof i1$3.BrnAutocompleteSearch; inputs: { "autoHighlight": "autoHighlight"; "disabled": "disabled"; "value": "value"; "search": "search"; "itemToString": "itemToString"; }; outputs: { "valueChange": "valueChange"; "searchChange": "searchChange"; }; }, { directive: typeof i1$4.BrnPopover; inputs: { "align": "align"; "autoFocus": "autoFocus"; "closeDelay": "closeDelay"; "closeOnOutsidePointerEvents": "closeOnOutsidePointerEvents"; "sideOffset": "sideOffset"; "state": "state"; "offsetX": "offsetX"; "restoreFocus": "restoreFocus"; }; outputs: { "stateChanged": "stateChanged"; "closed": "closed"; }; }]>;
+}
+
+declare class HlmAutocompleteSeparator {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmAutocompleteSeparator, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmAutocompleteSeparator, "[hlmAutocompleteSeparator]", never, {}, {}, never, never, true, [{ directive: typeof i1$3.BrnAutocompleteSeparator; inputs: { "orientation": "orientation"; }; outputs: {}; }]>;
+}
+
+declare class HlmAutocompleteStatus {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmAutocompleteStatus, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmAutocompleteStatus, "[hlmAutocompleteStatus],hlm-autocomplete-status", never, {}, {}, never, never, true, [{ directive: typeof i1$3.BrnAutocompleteStatus; inputs: {}; outputs: {}; }]>;
+}
+
+declare const HlmAutocompleteImports: readonly [typeof HlmAutocomplete, typeof HlmAutocompleteContent, typeof HlmAutocompleteEmpty, typeof HlmAutocompleteGroup, typeof HlmAutocompleteInput, typeof HlmAutocompleteItem, typeof HlmAutocompleteLabel, typeof HlmAutocompleteList, typeof HlmAutocompletePortal, typeof HlmAutocompleteSearch, typeof HlmAutocompleteSeparator, typeof HlmAutocompleteStatus];
+
+declare class HlmAvatar extends BrnAvatar {
+    readonly size: i0.InputSignal<"sm" | "lg" | "default">;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmAvatar, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HlmAvatar, "hlm-avatar", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, never, ["[hlmAvatarImage],[brnAvatarImage]", "[hlmAvatarFallback],[brnAvatarFallback]", "*"], true, never>;
+}
+
+declare class HlmAvatarBadge {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmAvatarBadge, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmAvatarBadge, "[hlmAvatarBadge],hlm-avatar-badge", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmAvatarFallback {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmAvatarFallback, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmAvatarFallback, "[hlmAvatarFallback]", ["avatarFallback"], {}, {}, never, never, true, [{ directive: typeof i1$5.BrnAvatarFallback; inputs: {}; outputs: {}; }]>;
+}
+
+declare class HlmAvatarGroup {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmAvatarGroup, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmAvatarGroup, "[hlmAvatarGroup],hlm-avatar-group", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmAvatarGroupCount {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmAvatarGroupCount, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmAvatarGroupCount, "[hlmAvatarGroupCount],hlm-avatar-group-count", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmAvatarImage {
+    readonly canShow: i0.Signal<boolean>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmAvatarImage, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmAvatarImage, "img[hlmAvatarImage]", ["avatarImage"], {}, {}, never, never, true, [{ directive: typeof i1$5.BrnAvatarImage; inputs: {}; outputs: {}; }]>;
+}
+
+declare const HlmAvatarImports: readonly [typeof HlmAvatar, typeof HlmAvatarBadge, typeof HlmAvatarFallback, typeof HlmAvatarGroup, typeof HlmAvatarGroupCount, typeof HlmAvatarImage];
+
+declare const badgeVariants: (props?: ({
+    variant?: "default" | "destructive" | "outline" | "secondary" | "ghost" | "link" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type BadgeVariants = VariantProps<typeof badgeVariants>;
+declare class HlmBadge {
+    readonly variant: i0.InputSignal<"default" | "destructive" | "outline" | "secondary" | "ghost" | "link" | null | undefined>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmBadge, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmBadge, "[hlmBadge],hlm-badge", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare const HlmBadgeImports: readonly [typeof HlmBadge];
+
+declare class HlmBreadcrumb {
+    readonly ariaLabel: i0.InputSignal<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmBreadcrumb, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmBreadcrumb, "[hlmBreadcrumb]", never, { "ariaLabel": { "alias": "aria-label"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class HlmBreadcrumbEllipsis {
+    readonly userClass: i0.InputSignal<ClassValue>;
+    /** Screen reader only text for the ellipsis */
+    readonly srOnlyText: i0.InputSignal<string>;
+    protected readonly _computedClass: i0.Signal<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmBreadcrumbEllipsis, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HlmBreadcrumbEllipsis, "hlm-breadcrumb-ellipsis", never, { "userClass": { "alias": "class"; "required": false; "isSignal": true; }; "srOnlyText": { "alias": "srOnlyText"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class HlmBreadcrumbItem {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmBreadcrumbItem, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmBreadcrumbItem, "[hlmBreadcrumbItem]", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmBreadcrumbLink {
+    constructor();
+    /** The link to navigate to the page. */
+    readonly link: i0.InputSignal<string | readonly any[] | _angular_router.UrlTree | null | undefined>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmBreadcrumbLink, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmBreadcrumbLink, "[hlmBreadcrumbLink]", never, { "link": { "alias": "link"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof _angular_router.RouterLink; inputs: { "target": "target"; "queryParams": "queryParams"; "fragment": "fragment"; "queryParamsHandling": "queryParamsHandling"; "state": "state"; "info": "info"; "relativeTo": "relativeTo"; "preserveFragment": "preserveFragment"; "skipLocationChange": "skipLocationChange"; "replaceUrl": "replaceUrl"; "routerLink": "link"; }; outputs: {}; }]>;
+}
+
+declare class HlmBreadcrumbList {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmBreadcrumbList, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmBreadcrumbList, "[hlmBreadcrumbList]", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmBreadcrumbPage {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmBreadcrumbPage, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmBreadcrumbPage, "[hlmBreadcrumbPage]", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmBreadcrumbSeparator {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmBreadcrumbSeparator, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HlmBreadcrumbSeparator, "[hlmBreadcrumbSeparator]", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare const HlmBreadCrumbImports: readonly [typeof HlmBreadcrumb, typeof HlmBreadcrumbEllipsis, typeof HlmBreadcrumbSeparator, typeof HlmBreadcrumbItem, typeof HlmBreadcrumbLink, typeof HlmBreadcrumbPage, typeof HlmBreadcrumbList];
+
+interface BrnButtonConfig {
+    variant: ButtonVariants['variant'];
+    size: ButtonVariants['size'];
+}
+declare function provideBrnButtonConfig(config: Partial<BrnButtonConfig>): ValueProvider;
+declare function injectBrnButtonConfig(): BrnButtonConfig;
+
+declare const HlmButtonImports: readonly [typeof HlmButton];
+
+declare const buttonGroupVariants: (props?: ({
+    orientation?: "horizontal" | "vertical" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare class HlmButtonGroup {
+    constructor();
+    readonly orientation: i0.InputSignal<"horizontal" | "vertical">;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmButtonGroup, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmButtonGroup, "[hlmButtonGroup],hlm-button-group", never, { "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class HlmButtonGroupSeparator {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmButtonGroupSeparator, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmButtonGroupSeparator, "[hlmButtonGroupSeparator],hlm-button-group-separator", never, {}, {}, never, never, true, [{ directive: typeof i1$6.BrnSeparator; inputs: { "orientation": "orientation"; "decorative": "decorative"; }; outputs: {}; }]>;
+}
+
+declare class HlmButtonGroupText {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmButtonGroupText, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmButtonGroupText, "[hlmButtonGroupText],hlm-button-group-text", never, {}, {}, never, never, true, never>;
+}
+
+declare const HlmButtonGroupImports: readonly [typeof HlmButtonGroup, typeof HlmButtonGroupText, typeof HlmButtonGroupSeparator];
+
+declare class HlmCalendar<T> {
+    readonly calendarClass: i0.InputSignal<ClassValue>;
+    protected readonly _computedCalenderClass: i0.Signal<string>;
+    /** Access the calendar i18n */
+    protected readonly _i18n: _spartan_ng_brain_calendar.BrnCalendarI18nService;
+    /** Access the date time adapter */
+    protected readonly _dateAdapter: _spartan_ng_brain_date_time.BrnDateAdapter<T>;
+    /** The minimum date that can be selected.*/
+    readonly min: i0.InputSignal<T | undefined>;
+    /** The maximum date that can be selected. */
+    readonly max: i0.InputSignal<T | undefined>;
+    /** Show dropdowns to navigate between months or years. */
+    readonly captionLayout: i0.InputSignal<"dropdown" | "label" | "dropdown-months" | "dropdown-years">;
+    /** Determine if the date picker is disabled. */
+    readonly disabled: i0.InputSignalWithTransform<boolean, BooleanInput>;
+    /** The selected value. */
+    readonly date: i0.ModelSignal<T | undefined>;
+    /** Whether a specific date is disabled. */
+    readonly dateDisabled: i0.InputSignal<(date: T) => boolean>;
+    /** The day the week starts on */
+    readonly weekStartsOn: i0.InputSignalWithTransform<Weekday | undefined, NumberInput>;
+    /** The default focused date. */
+    readonly defaultFocusedDate: i0.InputSignal<T | undefined>;
+    /** Access the calendar directive */
+    private readonly _calendar;
+    /** Get the heading for the current month and year */
+    protected readonly _heading: i0.Signal<{
+        header: string;
+        month: string;
+        year: string;
+    }>;
+    protected readonly _btnClass: string;
+    protected readonly _selectClass = "gap-0 px-1.5 py-2 [&>ng-icon]:ml-1";
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmCalendar<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HlmCalendar<any>, "hlm-calendar", never, { "calendarClass": { "alias": "calendarClass"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "captionLayout": { "alias": "captionLayout"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "date": { "alias": "date"; "required": false; "isSignal": true; }; "dateDisabled": { "alias": "dateDisabled"; "required": false; "isSignal": true; }; "weekStartsOn": { "alias": "weekStartsOn"; "required": false; "isSignal": true; }; "defaultFocusedDate": { "alias": "defaultFocusedDate"; "required": false; "isSignal": true; }; }, { "date": "dateChange"; }, never, never, true, never>;
+}
+
+declare class HlmCalendarMulti<T> {
+    readonly calendarClass: i0.InputSignal<ClassValue>;
+    protected readonly _computedCalenderClass: i0.Signal<string>;
+    /** Access the calendar i18n */
+    protected readonly _i18n: _spartan_ng_brain_calendar.BrnCalendarI18nService;
+    /** Access the date time adapter */
+    protected readonly _dateAdapter: _spartan_ng_brain_date_time.BrnDateAdapter<T>;
+    /** The minimum date that can be selected.*/
+    readonly min: i0.InputSignal<T | undefined>;
+    /** The maximum date that can be selected. */
+    readonly max: i0.InputSignal<T | undefined>;
+    /** Show dropdowns to navigate between months or years. */
+    readonly captionLayout: i0.InputSignal<"dropdown" | "label" | "dropdown-months" | "dropdown-years">;
+    /** The minimum selectable dates.  */
+    readonly minSelection: i0.InputSignalWithTransform<number | undefined, NumberInput>;
+    /** The maximum selectable dates.  */
+    readonly maxSelection: i0.InputSignalWithTransform<number | undefined, NumberInput>;
+    /** Determine if the date picker is disabled. */
+    readonly disabled: i0.InputSignalWithTransform<boolean, BooleanInput>;
+    /** The selected value. */
+    readonly date: i0.ModelSignal<T[] | undefined>;
+    /** Whether a specific date is disabled. */
+    readonly dateDisabled: i0.InputSignal<(date: T) => boolean>;
+    /** The day the week starts on */
+    readonly weekStartsOn: i0.InputSignalWithTransform<Weekday | undefined, NumberInput>;
+    /** The default focused date. */
+    readonly defaultFocusedDate: i0.InputSignal<T | undefined>;
+    /** Access the calendar directive */
+    private readonly _calendar;
+    /** Get the heading for the current month and year */
+    protected readonly _heading: i0.Signal<{
+        header: string;
+        month: string;
+        year: string;
+    }>;
+    protected readonly _btnClass: string;
+    protected readonly _selectClass = "gap-0 px-1.5 py-2 [&>ng-icon]:ml-1";
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmCalendarMulti<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HlmCalendarMulti<any>, "hlm-calendar-multi", never, { "calendarClass": { "alias": "calendarClass"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "captionLayout": { "alias": "captionLayout"; "required": false; "isSignal": true; }; "minSelection": { "alias": "minSelection"; "required": false; "isSignal": true; }; "maxSelection": { "alias": "maxSelection"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "date": { "alias": "date"; "required": false; "isSignal": true; }; "dateDisabled": { "alias": "dateDisabled"; "required": false; "isSignal": true; }; "weekStartsOn": { "alias": "weekStartsOn"; "required": false; "isSignal": true; }; "defaultFocusedDate": { "alias": "defaultFocusedDate"; "required": false; "isSignal": true; }; }, { "date": "dateChange"; }, never, never, true, never>;
+}
+
+declare class HlmCalendarRange<T> {
+    readonly calendarClass: i0.InputSignal<ClassValue>;
+    protected readonly _computedCalenderClass: i0.Signal<string>;
+    /** Access the calendar i18n */
+    protected readonly _i18n: _spartan_ng_brain_calendar.BrnCalendarI18nService;
+    /** Access the date time adapter */
+    protected readonly _dateAdapter: _spartan_ng_brain_date_time.BrnDateAdapter<T>;
+    /** The minimum date that can be selected.*/
+    readonly min: i0.InputSignal<T | undefined>;
+    /** The maximum date that can be selected. */
+    readonly max: i0.InputSignal<T | undefined>;
+    /** Show dropdowns to navigate between months or years. */
+    readonly captionLayout: i0.InputSignal<"dropdown" | "label" | "dropdown-months" | "dropdown-years">;
+    /** Determine if the date picker is disabled. */
+    readonly disabled: i0.InputSignalWithTransform<boolean, BooleanInput>;
+    /** The start date of the range. */
+    readonly startDate: i0.ModelSignal<T | undefined>;
+    /** The end date of the range. */
+    readonly endDate: i0.ModelSignal<T | undefined>;
+    /** Whether a specific date is disabled. */
+    readonly dateDisabled: i0.InputSignal<(date: T) => boolean>;
+    /** The day the week starts on */
+    readonly weekStartsOn: i0.InputSignalWithTransform<Weekday | undefined, NumberInput>;
+    /** The default focused date. */
+    readonly defaultFocusedDate: i0.InputSignal<T | undefined>;
+    /** Access the calendar directive */
+    private readonly _calendar;
+    /** Get the heading for the current month and year */
+    protected readonly _heading: i0.Signal<{
+        header: string;
+        month: string;
+        year: string;
+    }>;
+    protected readonly _btnClass: string;
+    protected readonly _selectClass = "gap-0 px-1.5 py-2 [&>ng-icon]:ml-1";
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmCalendarRange<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HlmCalendarRange<any>, "hlm-calendar-range", never, { "calendarClass": { "alias": "calendarClass"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "captionLayout": { "alias": "captionLayout"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "startDate": { "alias": "startDate"; "required": false; "isSignal": true; }; "endDate": { "alias": "endDate"; "required": false; "isSignal": true; }; "dateDisabled": { "alias": "dateDisabled"; "required": false; "isSignal": true; }; "weekStartsOn": { "alias": "weekStartsOn"; "required": false; "isSignal": true; }; "defaultFocusedDate": { "alias": "defaultFocusedDate"; "required": false; "isSignal": true; }; }, { "startDate": "startDateChange"; "endDate": "endDateChange"; }, never, never, true, never>;
+}
+
+declare const HlmCalendarImports: readonly [typeof HlmCalendar, typeof HlmCalendarMulti, typeof HlmCalendarRange];
+
+declare class HlmCard {
+    readonly size: i0.InputSignal<"sm" | "default">;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmCard, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmCard, "[hlmCard],hlm-card", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class HlmCardAction {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmCardAction, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmCardAction, "[hlmCardAction]", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmCardContent {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmCardContent, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmCardContent, "[hlmCardContent]", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmCardDescription {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmCardDescription, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmCardDescription, "[hlmCardDescription]", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmCardFooter {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmCardFooter, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmCardFooter, "[hlmCardFooter],hlm-card-footer", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmCardHeader {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmCardHeader, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmCardHeader, "[hlmCardHeader],hlm-card-header", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmCardTitle {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmCardTitle, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmCardTitle, "[hlmCardTitle]", never, {}, {}, never, never, true, never>;
+}
+
+declare const HlmCardImports: readonly [typeof HlmCard, typeof HlmCardAction, typeof HlmCardContent, typeof HlmCardDescription, typeof HlmCardFooter, typeof HlmCardHeader, typeof HlmCardTitle];
+
+declare const HLM_CHECKBOX_VALUE_ACCESSOR: {
+    provide: i0.InjectionToken<readonly ControlValueAccessor[]>;
+    useExisting: i0.Type<any>;
+    multi: boolean;
+};
+declare class HlmCheckbox implements ControlValueAccessor {
+    readonly userClass: i0.InputSignal<ClassValue>;
+    protected readonly _computedClass: i0.Signal<string>;
+    /** Used to set the id on the underlying brn element. */
+    readonly id: i0.InputSignal<string | null>;
+    /** Used to set the aria-label attribute on the underlying brn element. */
+    readonly ariaLabel: i0.InputSignal<string | null>;
+    /** Used to set the aria-labelledby attribute on the underlying brn element. */
+    readonly ariaLabelledby: i0.InputSignal<string | null>;
+    /** Used to set the aria-describedby attribute on the underlying brn element. */
+    readonly ariaDescribedby: i0.InputSignal<string | null>;
+    /** The checked state of the checkbox. */
+    readonly checked: i0.ModelSignal<boolean>;
+    /** Emits when checked state changes. */
+    readonly checkedChange: i0.OutputEmitterRef<boolean>;
+    /**
+     * The indeterminate state of the checkbox.
+     * For example, a "select all/deselect all" checkbox may be in the indeterminate state when some but not all of its sub-controls are checked.
+     */
+    readonly indeterminate: i0.ModelSignal<boolean>;
+    /** The name attribute of the checkbox. */
+    readonly name: i0.InputSignal<string | null>;
+    /** Whether the checkbox is required. */
+    readonly required: i0.InputSignalWithTransform<boolean, BooleanInput>;
+    /** Whether the checkbox is disabled. */
+    readonly disabled: i0.InputSignalWithTransform<boolean, BooleanInput>;
+    protected readonly _disabled: i0.WritableSignal<boolean>;
+    protected _onChange?: ChangeFn<boolean>;
+    protected _onTouched?: TouchFn;
+    protected _handleChange(value: boolean): void;
+    /** CONTROL VALUE ACCESSOR */
+    writeValue(value: boolean): void;
+    registerOnChange(fn: ChangeFn<boolean>): void;
+    registerOnTouched(fn: TouchFn): void;
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmCheckbox, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HlmCheckbox, "hlm-checkbox", never, { "userClass": { "alias": "class"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "aria-label"; "required": false; "isSignal": true; }; "ariaLabelledby": { "alias": "aria-labelledby"; "required": false; "isSignal": true; }; "ariaDescribedby": { "alias": "aria-describedby"; "required": false; "isSignal": true; }; "checked": { "alias": "checked"; "required": false; "isSignal": true; }; "indeterminate": { "alias": "indeterminate"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "checked": "checkedChange"; "checkedChange": "checkedChange"; "indeterminate": "indeterminateChange"; }, never, never, true, never>;
+}
+
+declare const HlmCheckboxImports: readonly [typeof HlmCheckbox];
+
+declare class HlmCollapsible {
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmCollapsible, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmCollapsible, "[hlmCollapsible],hlm-collapsible", never, {}, {}, never, never, true, [{ directive: typeof i1$7.BrnCollapsible; inputs: { "expanded": "expanded"; "disabled": "disabled"; }; outputs: { "expandedChange": "expandedChange"; }; }]>;
+}
+
+declare class HlmCollapsibleContent {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmCollapsibleContent, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmCollapsibleContent, "[hlmCollapsibleContent],hlm-collapsible-content", never, {}, {}, never, never, true, [{ directive: typeof i1$7.BrnCollapsibleContent; inputs: { "id": "id"; }; outputs: {}; }]>;
+}
+
+declare class HlmCollapsibleTrigger {
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmCollapsibleTrigger, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmCollapsibleTrigger, "button[hlmCollapsibleTrigger]", never, {}, {}, never, never, true, [{ directive: typeof i1$7.BrnCollapsibleTrigger; inputs: { "type": "type"; }; outputs: {}; }]>;
+}
+
+declare const HlmCollapsibleImports: readonly [typeof HlmCollapsible, typeof HlmCollapsibleContent, typeof HlmCollapsibleTrigger];
+
+declare class HlmCommand {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmCommand, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmCommand, "[hlmCommand],hlm-command", never, {}, {}, never, never, true, [{ directive: typeof i1$8.BrnCommand; inputs: { "id": "id"; "filter": "filter"; "search": "search"; "disabled": "disabled"; }; outputs: { "valueChange": "valueChange"; "searchChange": "searchChange"; }; }]>;
+}
+
+declare class HlmCommandDialog {
+    readonly title: i0.InputSignal<string>;
+    readonly description: i0.InputSignal<string>;
+    readonly state: i0.InputSignal<BrnDialogState>;
+    protected readonly _state: i0.WritableSignal<BrnDialogState>;
+    readonly showCloseButton: i0.InputSignalWithTransform<boolean, BooleanInput>;
+    readonly dialogContentClass: i0.InputSignal<ClassValue>;
+    protected readonly _computedDialogContentClass: i0.Signal<string>;
+    readonly stateChange: i0.OutputEmitterRef<BrnDialogState>;
+    protected stateChanged(state: BrnDialogState): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmCommandDialog, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HlmCommandDialog, "hlm-command-dialog", never, { "title": { "alias": "title"; "required": false; "isSignal": true; }; "description": { "alias": "description"; "required": false; "isSignal": true; }; "state": { "alias": "state"; "required": false; "isSignal": true; }; "showCloseButton": { "alias": "showCloseButton"; "required": false; "isSignal": true; }; "dialogContentClass": { "alias": "dialogContentClass"; "required": false; "isSignal": true; }; }, { "stateChange": "stateChange"; }, never, ["*"], true, never>;
+}
+
+declare class HlmCommandEmpty {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmCommandEmpty, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmCommandEmpty, "[hlmCommandEmpty]", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmCommandEmptyState {
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmCommandEmptyState, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmCommandEmptyState, "[hlmCommandEmptyState]", never, {}, {}, never, never, true, [{ directive: typeof i1$8.BrnCommandEmpty; inputs: {}; outputs: {}; }]>;
+}
+
+declare class HlmCommandGroup {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmCommandGroup, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmCommandGroup, "[hlmCommandGroup],hlm-command-group", never, {}, {}, never, never, true, [{ directive: typeof i1$8.BrnCommandGroup; inputs: { "id": "id"; }; outputs: {}; }]>;
+}
+
+declare class HlmCommandGroupLabel {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmCommandGroupLabel, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmCommandGroupLabel, "[hlmCommandGroupLabel],hlm-command-group-label", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmCommandInput {
+    readonly id: i0.InputSignal<string | undefined>;
+    readonly placeholder: i0.InputSignal<string>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmCommandInput, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HlmCommandInput, "hlm-command-input", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class HlmCommandItem {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmCommandItem, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmCommandItem, "button[hlmCommandItem],button[hlm-command-item]", never, {}, {}, never, never, true, [{ directive: typeof i1$8.BrnCommandItem; inputs: { "value": "value"; "disabled": "disabled"; "id": "id"; }; outputs: { "selected": "selected"; }; }]>;
+}
+
+declare class HlmCommandList {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmCommandList, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmCommandList, "[hlmCommandList],hlm-command-list", never, {}, {}, never, never, true, [{ directive: typeof i1$8.BrnCommandList; inputs: { "id": "id"; }; outputs: {}; }]>;
+}
+
+declare class HlmCommandSeparator {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmCommandSeparator, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmCommandSeparator, "[hlmCommandSeparator],hlm-command-separator", never, {}, {}, never, never, true, [{ directive: typeof i1$8.BrnCommandSeparator; inputs: {}; outputs: {}; }]>;
+}
+
+declare class HlmCommandShortcut {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmCommandShortcut, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmCommandShortcut, "[hlmCommandShortcut],hlm-command-shortcut", never, {}, {}, never, never, true, never>;
+}
+
+declare const HlmCommandImports: readonly [typeof HlmCommand, typeof HlmCommandDialog, typeof HlmCommandEmpty, typeof HlmCommandEmptyState, typeof HlmCommandGroup, typeof HlmCommandGroupLabel, typeof HlmCommandInput, typeof HlmCommandItem, typeof HlmCommandList, typeof HlmCommandSeparator, typeof HlmCommandShortcut];
+
+declare class HlmContextMenuTrigger {
+    private readonly _cdkTrigger;
+    private readonly _config;
+    readonly disabled: i0.InputSignalWithTransform<boolean, BooleanInput>;
+    readonly align: i0.InputSignal<MenuAlign>;
+    readonly side: i0.InputSignal<MenuSide>;
+    private readonly _menuPosition;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmContextMenuTrigger, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmContextMenuTrigger, "[hlmContextMenuTrigger]", never, { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "align": { "alias": "align"; "required": false; "isSignal": true; }; "side": { "alias": "side"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1$9.CdkContextMenuTrigger; inputs: { "cdkContextMenuTriggerFor": "hlmContextMenuTrigger"; "cdkContextMenuTriggerData": "hlmContextMenuTriggerData"; "cdkContextMenuDisabled": "disabled"; }; outputs: { "cdkContextMenuOpened": "hlmContextMenuOpened"; "cdkContextMenuClosed": "hlmContextMenuClosed"; }; }]>;
+}
+
+interface HlmContextMenuConfig {
+    align: MenuAlign;
+    side: MenuSide;
+}
+declare function provideHlmContextMenuConfig(config: Partial<HlmContextMenuConfig>): ValueProvider;
+declare function injectHlmContextMenuConfig(): HlmContextMenuConfig;
+
+declare const HlmContextMenuImports: readonly [typeof HlmContextMenuTrigger];
+
+declare const HLM_DATE_PICKER_VALUE_ACCESSOR: {
+    provide: i0.InjectionToken<readonly ControlValueAccessor[]>;
+    useExisting: i0.Type<any>;
+    multi: boolean;
+};
+declare class HlmDatePicker<T> implements ControlValueAccessor {
+    private readonly _config;
+    readonly userClass: i0.InputSignal<ClassValue>;
+    protected readonly _computedClass: i0.Signal<string>;
+    /** The id of the button that opens the date picker. */
+    readonly buttonId: i0.InputSignal<string>;
+    /** Show dropdowns to navigate between months or years. */
+    readonly captionLayout: i0.InputSignal<"dropdown" | "label" | "dropdown-months" | "dropdown-years">;
+    /** The minimum date that can be selected.*/
+    readonly min: i0.InputSignal<T | undefined>;
+    /** The maximum date that can be selected. */
+    readonly max: i0.InputSignal<T | undefined>;
+    /** Determine if the date picker is disabled. */
+    readonly disabled: i0.InputSignalWithTransform<boolean, BooleanInput>;
+    /** The selected value. */
+    readonly date: i0.InputSignal<T | undefined>;
+    protected readonly _mutableDate: i0.WritableSignal<T | undefined>;
+    /** If true, the date picker will close when a date is selected. */
+    readonly autoCloseOnSelect: i0.InputSignalWithTransform<boolean, BooleanInput>;
+    /** Defines how the date should be displayed in the UI.  */
+    readonly formatDate: i0.InputSignal<(date: T) => string>;
+    /** Defines how the date should be transformed before saving to model/form. */
+    readonly transformDate: i0.InputSignal<(date: T) => T>;
+    protected readonly _popoverState: i0.WritableSignal<BrnDialogState | null>;
+    protected readonly _mutableDisabled: i0.WritableSignal<boolean>;
+    protected readonly _formattedDate: i0.Signal<string | undefined>;
+    readonly dateChange: i0.OutputEmitterRef<T>;
+    protected _onChange?: ChangeFn<T>;
+    protected _onTouched?: TouchFn;
+    protected _handleChange(value: T): void;
+    /** CONTROL VALUE ACCESSOR */
+    writeValue(value: T | null): void;
+    registerOnChange(fn: ChangeFn<T>): void;
+    registerOnTouched(fn: TouchFn): void;
+    setDisabledState(isDisabled: boolean): void;
+    open(): void;
+    close(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmDatePicker<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HlmDatePicker<any>, "hlm-date-picker", never, { "userClass": { "alias": "class"; "required": false; "isSignal": true; }; "buttonId": { "alias": "buttonId"; "required": false; "isSignal": true; }; "captionLayout": { "alias": "captionLayout"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "date": { "alias": "date"; "required": false; "isSignal": true; }; "autoCloseOnSelect": { "alias": "autoCloseOnSelect"; "required": false; "isSignal": true; }; "formatDate": { "alias": "formatDate"; "required": false; "isSignal": true; }; "transformDate": { "alias": "transformDate"; "required": false; "isSignal": true; }; }, { "dateChange": "dateChange"; }, never, ["*"], true, never>;
+}
+
+declare const HLM_DATE_PICKER_MUTLI_VALUE_ACCESSOR: {
+    provide: i0.InjectionToken<readonly ControlValueAccessor[]>;
+    useExisting: i0.Type<any>;
+    multi: boolean;
+};
+declare class HlmDatePickerMulti<T> implements ControlValueAccessor {
+    private readonly _config;
+    readonly userClass: i0.InputSignal<ClassValue>;
+    protected readonly _computedClass: i0.Signal<string>;
+    /** The id of the button that opens the date picker. */
+    readonly buttonId: i0.InputSignal<string>;
+    /** Show dropdowns to navigate between months or years. */
+    readonly captionLayout: i0.InputSignal<"dropdown" | "label" | "dropdown-months" | "dropdown-years">;
+    /** The minimum date that can be selected.*/
+    readonly min: i0.InputSignal<T | undefined>;
+    /** The maximum date that can be selected. */
+    readonly max: i0.InputSignal<T | undefined>;
+    /** The minimum selectable dates.  */
+    readonly minSelection: i0.InputSignalWithTransform<number | undefined, NumberInput>;
+    /** The maximum selectable dates.  */
+    readonly maxSelection: i0.InputSignalWithTransform<number | undefined, NumberInput>;
+    /** Determine if the date picker is disabled. */
+    readonly disabled: i0.InputSignalWithTransform<boolean, BooleanInput>;
+    /** The selected value. */
+    readonly date: i0.InputSignal<T[] | undefined>;
+    protected readonly _mutableDate: i0.WritableSignal<T[] | undefined>;
+    /** If true, the date picker will close when the max selection of dates is reached. */
+    readonly autoCloseOnMaxSelection: i0.InputSignalWithTransform<boolean, BooleanInput>;
+    /** Defines how the date should be displayed in the UI.  */
+    readonly formatDates: i0.InputSignal<(date: T[]) => string>;
+    /** Defines how the date should be transformed before saving to model/form. */
+    readonly transformDates: i0.InputSignal<(date: T[]) => T[]>;
+    protected readonly _popoverState: i0.WritableSignal<BrnDialogState | null>;
+    protected readonly _mutableDisabled: i0.WritableSignal<boolean>;
+    protected readonly _formattedDate: i0.Signal<string | undefined>;
+    readonly dateChange: i0.OutputEmitterRef<T[]>;
+    protected _onChange?: ChangeFn<T[]>;
+    protected _onTouched?: TouchFn;
+    protected _handleChange(value: T[] | undefined): void;
+    /** CONTROL VALUE ACCESSOR */
+    writeValue(value: T[] | null): void;
+    registerOnChange(fn: ChangeFn<T[]>): void;
+    registerOnTouched(fn: TouchFn): void;
+    setDisabledState(isDisabled: boolean): void;
+    open(): void;
+    close(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmDatePickerMulti<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HlmDatePickerMulti<any>, "hlm-date-picker-multi", never, { "userClass": { "alias": "class"; "required": false; "isSignal": true; }; "buttonId": { "alias": "buttonId"; "required": false; "isSignal": true; }; "captionLayout": { "alias": "captionLayout"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "minSelection": { "alias": "minSelection"; "required": false; "isSignal": true; }; "maxSelection": { "alias": "maxSelection"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "date": { "alias": "date"; "required": false; "isSignal": true; }; "autoCloseOnMaxSelection": { "alias": "autoCloseOnMaxSelection"; "required": false; "isSignal": true; }; "formatDates": { "alias": "formatDates"; "required": false; "isSignal": true; }; "transformDates": { "alias": "transformDates"; "required": false; "isSignal": true; }; }, { "dateChange": "dateChange"; }, never, ["*"], true, never>;
+}
+
+declare const HLM_DATE_RANGE_PICKER_VALUE_ACCESSOR: {
+    provide: i0.InjectionToken<readonly ControlValueAccessor[]>;
+    useExisting: i0.Type<any>;
+    multi: boolean;
+};
+declare class HlmDateRangePicker<T> implements ControlValueAccessor {
+    private readonly _config;
+    readonly userClass: i0.InputSignal<ClassValue>;
+    protected readonly _computedClass: i0.Signal<string>;
+    /** The id of the button that opens the date picker. */
+    readonly buttonId: i0.InputSignal<string>;
+    /** Show dropdowns to navigate between months or years. */
+    readonly captionLayout: i0.InputSignal<"dropdown" | "label" | "dropdown-months" | "dropdown-years">;
+    /** The minimum date that can be selected.*/
+    readonly min: i0.InputSignal<T | undefined>;
+    /** The maximum date that can be selected. */
+    readonly max: i0.InputSignal<T | undefined>;
+    /** Determine if the date picker is disabled. */
+    readonly disabled: i0.InputSignalWithTransform<boolean, BooleanInput>;
+    /** The selected value. */
+    readonly date: i0.InputSignal<[T, T] | undefined>;
+    protected readonly _mutableDate: i0.WritableSignal<[T, T] | undefined>;
+    protected readonly _start: i0.WritableSignal<T | undefined>;
+    protected readonly _end: i0.WritableSignal<T | undefined>;
+    /** If true, the date picker will close when the end date is selected */
+    readonly autoCloseOnEndSelection: i0.InputSignalWithTransform<boolean, BooleanInput>;
+    /** Defines how the date should be displayed in the UI.  */
+    readonly formatDates: i0.InputSignal<(dates: [T | undefined, T | undefined]) => string>;
+    /** Defines how the date should be transformed before saving to model/form. */
+    readonly transformDates: i0.InputSignal<(date: [T, T]) => [T, T]>;
+    protected readonly _popoverState: i0.WritableSignal<BrnDialogState | null>;
+    protected readonly _mutableDisabled: i0.WritableSignal<boolean>;
+    protected readonly _formattedDate: i0.Signal<string | undefined>;
+    readonly dateChange: i0.OutputEmitterRef<[T, T] | null>;
+    protected _onChange?: ChangeFn<[T, T] | null>;
+    protected _onTouched?: TouchFn;
+    protected _handleStartDayChange(value: T): void;
+    protected _handleEndDateChange(value: T): void;
+    /** CONTROL VALUE ACCESSOR */
+    writeValue(value: [T, T] | null): void;
+    registerOnChange(fn: ChangeFn<[T, T] | null>): void;
+    registerOnTouched(fn: TouchFn): void;
+    setDisabledState(isDisabled: boolean): void;
+    open(): void;
+    close(): void;
+    protected _onClose(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmDateRangePicker<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HlmDateRangePicker<any>, "hlm-date-range-picker", never, { "userClass": { "alias": "class"; "required": false; "isSignal": true; }; "buttonId": { "alias": "buttonId"; "required": false; "isSignal": true; }; "captionLayout": { "alias": "captionLayout"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "date": { "alias": "date"; "required": false; "isSignal": true; }; "autoCloseOnEndSelection": { "alias": "autoCloseOnEndSelection"; "required": false; "isSignal": true; }; "formatDates": { "alias": "formatDates"; "required": false; "isSignal": true; }; "transformDates": { "alias": "transformDates"; "required": false; "isSignal": true; }; }, { "dateChange": "dateChange"; }, never, ["*"], true, never>;
+}
+
+interface HlmDatePickerMultiConfig<T> {
+    /**
+     * If true, the date picker will close when the max selection of dates is reached.
+     */
+    autoCloseOnMaxSelection: boolean;
+    /**
+     * Defines how the date should be displayed in the UI.
+     *
+     * @param dates
+     * @returns formatted date
+     */
+    formatDates: (dates: T[]) => string;
+    /**
+     * Defines how the date should be transformed before saving to model/form.
+     *
+     * @param dates
+     * @returns transformed date
+     */
+    transformDates: (dates: T[]) => T[];
+}
+declare function provideHlmDatePickerMultiConfig<T>(config: Partial<HlmDatePickerMultiConfig<T>>): ValueProvider;
+declare function injectHlmDatePickerMultiConfig<T>(): HlmDatePickerMultiConfig<T>;
+
+interface HlmDatePickerConfig<T> {
+    /**
+     * If true, the date picker will close when a date is selected.
+     */
+    autoCloseOnSelect: boolean;
+    /**
+     * Defines how the date should be displayed in the UI.
+     *
+     * @param date
+     * @returns formatted date
+     */
+    formatDate: (date: T) => string;
+    /**
+     * Defines how the date should be transformed before saving to model/form.
+     *
+     * @param date
+     * @returns transformed date
+     */
+    transformDate: (date: T) => T;
+}
+declare function provideHlmDatePickerConfig<T>(config: Partial<HlmDatePickerConfig<T>>): ValueProvider;
+declare function injectHlmDatePickerConfig<T>(): HlmDatePickerConfig<T>;
+
+interface HlmDateRangePickerConfig<T> {
+    /**
+     * If true, the date picker will close when the max selection of dates is reached.
+     */
+    autoCloseOnEndSelection: boolean;
+    /**
+     * Defines how the date should be displayed in the UI.
+     *
+     * @param dates
+     * @returns formatted date
+     */
+    formatDates: (dates: [T | undefined, T | undefined]) => string;
+    /**
+     * Defines how the date should be transformed before saving to model/form.
+     *
+     * @param dates
+     * @returns transformed date
+     */
+    transformDates: (dates: [T, T]) => [T, T];
+}
+declare function provideHlmDateRangePickerConfig<T>(config: Partial<HlmDateRangePickerConfig<T>>): ValueProvider;
+declare function injectHlmDateRangePickerConfig<T>(): HlmDateRangePickerConfig<T>;
+
+declare const HlmDatePickerImports: readonly [typeof HlmDatePicker, typeof HlmDatePickerMulti, typeof HlmDateRangePicker];
+
+declare class HlmDialog extends BrnDialog {
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmDialog, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HlmDialog, "hlm-dialog", ["hlmDialog"], {}, {}, never, ["*"], true, never>;
+}
+
+declare class HlmDialogClose {
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmDialogClose, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmDialogClose, "button[hlmDialogClose]", never, {}, {}, never, never, true, [{ directive: typeof i1$a.BrnDialogClose; inputs: { "delay": "delay"; }; outputs: {}; }]>;
+}
+
+declare class HlmDialogContent {
+    private readonly _dialogRef;
+    private readonly _dialogContext;
+    readonly showCloseButton: i0.InputSignalWithTransform<boolean, BooleanInput>;
+    readonly state: i0.Signal<i1$a.BrnDialogState>;
+    readonly component: any;
+    private readonly _dynamicComponentClass;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmDialogContent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HlmDialogContent, "hlm-dialog-content", never, { "showCloseButton": { "alias": "showCloseButton"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class HlmDialogDescription {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmDialogDescription, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmDialogDescription, "[hlmDialogDescription]", never, {}, {}, never, never, true, [{ directive: typeof i1$a.BrnDialogDescription; inputs: {}; outputs: {}; }]>;
+}
+
+declare class HlmDialogFooter {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmDialogFooter, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmDialogFooter, "[hlmDialogFooter],hlm-dialog-footer", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmDialogHeader {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmDialogHeader, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmDialogHeader, "[hlmDialogHeader],hlm-dialog-header", never, {}, {}, never, never, true, never>;
+}
+
+declare const hlmDialogOverlayClass = "data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 bg-black/50";
+declare class HlmDialogOverlay {
+    private readonly _classSettable;
+    readonly userClass: i0.InputSignal<ClassValue>;
+    protected readonly _computedClass: i0.Signal<string>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmDialogOverlay, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmDialogOverlay, "[hlmDialogOverlay],hlm-dialog-overlay", never, { "userClass": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1$a.BrnDialogOverlay; inputs: {}; outputs: {}; }]>;
+}
+
+declare class HlmDialogPortal {
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmDialogPortal, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmDialogPortal, "[hlmDialogPortal]", never, {}, {}, never, never, true, [{ directive: typeof i1$a.BrnDialogContent; inputs: { "context": "context"; "class": "class"; }; outputs: {}; }]>;
+}
+
+declare class HlmDialogTitle {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmDialogTitle, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmDialogTitle, "[hlmDialogTitle]", never, {}, {}, never, never, true, [{ directive: typeof i1$a.BrnDialogTitle; inputs: {}; outputs: {}; }]>;
+}
+
+declare class HlmDialogTrigger {
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmDialogTrigger, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmDialogTrigger, "button[hlmDialogTrigger],button[hlmDialogTriggerFor]", never, {}, {}, never, never, true, [{ directive: typeof i1$a.BrnDialogTrigger; inputs: { "id": "id"; "brnDialogTriggerFor": "hlmDialogTriggerFor"; "type": "type"; }; outputs: {}; }]>;
+}
+
+type HlmDialogOptions<DialogContext = unknown> = BrnDialogOptions & {
+    contentClass?: string;
+    context?: DialogContext;
+};
+declare class HlmDialogService {
+    private readonly _brnDialogService;
+    open(component: ComponentType<unknown> | TemplateRef<unknown>, options?: Partial<HlmDialogOptions>): i1$a.BrnDialogRef<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmDialogService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<HlmDialogService>;
+}
+
+declare const HlmDialogImports: readonly [typeof HlmDialog, typeof HlmDialogContent, typeof HlmDialogDescription, typeof HlmDialogFooter, typeof HlmDialogHeader, typeof HlmDialogOverlay, typeof HlmDialogPortal, typeof HlmDialogTitle, typeof HlmDialogTrigger, typeof HlmDialogClose];
+
+declare class HlmDropdownMenu {
+    private readonly _host;
+    protected readonly _state: i0.WritableSignal<string>;
+    protected readonly _side: i0.WritableSignal<string>;
+    readonly sideOffset: i0.InputSignalWithTransform<number, NumberInput>;
+    constructor();
+    private setSideWithDarkMagic;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmDropdownMenu, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmDropdownMenu, "[hlmDropdownMenu],hlm-dropdown-menu", never, { "sideOffset": { "alias": "sideOffset"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1$9.CdkMenu; inputs: {}; outputs: {}; }]>;
+}
+
+declare class HlmDropdownMenuCheckbox {
+    private readonly _cdkMenuItem;
+    readonly checked: i0.InputSignalWithTransform<boolean, BooleanInput>;
+    readonly disabled: i0.InputSignalWithTransform<boolean, BooleanInput>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmDropdownMenuCheckbox, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmDropdownMenuCheckbox, "[hlmDropdownMenuCheckbox]", never, { "checked": { "alias": "checked"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1$9.CdkMenuItemCheckbox; inputs: { "cdkMenuItemDisabled": "disabled"; "cdkMenuItemChecked": "checked"; }; outputs: { "cdkMenuItemTriggered": "triggered"; }; }]>;
+}
+
+declare class HlmDropdownMenuCheckboxIndicator {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmDropdownMenuCheckboxIndicator, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HlmDropdownMenuCheckboxIndicator, "hlm-dropdown-menu-checkbox-indicator", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmDropdownMenuGroup {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmDropdownMenuGroup, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmDropdownMenuGroup, "[hlmDropdownMenuGroup],hlm-dropdown-menu-group", never, {}, {}, never, never, true, [{ directive: typeof i1$9.CdkMenuGroup; inputs: {}; outputs: {}; }]>;
+}
+
+declare class HlmDropdownMenuItem {
+    protected readonly _isButton: boolean;
+    readonly disabled: i0.InputSignalWithTransform<boolean, BooleanInput>;
+    readonly variant: i0.InputSignal<"default" | "destructive">;
+    readonly inset: i0.InputSignalWithTransform<boolean, BooleanInput>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmDropdownMenuItem, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmDropdownMenuItem, "[hlmDropdownMenuItem]", never, { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "inset": { "alias": "inset"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1$9.CdkMenuItem; inputs: { "cdkMenuItemDisabled": "disabled"; }; outputs: { "cdkMenuItemTriggered": "triggered"; }; }]>;
+}
+
+declare class HlmDropdownMenuItemSubIndicator {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmDropdownMenuItemSubIndicator, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HlmDropdownMenuItemSubIndicator, "hlm-dropdown-menu-item-sub-indicator", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmDropdownMenuLabel {
+    constructor();
+    readonly inset: i0.InputSignalWithTransform<boolean, BooleanInput>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmDropdownMenuLabel, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmDropdownMenuLabel, "[hlmDropdownMenuLabel],hlm-dropdown-menu-label", never, { "inset": { "alias": "inset"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class HlmDropdownMenuRadio {
+    private readonly _cdkMenuItem;
+    readonly checked: i0.InputSignalWithTransform<boolean, BooleanInput>;
+    readonly disabled: i0.InputSignalWithTransform<boolean, BooleanInput>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmDropdownMenuRadio, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmDropdownMenuRadio, "[hlmDropdownMenuRadio]", never, { "checked": { "alias": "checked"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1$9.CdkMenuItemRadio; inputs: { "cdkMenuItemDisabled": "disabled"; "cdkMenuItemChecked": "checked"; }; outputs: { "cdkMenuItemTriggered": "triggered"; }; }]>;
+}
+
+declare class HlmDropdownMenuRadioIndicator {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmDropdownMenuRadioIndicator, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HlmDropdownMenuRadioIndicator, "hlm-dropdown-menu-radio-indicator", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmDropdownMenuSeparator {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmDropdownMenuSeparator, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmDropdownMenuSeparator, "[hlmDropdownMenuSeparator],hlm-dropdown-menu-separator", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmDropdownMenuShortcut {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmDropdownMenuShortcut, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmDropdownMenuShortcut, "[hlmDropdownMenuShortcut],hlm-dropdown-menu-shortcut", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmDropdownMenuSub {
+    private readonly _host;
+    protected readonly _state: i0.WritableSignal<string>;
+    protected readonly _side: i0.WritableSignal<string>;
+    constructor();
+    private setSideWithDarkMagic;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmDropdownMenuSub, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmDropdownMenuSub, "[hlmDropdownMenuSub],hlm-dropdown-menu-sub", never, {}, {}, never, never, true, [{ directive: typeof i1$9.CdkMenu; inputs: {}; outputs: {}; }]>;
+}
+
+declare class HlmDropdownMenuTrigger {
+    private readonly _cdkTrigger;
+    private readonly _config;
+    readonly align: i0.InputSignal<MenuAlign>;
+    readonly side: i0.InputSignal<MenuSide>;
+    private readonly _menuPosition;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmDropdownMenuTrigger, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmDropdownMenuTrigger, "[hlmDropdownMenuTrigger]", never, { "align": { "alias": "align"; "required": false; "isSignal": true; }; "side": { "alias": "side"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1$9.CdkMenuTrigger; inputs: { "cdkMenuTriggerFor": "hlmDropdownMenuTrigger"; "cdkMenuTriggerData": "hlmDropdownMenuTriggerData"; }; outputs: { "cdkMenuOpened": "hlmDropdownMenuOpened"; "cdkMenuClosed": "hlmDropdownMenuClosed"; }; }]>;
+}
+
+interface HlmDropdownMenuConfig {
+    align: MenuAlign;
+    side: MenuSide;
+}
+declare function provideHlmDropdownMenuConfig(config: Partial<HlmDropdownMenuConfig>): ValueProvider;
+declare function injectHlmDropdownMenuConfig(): HlmDropdownMenuConfig;
+
+declare const HlmDropdownMenuImports: readonly [typeof HlmDropdownMenu, typeof HlmDropdownMenuCheckbox, typeof HlmDropdownMenuCheckboxIndicator, typeof HlmDropdownMenuGroup, typeof HlmDropdownMenuItem, typeof HlmDropdownMenuItemSubIndicator, typeof HlmDropdownMenuLabel, typeof HlmDropdownMenuRadio, typeof HlmDropdownMenuRadioIndicator, typeof HlmDropdownMenuSeparator, typeof HlmDropdownMenuShortcut, typeof HlmDropdownMenuSub, typeof HlmDropdownMenuTrigger];
+
+declare class HlmEmpty {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmEmpty, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmEmpty, "[hlmEmpty],hlm-empty", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmEmptyContent {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmEmptyContent, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmEmptyContent, "[hlmEmptyContent],hlm-empty-content", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmEmptyDescription {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmEmptyDescription, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmEmptyDescription, "[hlmEmptyDescription]", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmEmptyHeader {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmEmptyHeader, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmEmptyHeader, "[hlmEmptyHeader],hlm-empty-header", never, {}, {}, never, never, true, never>;
+}
+
+declare const emptyMediaVariants: (props?: ({
+    variant?: "default" | "icon" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type EmptyMediaVariants = VariantProps<typeof emptyMediaVariants>;
+declare class HlmEmptyMedia {
+    constructor();
+    readonly variant: i0.InputSignal<"default" | "icon" | null | undefined>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmEmptyMedia, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmEmptyMedia, "[hlmEmptyMedia],hlm-empty-media", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class HlmEmptyTitle {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmEmptyTitle, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmEmptyTitle, "[hlmEmptyTitle]", never, {}, {}, never, never, true, never>;
+}
+
+declare const HlmEmptyImports: readonly [typeof HlmEmpty, typeof HlmEmptyContent, typeof HlmEmptyDescription, typeof HlmEmptyHeader, typeof HlmEmptyTitle, typeof HlmEmptyMedia];
+
+declare const fieldVariants: (props?: ({
+    orientation?: "horizontal" | "vertical" | "responsive" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type FieldVariants = VariantProps<typeof fieldVariants>;
+declare class HlmField {
+    readonly orientation: i0.InputSignal<"horizontal" | "vertical" | "responsive" | null | undefined>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmField, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmField, "[hlmField],hlm-field", never, { "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class HlmFieldContent {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmFieldContent, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmFieldContent, "[hlmFieldContent],hlm-field-content", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmFieldDescription {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmFieldDescription, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmFieldDescription, "[hlmFieldDescription],hlm-field-description", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmFieldError {
+    readonly userClass: i0.InputSignal<ClassValue>;
+    readonly error: i0.InputSignal<({
+        message: string;
+    } | undefined)[] | undefined>;
+    protected readonly _uniqueErrors: i0.Signal<({
+        message: string;
+    } | undefined)[]>;
+    protected readonly _computedClass: i0.Signal<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmFieldError, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HlmFieldError, "hlm-field-error", never, { "userClass": { "alias": "class"; "required": false; "isSignal": true; }; "error": { "alias": "error"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class HlmFieldGroup {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmFieldGroup, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmFieldGroup, "[hlmFieldGroup],hlm-field-group", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmLabel {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmLabel, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmLabel, "[hlmLabel]", never, {}, {}, never, never, true, [{ directive: typeof i1$b.BrnLabel; inputs: { "id": "id"; }; outputs: {}; }]>;
+}
+
+declare class HlmFieldLabel {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmFieldLabel, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmFieldLabel, "[hlmFieldLabel],hlm-field-label", never, {}, {}, never, never, true, [{ directive: typeof HlmLabel; inputs: {}; outputs: {}; }]>;
+}
+
+declare class HlmFieldLegend {
+    constructor();
+    readonly variant: i0.InputSignal<"label" | "legend">;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmFieldLegend, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmFieldLegend, "legend[hlmFieldLegend]", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class HlmFieldSeparator {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmFieldSeparator, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HlmFieldSeparator, "hlm-field-separator", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare class HlmFieldSet {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmFieldSet, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmFieldSet, "fieldset[hlmFieldSet]", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmFieldTitle {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmFieldTitle, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmFieldTitle, "[hlmFieldTitle],hlm-field-title", never, {}, {}, never, never, true, never>;
+}
+
+declare const HlmFieldImports: readonly [typeof HlmField, typeof HlmFieldTitle, typeof HlmFieldContent, typeof HlmFieldDescription, typeof HlmFieldError, typeof HlmFieldLabel, typeof HlmFieldSeparator, typeof HlmFieldGroup, typeof HlmFieldLegend, typeof HlmFieldSet];
+
+declare class HlmError {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmError, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmError, "hlm-error", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmFormField {
+    readonly control: i0.Signal<BrnFormFieldControl | undefined>;
+    readonly errorChildren: i0.Signal<readonly HlmError[]>;
+    protected readonly _hasDisplayedMessage: i0.Signal<"error" | "hint">;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmFormField, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HlmFormField, "hlm-form-field", never, {}, {}, ["control", "errorChildren"], ["*", "hlm-error", "hlm-hint"], true, never>;
+}
+
+declare class HlmHint {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmHint, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmHint, "hlm-hint", never, {}, {}, never, never, true, never>;
+}
+
+declare const HlmFormFieldImports: readonly [typeof HlmFormField, typeof HlmError, typeof HlmHint];
+
+declare class HlmHoverCard {
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmHoverCard, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmHoverCard, "[hlmHoverCard],hlm-hover-card", never, {}, {}, never, never, true, [{ directive: typeof i1$c.BrnHoverCard; inputs: {}; outputs: {}; }]>;
+}
+
+declare class HlmHoverCardContent {
+    private readonly _renderer;
+    private readonly _element;
+    readonly state: i0.Signal<"open" | "closed">;
+    readonly side: i0.Signal<"top" | "bottom" | "left" | "right">;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmHoverCardContent, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmHoverCardContent, "[hlmHoverCardContent],hlm-hover-card-content", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmHoverCardPortal {
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmHoverCardPortal, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmHoverCardPortal, "[hlmHoverCardPortal],hlm-hover-card-portal", never, {}, {}, never, never, true, [{ directive: typeof i1$c.BrnHoverCardContent; inputs: {}; outputs: {}; }]>;
+}
+
+declare class HlmHoverCardTrigger {
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmHoverCardTrigger, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmHoverCardTrigger, "[hlmHoverCardTrigger]", never, {}, {}, never, never, true, [{ directive: typeof i1$c.BrnHoverCardTrigger; inputs: { "showDelay": "showDelay"; "hideDelay": "hideDelay"; "animationDelay": "animationDelay"; "sideOffset": "sideOffset"; "align": "align"; "brnHoverCardTriggerFor": "hlmHoverCardTriggerFor"; }; outputs: {}; }]>;
+}
+
+declare const HlmHoverCardImports: readonly [typeof HlmHoverCardContent, typeof HlmHoverCardPortal, typeof HlmHoverCard, typeof HlmHoverCardTrigger];
+
+type IconSize = 'xs' | 'sm' | 'base' | 'lg' | 'xl' | 'none' | (Record<never, never> & string);
+declare class HlmIcon {
+    private readonly _config;
+    readonly size: i0.InputSignal<IconSize>;
+    protected readonly _computedSize: i0.Signal<"none" | (Record<never, never> & string) | "12px" | "16px" | "24px" | "32px" | "48px">;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmIcon, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmIcon, "ng-icon[hlmIcon], ng-icon[hlm]", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface HlmIconConfig {
+    size: IconSize;
+}
+declare function provideHlmIconConfig(config: Partial<HlmIconConfig>): ValueProvider;
+declare function injectHlmIconConfig(): HlmIconConfig;
+
+declare const HlmIconImports: readonly [typeof HlmIcon, typeof NgIcon];
+
+declare const inputVariants: (props?: ({
+    error?: boolean | "auto" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type InputVariants = VariantProps<typeof inputVariants>;
+declare class HlmInput implements BrnFormFieldControl, DoCheck {
+    private readonly _injector;
+    private readonly _additionalClasses;
+    private readonly _errorStateTracker;
+    private readonly _defaultErrorStateMatcher;
+    private readonly _parentForm;
+    private readonly _parentFormGroup;
+    readonly error: i0.InputSignal<boolean | "auto" | null | undefined>;
+    protected readonly _state: i0.WritableSignal<{
+        error: boolean | "auto" | null | undefined;
+    }>;
+    readonly ngControl: NgControl | null;
+    readonly errorState: i0.Signal<boolean>;
+    constructor();
+    ngDoCheck(): void;
+    setError(error: InputVariants['error']): void;
+    setClass(classes: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmInput, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmInput, "[hlmInput]", never, { "error": { "alias": "error"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare const HlmInputImports: readonly [typeof HlmInput];
+
+declare class HlmInputGroup {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmInputGroup, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmInputGroup, "[hlmInputGroup],hlm-input-group", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmInputGroupAddon {
+    readonly align: i0.InputSignal<"inline-start" | "inline-end" | "block-start" | "block-end" | null | undefined>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmInputGroupAddon, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmInputGroupAddon, "hlm-input-group-addon,[hlmInputGroupAddon]", never, { "align": { "alias": "align"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class HlmInputGroupButton {
+    readonly size: i0.InputSignal<"xs" | "sm" | "icon-xs" | "icon-sm" | null | undefined>;
+    readonly type: i0.InputSignal<"button" | "submit" | "reset">;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmInputGroupButton, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmInputGroupButton, "button[hlmInputGroupButton]", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof HlmButton; inputs: { "variant": "variant"; }; outputs: {}; }]>;
+}
+
+declare class HlmInputGroupInput {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmInputGroupInput, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmInputGroupInput, "input[hlmInputGroupInput]", never, {}, {}, never, never, true, [{ directive: typeof HlmInput; inputs: {}; outputs: {}; }]>;
+}
+
+declare class HlmInputGroupText {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmInputGroupText, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmInputGroupText, "span[hlmInputGroupText]", never, {}, {}, never, never, true, never>;
+}
+
+declare const textareaVariants: (props?: ({
+    error?: boolean | "auto" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type TextareaVariants = VariantProps<typeof textareaVariants>;
+declare class HlmTextarea implements BrnFormFieldControl, DoCheck {
+    private readonly _injector;
+    private readonly _additionalClasses;
+    private readonly _errorStateTracker;
+    private readonly _defaultErrorStateMatcher;
+    private readonly _parentForm;
+    private readonly _parentFormGroup;
+    readonly error: i0.InputSignal<boolean | "auto" | null | undefined>;
+    protected readonly _state: i0.WritableSignal<{
+        error: boolean | "auto" | null | undefined;
+    }>;
+    readonly ngControl: NgControl | null;
+    readonly errorState: i0.Signal<boolean>;
+    constructor();
+    ngDoCheck(): void;
+    setError(error: TextareaVariants['error']): void;
+    setClass(classes: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmTextarea, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmTextarea, "[hlmTextarea]", never, { "error": { "alias": "error"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class HlmInputGroupTextarea {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmInputGroupTextarea, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmInputGroupTextarea, "textarea[hlmInputGroupTextarea]", never, {}, {}, never, never, true, [{ directive: typeof HlmTextarea; inputs: {}; outputs: {}; }]>;
+}
+
+declare const HlmInputGroupImports: readonly [typeof HlmInputGroup, typeof HlmInputGroupAddon, typeof HlmInputGroupButton, typeof HlmInputGroupInput, typeof HlmInputGroupText, typeof HlmInputGroupTextarea];
+
+declare class HlmInputOtp {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmInputOtp, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmInputOtp, "brn-input-otp[hlmInputOtp], brn-input-otp[hlm]", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmInputOtpFakeCaret {
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmInputOtpFakeCaret, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HlmInputOtpFakeCaret, "hlm-input-otp-fake-caret", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmInputOtpGroup {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmInputOtpGroup, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmInputOtpGroup, "[hlmInputOtpGroup]", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmInputOtpSeparator {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmInputOtpSeparator, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HlmInputOtpSeparator, "hlm-input-otp-separator", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmInputOtpSlot {
+    /** The index of the slot to render the char or a fake caret */
+    readonly index: i0.InputSignalWithTransform<number, NumberInput>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmInputOtpSlot, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HlmInputOtpSlot, "hlm-input-otp-slot", never, { "index": { "alias": "index"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare const HlmInputOtpImports: readonly [typeof HlmInputOtp, typeof HlmInputOtpGroup, typeof HlmInputOtpSeparator, typeof HlmInputOtpSlot, typeof HlmInputOtpFakeCaret];
+
+declare const itemVariants: (props?: ({
+    variant?: "default" | "outline" | "muted" | null | undefined;
+    size?: "sm" | "default" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type ItemVariants = VariantProps<typeof itemVariants>;
+declare class HlmItem {
+    private readonly _config;
+    readonly variant: i0.InputSignal<"default" | "outline" | "muted" | null | undefined>;
+    readonly size: i0.InputSignal<"sm" | "default" | null | undefined>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmItem, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmItem, "div[hlmItem], a[hlmItem]", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class HlmItemActions {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmItemActions, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmItemActions, "[hlmItemActions],hlm-item-actions", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmItemContent {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmItemContent, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmItemContent, "[hlmItemContent],hlm-item-content", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmItemDescription {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmItemDescription, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmItemDescription, "p[hlmItemDescription]", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmItemFooter {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmItemFooter, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmItemFooter, "[hlmItemFooter],hlm-item-footer", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmItemGroup {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmItemGroup, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmItemGroup, "[hlmItemGroup],hlm-item-group", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmItemHeader {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmItemHeader, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmItemHeader, "[hlmItemHeader],hlm-item-header", never, {}, {}, never, never, true, never>;
+}
+
+declare const itemMediaVariants: (props?: ({
+    variant?: "default" | "icon" | "image" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type ItemMediaVariants = VariantProps<typeof itemMediaVariants>;
+declare class HlmItemMedia {
+    private readonly _config;
+    readonly variant: i0.InputSignal<"default" | "icon" | "image" | null | undefined>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmItemMedia, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmItemMedia, "[hlmItemMedia],hlm-item-media", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class HlmItemSeparator {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmItemSeparator, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmItemSeparator, "div[hlmItemSeparator]", never, {}, {}, never, never, true, [{ directive: typeof i1$6.BrnSeparator; inputs: { "orientation": "orientation"; }; outputs: {}; }]>;
+}
+
+declare class HlmItemTitle {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmItemTitle, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmItemTitle, "[hlmItemTitle],hlm-item-title", never, {}, {}, never, never, true, never>;
+}
+
+interface HlmItemConfig {
+    variant: ItemVariants['variant'];
+    size: ItemVariants['size'];
+}
+declare function provideHlmItemConfig(config: Partial<HlmItemConfig>): ValueProvider;
+declare function injectHlmItemConfig(): HlmItemConfig;
+interface HlmItemMediaConfig {
+    variant: ItemMediaVariants['variant'];
+}
+declare function provideHlmItemMediaConfig(config: Partial<HlmItemMediaConfig>): ValueProvider;
+declare function injectHlmItemMediaConfig(): HlmItemMediaConfig;
+
+declare const HlmItemImports: readonly [typeof HlmItem, typeof HlmItemActions, typeof HlmItemContent, typeof HlmItemDescription, typeof HlmItemFooter, typeof HlmItemGroup, typeof HlmItemHeader, typeof HlmItemMedia, typeof HlmItemSeparator, typeof HlmItemTitle];
+
+declare class HlmKbd {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmKbd, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmKbd, "kbd[hlmKbd]", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmKbdGroup {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmKbdGroup, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmKbdGroup, "kbd[hlmKbdGroup]", never, {}, {}, never, never, true, never>;
+}
+
+declare const HlmKbdImports: readonly [typeof HlmKbd, typeof HlmKbdGroup];
+
+declare const HlmLabelImports: readonly [typeof HlmLabel];
+
+declare class HlmMenubar {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmMenubar, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmMenubar, "[hlmMenubar],hlm-menubar", never, {}, {}, never, never, true, [{ directive: typeof i1$9.CdkMenuBar; inputs: {}; outputs: {}; }]>;
+}
+
+declare class HlmMenubarTrigger {
+    private readonly _cdkTrigger;
+    private readonly _config;
+    readonly disabled: i0.InputSignalWithTransform<boolean, BooleanInput>;
+    readonly align: i0.InputSignal<MenuAlign>;
+    readonly side: i0.InputSignal<MenuSide>;
+    private readonly _menuPosition;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmMenubarTrigger, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmMenubarTrigger, "button[hlmMenubarTrigger]", never, { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "align": { "alias": "align"; "required": false; "isSignal": true; }; "side": { "alias": "side"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1$9.CdkMenuItem; inputs: { "cdkMenuItemDisabled": "disabled"; }; outputs: {}; }, { directive: typeof i1$9.CdkMenuTrigger; inputs: { "cdkMenuTriggerFor": "hlmMenubarTrigger"; "cdkMenuTriggerData": "hlmMenubarTriggerData"; }; outputs: { "cdkMenuOpened": "hlmDropdownMenuOpened"; "cdkMenuClosed": "hlmDropdownMenuClosed"; }; }]>;
+}
+
+interface HlmMenubarConfig {
+    align: MenuAlign;
+    side: MenuSide;
+}
+declare function provideHlmMenubarConfig(config: Partial<HlmMenubarConfig>): ValueProvider;
+declare function injectHlmMenubarConfig(): HlmMenubarConfig;
+
+declare const HlmMenubarImports: readonly [typeof HlmMenubar, typeof HlmMenubarTrigger];
+
+declare const HLM_NATIVE_SELECT_VALUE_ACCESSOR: {
+    provide: i0.InjectionToken<readonly ControlValueAccessor[]>;
+    useExisting: i0.Type<any>;
+    multi: boolean;
+};
+declare class HlmNativeSelect implements ControlValueAccessor {
+    private static _id;
+    readonly selectId: i0.InputSignal<string>;
+    protected readonly _selectId: i0.Signal<string>;
+    readonly selectClass: i0.InputSignal<ClassValue>;
+    protected readonly _computedSelectClass: i0.Signal<string>;
+    readonly selectIconClass: i0.InputSignal<ClassValue>;
+    protected readonly _computedSelectIconClass: i0.Signal<string>;
+    readonly size: i0.InputSignal<"sm" | "default">;
+    readonly disabled: i0.InputSignalWithTransform<boolean, BooleanInput>;
+    protected readonly _disabled: i0.WritableSignal<boolean>;
+    readonly ariaInvalid: i0.InputSignalWithTransform<boolean, BooleanInput>;
+    readonly value: i0.ModelSignal<string | null>;
+    readonly valueChange: i0.OutputEmitterRef<string | null>;
+    protected _onChange?: ChangeFn<string | null>;
+    protected _onTouched?: TouchFn;
+    constructor();
+    protected _valueChanged(event: Event): void;
+    protected _blur(): void;
+    /** CONTROL VALUE ACCESSOR */
+    writeValue(value: string | null): void;
+    registerOnChange(fn: ChangeFn<string | null>): void;
+    registerOnTouched(fn: TouchFn): void;
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmNativeSelect, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HlmNativeSelect, "hlm-native-select", never, { "selectId": { "alias": "selectId"; "required": false; "isSignal": true; }; "selectClass": { "alias": "selectClass"; "required": false; "isSignal": true; }; "selectIconClass": { "alias": "selectIconClass"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "ariaInvalid": { "alias": "aria-invalid"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "valueChange": "valueChange"; }, never, ["*"], true, never>;
+}
+
+declare class HlmNativeSelectOptGroup {
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmNativeSelectOptGroup, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmNativeSelectOptGroup, "[hlmNativeSelectOptGroup]", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmNativeSelectOption {
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmNativeSelectOption, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmNativeSelectOption, "[hlmNativeSelectOption]", never, {}, {}, never, never, true, never>;
+}
+
+declare const HlmNativeSelectImports: readonly [typeof HlmNativeSelect, typeof HlmNativeSelectOption, typeof HlmNativeSelectOptGroup];
+
+declare class HlmNavigationMenu {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmNavigationMenu, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmNavigationMenu, "nav[hlmNavigationMenu]", never, {}, {}, never, never, true, [{ directive: typeof i1$d.BrnNavigationMenu; inputs: { "value": "value"; "delayDuration": "delayDuration"; "skipDelayDuration": "skipDelayDuration"; "orientation": "orientation"; "openOn": "openOn"; }; outputs: { "valueChange": "valueChange"; }; }]>;
+}
+
+declare class HlmNavigationMenuContent {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmNavigationMenuContent, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmNavigationMenuContent, "[hlmNavigationMenuContent],hlm-navigation-menu-content", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmNavigationMenuItem {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmNavigationMenuItem, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmNavigationMenuItem, "li[hlmNavigationMenuItem]", never, {}, {}, never, never, true, [{ directive: typeof i1$d.BrnNavigationMenuItem; inputs: { "id": "id"; }; outputs: {}; }]>;
+}
+
+declare class HlmNavigationMenuLink {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmNavigationMenuLink, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmNavigationMenuLink, "a[hlmNavigationMenuLink]", never, {}, {}, never, never, true, [{ directive: typeof i1$d.BrnNavigationMenuLink; inputs: { "active": "active"; }; outputs: {}; }]>;
+}
+
+declare class HlmNavigationMenuList {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmNavigationMenuList, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmNavigationMenuList, "ul[hlmNavigationMenuList]", never, {}, {}, never, never, true, [{ directive: typeof i1$d.BrnNavigationMenuList; inputs: {}; outputs: {}; }]>;
+}
+
+declare class HlmNavigationMenuPortal {
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmNavigationMenuPortal, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmNavigationMenuPortal, "[hlmNavigationMenuPortal]", never, {}, {}, never, never, true, [{ directive: typeof i1$d.BrnNavigationMenuContent; inputs: {}; outputs: {}; }]>;
+}
+
+declare class HlmNavigationMenuTrigger {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmNavigationMenuTrigger, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmNavigationMenuTrigger, "button[hlmNavigationMenuTrigger]", never, {}, {}, never, never, true, [{ directive: typeof i1$d.BrnNavigationMenuTrigger; inputs: {}; outputs: {}; }]>;
+}
+
+declare const HlmNavigationMenuImports: readonly [typeof HlmNavigationMenu, typeof HlmNavigationMenuContent, typeof HlmNavigationMenuItem, typeof HlmNavigationMenuLink, typeof HlmNavigationMenuList, typeof HlmNavigationMenuPortal, typeof HlmNavigationMenuTrigger];
+
+declare class HlmNumberedPagination {
+    /**
+     * The current (active) page.
+     */
+    readonly currentPage: i0.ModelSignal<number>;
+    /**
+     * The number of items per paginated page.
+     */
+    readonly itemsPerPage: i0.ModelSignal<number>;
+    /**
+     * The total number of items in the collection. Only useful when
+     * doing server-side paging, where the collection size is limited
+     * to a single page returned by the server API.
+     */
+    readonly totalItems: i0.InputSignalWithTransform<number, NumberInput>;
+    /**
+     * The number of page links to show.
+     */
+    readonly maxSize: i0.InputSignalWithTransform<number, NumberInput>;
+    /**
+     * Show the first and last page buttons.
+     */
+    readonly showEdges: i0.InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * The page sizes to show.
+     * Defaults to [10, 20, 50, 100]
+     */
+    readonly pageSizes: i0.InputSignal<number[]>;
+    protected readonly _pageSizesWithCurrent: i0.Signal<number[]>;
+    protected readonly _isFirstPageActive: i0.Signal<boolean>;
+    protected readonly _isLastPageActive: i0.Signal<boolean>;
+    protected readonly _lastPageNumber: i0.Signal<number>;
+    protected readonly _pages: i0.Signal<Page[]>;
+    protected goToPrevious(): void;
+    protected goToNext(): void;
+    protected goToFirst(): void;
+    protected goToLast(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmNumberedPagination, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HlmNumberedPagination, "hlm-numbered-pagination", never, { "currentPage": { "alias": "currentPage"; "required": true; "isSignal": true; }; "itemsPerPage": { "alias": "itemsPerPage"; "required": true; "isSignal": true; }; "totalItems": { "alias": "totalItems"; "required": true; "isSignal": true; }; "maxSize": { "alias": "maxSize"; "required": false; "isSignal": true; }; "showEdges": { "alias": "showEdges"; "required": false; "isSignal": true; }; "pageSizes": { "alias": "pageSizes"; "required": false; "isSignal": true; }; }, { "currentPage": "currentPageChange"; "itemsPerPage": "itemsPerPageChange"; }, never, never, true, never>;
+}
+type Page = number | '...';
+/**
+ * Checks that the instance.currentPage property is within bounds for the current page range.
+ * If not, return a correct value for currentPage, or the current value if OK.
+ *
+ * Copied from 'ngx-pagination' package
+ */
+declare function outOfBoundCorrection(totalItems: number, itemsPerPage: number, currentPage: number): number;
+/**
+ * Returns an array of Page objects to use in the pagination controls.
+ *
+ * Copied from 'ngx-pagination' package
+ */
+declare function createPageArray(currentPage: number, itemsPerPage: number, totalItems: number, paginationRange: number): Page[];
+
+declare class HlmNumberedPaginationQueryParams {
+    /**
+     * The current (active) page.
+     */
+    readonly currentPage: i0.ModelSignal<number>;
+    /**
+     * The number of items per paginated page.
+     */
+    readonly itemsPerPage: i0.ModelSignal<number>;
+    /**
+     * The total number of items in the collection. Only useful when
+     * doing server-side paging, where the collection size is limited
+     * to a single page returned by the server API.
+     */
+    readonly totalItems: i0.InputSignalWithTransform<number, NumberInput>;
+    /**
+     * The URL path to use for the pagination links.
+     * Defaults to '.' (current path).
+     */
+    readonly link: i0.InputSignal<string>;
+    /**
+     * The number of page links to show.
+     */
+    readonly maxSize: i0.InputSignalWithTransform<number, NumberInput>;
+    /**
+     * Show the first and last page buttons.
+     */
+    readonly showEdges: i0.InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * The page sizes to show.
+     * Defaults to [10, 20, 50, 100]
+     */
+    readonly pageSizes: i0.InputSignal<number[]>;
+    protected readonly _pageSizesWithCurrent: i0.Signal<number[]>;
+    protected readonly _isFirstPageActive: i0.Signal<boolean>;
+    protected readonly _isLastPageActive: i0.Signal<boolean>;
+    protected readonly _lastPageNumber: i0.Signal<number>;
+    protected readonly _pages: i0.Signal<(number | "...")[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmNumberedPaginationQueryParams, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HlmNumberedPaginationQueryParams, "hlm-numbered-pagination-query-params", never, { "currentPage": { "alias": "currentPage"; "required": true; "isSignal": true; }; "itemsPerPage": { "alias": "itemsPerPage"; "required": true; "isSignal": true; }; "totalItems": { "alias": "totalItems"; "required": true; "isSignal": true; }; "link": { "alias": "link"; "required": false; "isSignal": true; }; "maxSize": { "alias": "maxSize"; "required": false; "isSignal": true; }; "showEdges": { "alias": "showEdges"; "required": false; "isSignal": true; }; "pageSizes": { "alias": "pageSizes"; "required": false; "isSignal": true; }; }, { "currentPage": "currentPageChange"; "itemsPerPage": "itemsPerPageChange"; }, never, never, true, never>;
+}
+
+declare class HlmPagination {
+    /** The aria-label for the pagination component. */
+    readonly ariaLabel: i0.InputSignal<string>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmPagination, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmPagination, "[hlmPagination],hlm-pagination", never, { "ariaLabel": { "alias": "aria-label"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class HlmPaginationContent {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmPaginationContent, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmPaginationContent, "ul[hlmPaginationContent]", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmPaginationEllipsis {
+    constructor();
+    /** Screen reader only text for the ellipsis */
+    readonly srOnlyText: i0.InputSignal<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmPaginationEllipsis, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HlmPaginationEllipsis, "hlm-pagination-ellipsis", never, { "srOnlyText": { "alias": "srOnlyText"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class HlmPaginationItem {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmPaginationItem, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmPaginationItem, "li[hlmPaginationItem]", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmPaginationLink {
+    /** Whether the link is active (i.e., the current page). */
+    readonly isActive: i0.InputSignalWithTransform<boolean, BooleanInput>;
+    /** The size of the button. */
+    readonly size: i0.InputSignal<"xs" | "sm" | "lg" | "default" | "icon" | "icon-xs" | "icon-sm" | "icon-lg" | null | undefined>;
+    /** The link to navigate to the page. */
+    readonly link: i0.InputSignal<string | readonly any[] | _angular_router.UrlTree | null | undefined>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmPaginationLink, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmPaginationLink, "[hlmPaginationLink]", never, { "isActive": { "alias": "isActive"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "link": { "alias": "link"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof _angular_router.RouterLink; inputs: { "target": "target"; "queryParams": "queryParams"; "fragment": "fragment"; "queryParamsHandling": "queryParamsHandling"; "state": "state"; "info": "info"; "relativeTo": "relativeTo"; "preserveFragment": "preserveFragment"; "skipLocationChange": "skipLocationChange"; "replaceUrl": "replaceUrl"; "routerLink": "link"; }; outputs: {}; }]>;
+}
+
+declare class HlmPaginationNext {
+    constructor();
+    /** The link to navigate to the next page. */
+    readonly link: i0.InputSignal<string | readonly any[] | _angular_router.UrlTree | null | undefined>;
+    /** The query parameters to pass to the next page. */
+    readonly queryParams: i0.InputSignal<_angular_router.Params | null | undefined>;
+    /** How to handle query parameters when navigating to the next page. */
+    readonly queryParamsHandling: i0.InputSignal<_angular_router.QueryParamsHandling | null | undefined>;
+    /** The aria-label for the next page link. */
+    readonly ariaLabel: i0.InputSignal<string>;
+    /** The text to display for the next page link. */
+    readonly text: i0.InputSignal<string>;
+    /** Whether the button should only display the icon. */
+    readonly iconOnly: i0.InputSignalWithTransform<boolean, BooleanInput>;
+    protected readonly _labelClass: i0.Signal<"sr-only" | "hidden sm:block">;
+    protected readonly _size: i0.Signal<"xs" | "sm" | "lg" | "default" | "icon" | "icon-xs" | "icon-sm" | "icon-lg" | null | undefined>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmPaginationNext, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HlmPaginationNext, "hlm-pagination-next", never, { "link": { "alias": "link"; "required": false; "isSignal": true; }; "queryParams": { "alias": "queryParams"; "required": false; "isSignal": true; }; "queryParamsHandling": { "alias": "queryParamsHandling"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "aria-label"; "required": false; "isSignal": true; }; "text": { "alias": "text"; "required": false; "isSignal": true; }; "iconOnly": { "alias": "iconOnly"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class HlmPaginationPrevious {
+    /** The link to navigate to the previous page. */
+    readonly link: i0.InputSignal<string | readonly any[] | _angular_router.UrlTree | null | undefined>;
+    /** The query parameters to pass to the previous page. */
+    readonly queryParams: i0.InputSignal<_angular_router.Params | null | undefined>;
+    /** How to handle query parameters when navigating to the previous page. */
+    readonly queryParamsHandling: i0.InputSignal<_angular_router.QueryParamsHandling | null | undefined>;
+    /** The aria-label for the previous page link. */
+    readonly ariaLabel: i0.InputSignal<string>;
+    /** The text to display for the previous page link. */
+    readonly text: i0.InputSignal<string>;
+    /** Whether the button should only display the icon. */
+    readonly iconOnly: i0.InputSignalWithTransform<boolean, BooleanInput>;
+    protected readonly _labelClass: i0.Signal<"sr-only" | "hidden sm:block">;
+    protected readonly _size: i0.Signal<"xs" | "sm" | "lg" | "default" | "icon" | "icon-xs" | "icon-sm" | "icon-lg" | null | undefined>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmPaginationPrevious, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HlmPaginationPrevious, "hlm-pagination-previous", never, { "link": { "alias": "link"; "required": false; "isSignal": true; }; "queryParams": { "alias": "queryParams"; "required": false; "isSignal": true; }; "queryParamsHandling": { "alias": "queryParamsHandling"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "aria-label"; "required": false; "isSignal": true; }; "text": { "alias": "text"; "required": false; "isSignal": true; }; "iconOnly": { "alias": "iconOnly"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare const HlmPaginationImports: readonly [typeof HlmPagination, typeof HlmPaginationContent, typeof HlmPaginationItem, typeof HlmPaginationLink, typeof HlmPaginationPrevious, typeof HlmPaginationNext, typeof HlmPaginationEllipsis, typeof HlmNumberedPagination, typeof HlmNumberedPaginationQueryParams];
+
+declare class HlmPopover {
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmPopover, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmPopover, "[hlmPopover],hlm-popover", never, {}, {}, never, never, true, [{ directive: typeof i1$4.BrnPopover; inputs: { "align": "align"; "autoFocus": "autoFocus"; "attachTo": "attachTo"; "closeDelay": "closeDelay"; "closeOnOutsidePointerEvents": "closeOnOutsidePointerEvents"; "offsetX": "offsetX"; "restoreFocus": "restoreFocus"; "sideOffset": "sideOffset"; "state": "state"; }; outputs: { "stateChanged": "stateChanged"; "closed": "closed"; }; }]>;
+}
+
+declare class HlmPopoverContent {
+    private readonly _stateProvider;
+    state: i0.Signal<"open" | "closed">;
+    private readonly _renderer;
+    private readonly _element;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmPopoverContent, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmPopoverContent, "[hlmPopoverContent],hlm-popover-content", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmPopoverPortal {
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmPopoverPortal, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmPopoverPortal, "[hlmPopoverPortal]", never, {}, {}, never, never, true, [{ directive: typeof i1$4.BrnPopoverContent; inputs: { "context": "context"; "class": "class"; }; outputs: {}; }]>;
+}
+
+declare class HlmPopoverTrigger {
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmPopoverTrigger, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmPopoverTrigger, "button[hlmPopoverTrigger],button[hlmPopoverTriggerFor]", never, {}, {}, never, never, true, [{ directive: typeof i1$4.BrnPopoverTrigger; inputs: { "id": "id"; "brnPopoverTriggerFor": "hlmPopoverTriggerFor"; "type": "type"; }; outputs: {}; }]>;
+}
+
+declare const HlmPopoverImports: readonly [typeof HlmPopover, typeof HlmPopoverContent, typeof HlmPopoverPortal, typeof HlmPopoverTrigger];
+
+declare class HlmProgress {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmProgress, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmProgress, "hlm-progress,[hlmProgress]", never, {}, {}, never, never, true, [{ directive: typeof i1$e.BrnProgress; inputs: { "value": "value"; "max": "max"; "getValueLabel": "getValueLabel"; }; outputs: {}; }]>;
+}
+
+declare class HlmProgressIndicator {
+    private readonly _progress;
+    protected readonly _transform: i0.Signal<string>;
+    protected readonly _indeterminate: i0.Signal<boolean>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmProgressIndicator, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmProgressIndicator, "[hlmProgressIndicator],hlm-progress-indicator", never, {}, {}, never, never, true, [{ directive: typeof i1$e.BrnProgressIndicator; inputs: {}; outputs: {}; }]>;
+}
+
+declare const HlmProgressImports: readonly [typeof HlmProgress, typeof HlmProgressIndicator];
+
+declare class HlmRadio<T = unknown> {
+    private readonly _document;
+    private readonly _renderer;
+    private readonly _elementRef;
+    private readonly _isBrowser;
+    readonly userClass: i0.InputSignal<ClassValue>;
+    protected readonly _computedClass: i0.Signal<string>;
+    /** Used to set the id on the underlying brn element. */
+    readonly id: i0.InputSignal<string | undefined>;
+    /** Used to set the aria-label attribute on the underlying brn element. */
+    readonly ariaLabel: i0.InputSignal<string | undefined>;
+    /** Used to set the aria-labelledby attribute on the underlying brn element. */
+    readonly ariaLabelledby: i0.InputSignal<string | undefined>;
+    /** Used to set the aria-describedby attribute on the underlying brn element. */
+    readonly ariaDescribedby: i0.InputSignal<string | undefined>;
+    /**
+     * The value this radio button represents.
+     */
+    readonly value: i0.InputSignal<T>;
+    /** Whether the checkbox is required. */
+    readonly required: i0.InputSignalWithTransform<boolean, BooleanInput>;
+    /** Whether the checkbox is disabled. */
+    readonly disabled: i0.InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * Event emitted when the checked state of this radio button changes.
+     */
+    readonly change: i0.OutputEmitterRef<BrnRadioChange<T>>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmRadio<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HlmRadio<any>, "hlm-radio", never, { "userClass": { "alias": "class"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "aria-label"; "required": false; "isSignal": true; }; "ariaLabelledby": { "alias": "aria-labelledby"; "required": false; "isSignal": true; }; "ariaDescribedby": { "alias": "aria-describedby"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": true; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "change": "change"; }, never, ["[target],[indicator],hlm-radio-indicator", "*"], true, never>;
+}
+
+declare class HlmRadioGroup {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmRadioGroup, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmRadioGroup, "[hlmRadioGroup],hlm-radio-group", never, {}, {}, never, never, true, [{ directive: typeof i1$f.BrnRadioGroup; inputs: { "name": "name"; "value": "value"; "disabled": "disabled"; "required": "required"; }; outputs: { "valueChange": "valueChange"; }; }]>;
+}
+
+declare class HlmRadioIndicator {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmRadioIndicator, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HlmRadioIndicator, "hlm-radio-indicator", never, {}, {}, never, never, true, never>;
+}
+
+declare const HlmRadioGroupImports: readonly [typeof HlmRadioGroup, typeof HlmRadio, typeof HlmRadioIndicator];
+
+declare class HlmResizableGroup {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmResizableGroup, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmResizableGroup, "[hlmResizableGroup],hlm-resizable-group", never, {}, {}, never, never, true, [{ directive: typeof i1$g.BrnResizableGroup; inputs: { "direction": "direction"; "layout": "layout"; }; outputs: { "dragEnd": "dragEnd"; "dragStart": "dragStart"; "layoutChange": "layoutChange"; }; }]>;
+}
+
+declare class HlmResizableHandle {
+    protected readonly _brnResizableHandle: BrnResizableHandle;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmResizableHandle, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HlmResizableHandle, "hlm-resizable-handle", ["hlmResizableHandle"], {}, {}, never, never, true, [{ directive: typeof i1$g.BrnResizableHandle; inputs: { "withHandle": "withHandle"; "disabled": "disabled"; }; outputs: {}; }]>;
+}
+
+declare class HlmResizablePanel {
+    private readonly _resizablePanel;
+    setSize(size: number): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmResizablePanel, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmResizablePanel, "[hlmResizablePanel],hlm-resizable-panel", ["hlmResizablePanel"], {}, {}, never, never, true, [{ directive: typeof i1$g.BrnResizablePanel; inputs: { "defaultSize": "defaultSize"; "id": "id"; "collapsible": "collapsible"; "maxSize": "maxSize"; "minSize": "minSize"; }; outputs: {}; }]>;
+}
+
+declare const HlmResizableImports: readonly [typeof HlmResizableGroup, typeof HlmResizablePanel, typeof HlmResizableHandle];
+
+declare class HlmScrollArea {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmScrollArea, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmScrollArea, "ng-scrollbar[hlm],ng-scrollbar[hlmScrollbar]", never, {}, {}, never, never, true, never>;
+}
+
+declare const HlmScrollAreaImports: readonly [typeof HlmScrollArea];
+
+declare class HlmSelect {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSelect, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmSelect, "hlm-select, brn-select [hlm]", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmSelectContent {
+    readonly stickyLabels: i0.InputSignalWithTransform<boolean, BooleanInput>;
+    protected readonly _stateProvider: _spartan_ng_brain_core.ExposesState | null;
+    protected readonly _sideProvider: _spartan_ng_brain_core.ExposesSide | null;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSelectContent, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmSelectContent, "[hlmSelectContent], hlm-select-content", never, { "stickyLabels": { "alias": "stickyLabels"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class HlmSelectGroup {
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSelectGroup, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmSelectGroup, "[hlmSelectGroup], hlm-select-group", never, {}, {}, never, never, true, [{ directive: typeof i1$h.BrnSelectGroup; inputs: {}; outputs: {}; }]>;
+}
+
+declare class HlmSelectLabel {
+    private readonly _selectContent;
+    private readonly _stickyLabels;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSelectLabel, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmSelectLabel, "[hlmSelectLabel], hlm-select-label", never, {}, {}, never, never, true, [{ directive: typeof i1$h.BrnSelectLabel; inputs: {}; outputs: {}; }]>;
+}
+
+declare class HlmSelectOption {
+    protected readonly _brnSelectOption: BrnSelectOption<any>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSelectOption, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HlmSelectOption, "hlm-option", never, {}, {}, never, ["*"], true, [{ directive: typeof i1$h.BrnSelectOption; inputs: { "disabled": "disabled"; "value": "value"; }; outputs: {}; }]>;
+}
+
+declare class HlmSelectScrollDown {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSelectScrollDown, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HlmSelectScrollDown, "hlm-select-scroll-down", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmSelectScrollUp {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSelectScrollUp, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HlmSelectScrollUp, "hlm-select-scroll-up", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmSelectSeparator {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSelectSeparator, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmSelectSeparator, "[hlmSelectSeparator]", never, {}, {}, never, never, true, never>;
+}
+
+declare const selectTriggerVariants: (props?: ({
+    error?: boolean | "auto" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare class HlmSelectTrigger {
+    protected readonly _icon: i0.Signal<HlmIcon | undefined>;
+    protected readonly _brnSelect: BrnSelect<any> | null;
+    readonly userClass: i0.InputSignal<ClassValue>;
+    readonly size: i0.InputSignal<"sm" | "default">;
+    protected readonly _computedClass: i0.Signal<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSelectTrigger, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HlmSelectTrigger, "hlm-select-trigger", never, { "userClass": { "alias": "class"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, ["_icon"], ["*", "ng-icon"], true, never>;
+}
+
+declare class HlmSelectValue {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSelectValue, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmSelectValue, "hlm-select-value,[hlmSelectValue], brn-select-value[hlm]", never, {}, {}, never, never, true, never>;
+}
+
+declare const HlmSelectImports: readonly [typeof HlmSelect, typeof HlmSelectContent, typeof HlmSelectGroup, typeof HlmSelectLabel, typeof HlmSelectOption, typeof HlmSelectScrollDown, typeof HlmSelectScrollUp, typeof HlmSelectSeparator, typeof HlmSelectTrigger, typeof HlmSelectValue];
+
+declare const hlmSeparatorClass = "bg-border inline-flex shrink-0 data-[orientation=horizontal]:h-px data-[orientation=horizontal]:w-full data-[orientation=vertical]:h-full data-[orientation=vertical]:w-px";
+declare class HlmSeparator {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSeparator, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmSeparator, "[hlmSeparator],hlm-separator", never, {}, {}, never, never, true, [{ directive: typeof i1$6.BrnSeparator; inputs: { "orientation": "orientation"; "decorative": "decorative"; }; outputs: {}; }]>;
+}
+
+declare const HlmSeparatorImports: readonly [typeof HlmSeparator];
+
+declare class HlmSheet extends BrnSheet {
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSheet, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HlmSheet, "hlm-sheet", ["hlmSheet"], {}, {}, never, ["*"], true, never>;
+}
+
+declare class HlmSheetClose {
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSheetClose, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmSheetClose, "button[hlmSheetClose]", never, {}, {}, never, never, true, [{ directive: typeof i1$i.BrnSheetClose; inputs: { "delay": "delay"; }; outputs: {}; }]>;
+}
+
+declare const sheetVariants: (props?: ({
+    side?: "top" | "bottom" | "left" | "right" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare class HlmSheetContent {
+    private readonly _stateProvider;
+    private readonly _sideProvider;
+    readonly state: i0.Signal<"open" | "closed">;
+    private readonly _renderer;
+    private readonly _element;
+    readonly showCloseButton: i0.InputSignalWithTransform<boolean, BooleanInput>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSheetContent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HlmSheetContent, "hlm-sheet-content", never, { "showCloseButton": { "alias": "showCloseButton"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class HlmSheetDescription {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSheetDescription, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmSheetDescription, "[hlmSheetDescription]", never, {}, {}, never, never, true, [{ directive: typeof i1$i.BrnSheetDescription; inputs: {}; outputs: {}; }]>;
+}
+
+declare class HlmSheetFooter {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSheetFooter, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmSheetFooter, "[hlmSheetFooter],hlm-sheet-footer", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmSheetHeader {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSheetHeader, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmSheetHeader, "[hlmSheetHeader],hlm-sheet-header", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmSheetOverlay {
+    private readonly _classSettable;
+    readonly userClass: i0.InputSignal<ClassValue>;
+    protected readonly _computedClass: i0.Signal<string>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSheetOverlay, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmSheetOverlay, "[hlmSheetOverlay],hlm-sheet-overlay", never, { "userClass": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1$i.BrnSheetOverlay; inputs: {}; outputs: {}; }]>;
+}
+
+declare class HlmSheetPortal {
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSheetPortal, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmSheetPortal, "[hlmSheetPortal]", never, {}, {}, never, never, true, [{ directive: typeof i1$i.BrnSheetContent; inputs: { "context": "context"; "class": "class"; }; outputs: {}; }]>;
+}
+
+declare class HlmSheetTitle {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSheetTitle, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmSheetTitle, "[hlmSheetTitle]", never, {}, {}, never, never, true, [{ directive: typeof i1$i.BrnSheetTitle; inputs: {}; outputs: {}; }]>;
+}
+
+declare class HlmSheetTrigger {
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSheetTrigger, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmSheetTrigger, "button[hlmSheetTrigger]", never, {}, {}, never, never, true, [{ directive: typeof i1$i.BrnSheetTrigger; inputs: { "id": "id"; "side": "side"; "type": "type"; }; outputs: {}; }]>;
+}
+
+declare const HlmSheetImports: readonly [typeof HlmSheet, typeof HlmSheetClose, typeof HlmSheetContent, typeof HlmSheetDescription, typeof HlmSheetFooter, typeof HlmSheetHeader, typeof HlmSheetOverlay, typeof HlmSheetPortal, typeof HlmSheetTitle, typeof HlmSheetTrigger];
+
+type SidebarVariant = 'sidebar' | 'floating' | 'inset';
+declare class HlmSidebarService {
+    private readonly _config;
+    private readonly _document;
+    private readonly _window;
+    private readonly _open;
+    private readonly _openMobile;
+    private readonly _isMobile;
+    private readonly _variant;
+    private _mediaQuery;
+    readonly open: Signal<boolean>;
+    readonly openMobile: Signal<boolean>;
+    readonly isMobile: Signal<boolean>;
+    readonly variant: Signal<SidebarVariant>;
+    readonly state: Signal<"expanded" | "collapsed">;
+    constructor();
+    setOpen(open: boolean): void;
+    setOpenMobile(open: boolean): void;
+    setVariant(variant: SidebarVariant): void;
+    toggleSidebar(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSidebarService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<HlmSidebarService>;
+}
+
+declare class HlmSidebar {
+    protected readonly _sidebarService: HlmSidebarService;
+    private readonly _config;
+    readonly sidebarWidthMobile: i0.InputSignal<string>;
+    readonly side: i0.InputSignal<"left" | "right">;
+    readonly variant: i0.InputSignal<SidebarVariant>;
+    readonly collapsible: i0.InputSignal<"none" | "icon" | "offcanvas">;
+    protected readonly _sidebarGapComputedClass: i0.Signal<string>;
+    readonly sidebarContainerClass: i0.InputSignal<ClassValue>;
+    protected readonly _sidebarContainerComputedClass: i0.Signal<string>;
+    protected readonly _dataSlot: i0.Signal<"sidebar" | undefined>;
+    private readonly _collapsibleAndNonMobile;
+    protected readonly _dataState: i0.Signal<"expanded" | "collapsed" | undefined>;
+    protected readonly _dataCollapsible: i0.Signal<"" | "none" | "icon" | "offcanvas" | undefined>;
+    protected readonly _dataVariant: i0.Signal<SidebarVariant | undefined>;
+    protected readonly _dataSide: i0.Signal<"left" | "right" | undefined>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSidebar, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HlmSidebar, "hlm-sidebar", never, { "sidebarWidthMobile": { "alias": "sidebarWidthMobile"; "required": false; "isSignal": true; }; "side": { "alias": "side"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "collapsible": { "alias": "collapsible"; "required": false; "isSignal": true; }; "sidebarContainerClass": { "alias": "sidebarContainerClass"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class HlmSidebarContent {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSidebarContent, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmSidebarContent, "[hlmSidebarContent],hlm-sidebar-content", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmSidebarFooter {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSidebarFooter, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmSidebarFooter, "[hlmSidebarFooter],hlm-sidebar-footer", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmSidebarGroup {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSidebarGroup, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmSidebarGroup, "[hlmSidebarGroup],hlm-sidebar-group", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmSidebarGroupAction {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSidebarGroupAction, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmSidebarGroupAction, "button[hlmSidebarGroupAction]", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmSidebarGroupContent {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSidebarGroupContent, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmSidebarGroupContent, "div[hlmSidebarGroupContent]", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmSidebarGroupLabel {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSidebarGroupLabel, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmSidebarGroupLabel, "div[hlmSidebarGroupLabel], button[hlmSidebarGroupLabel]", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmSidebarHeader {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSidebarHeader, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmSidebarHeader, "[hlmSidebarHeader],hlm-sidebar-header", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmSidebarInput extends HlmInput {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSidebarInput, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmSidebarInput, "input[hlmSidebarInput]", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmSidebarInset {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSidebarInset, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmSidebarInset, "main[hlmSidebarInset]", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmSidebarMenu {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSidebarMenu, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmSidebarMenu, "ul[hlmSidebarMenu]", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmSidebarMenuAction {
+    readonly showOnHover: i0.InputSignalWithTransform<boolean, BooleanInput>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSidebarMenuAction, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmSidebarMenuAction, "button[hlmSidebarMenuAction]", never, { "showOnHover": { "alias": "showOnHover"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class HlmSidebarMenuBadge {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSidebarMenuBadge, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmSidebarMenuBadge, "[hlmSidebarMenuBadge],hlm-sidebar-menu-badge", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmSidebarMenuButton {
+    private readonly _config;
+    private readonly _sidebarService;
+    private readonly _brnTooltip;
+    readonly variant: i0.InputSignal<"default" | "outline">;
+    readonly size: i0.InputSignal<"sm" | "lg" | "default">;
+    readonly isActive: i0.InputSignalWithTransform<boolean, BooleanInput>;
+    readonly closeMobileSidebarOnClick: i0.InputSignalWithTransform<boolean, BooleanInput>;
+    protected readonly _isTooltipHidden: i0.Signal<boolean>;
+    constructor();
+    protected onClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSidebarMenuButton, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmSidebarMenuButton, "button[hlmSidebarMenuButton], a[hlmSidebarMenuButton]", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "isActive": { "alias": "isActive"; "required": false; "isSignal": true; }; "closeMobileSidebarOnClick": { "alias": "closeMobileSidebarOnClick"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1$j.BrnTooltip; inputs: { "brnTooltip": "tooltip"; }; outputs: {}; }]>;
+}
+
+declare class HlmSidebarMenuItem {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSidebarMenuItem, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmSidebarMenuItem, "li[hlmSidebarMenuItem]", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmSidebarMenuSkeleton {
+    readonly showIcon: i0.InputSignalWithTransform<boolean, BooleanInput>;
+    protected readonly _width: string;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSidebarMenuSkeleton, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HlmSidebarMenuSkeleton, "hlm-sidebar-menu-skeleton,div[hlmSidebarMenuSkeleton]", never, { "showIcon": { "alias": "showIcon"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class HlmSidebarMenuSub {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSidebarMenuSub, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmSidebarMenuSub, "ul[hlmSidebarMenuSub]", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmSidebarMenuSubButton {
+    private readonly _sidebarService;
+    private readonly _config;
+    readonly closeMobileSidebarOnClick: i0.InputSignalWithTransform<boolean, BooleanInput>;
+    readonly size: i0.InputSignal<"sm" | "md">;
+    readonly isActive: i0.InputSignalWithTransform<boolean, BooleanInput>;
+    constructor();
+    protected onClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSidebarMenuSubButton, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmSidebarMenuSubButton, "a[hlmSidebarMenuSubButton], button[hlmSidebarMenuSubButton]", never, { "closeMobileSidebarOnClick": { "alias": "closeMobileSidebarOnClick"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "isActive": { "alias": "isActive"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class HlmSidebarMenuSubItem {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSidebarMenuSubItem, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmSidebarMenuSubItem, "li[hlmSidebarMenuSubItem]", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmSidebarRail {
+    private readonly _sidebarService;
+    readonly ariaLabel: i0.InputSignal<string>;
+    constructor();
+    protected onClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSidebarRail, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmSidebarRail, "button[hlmSidebarRail]", never, { "ariaLabel": { "alias": "aria-label"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class HlmSidebarSeparator {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSidebarSeparator, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmSidebarSeparator, "[hlmSidebarSeparator],hlm-sidebar-separator", never, {}, {}, never, never, true, [{ directive: typeof HlmSeparator; inputs: {}; outputs: {}; }]>;
+}
+
+declare class HlmSidebarTrigger {
+    private readonly _hlmBtn;
+    private readonly _sidebarService;
+    constructor();
+    protected _onClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSidebarTrigger, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HlmSidebarTrigger, "button[hlmSidebarTrigger]", never, {}, {}, never, never, true, [{ directive: typeof HlmButton; inputs: {}; outputs: {}; }]>;
+}
+
+declare class HlmSidebarWrapper {
+    private readonly _config;
+    readonly sidebarWidth: i0.InputSignal<string>;
+    readonly sidebarWidthIcon: i0.InputSignal<string>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSidebarWrapper, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmSidebarWrapper, "[hlmSidebarWrapper],hlm-sidebar-wrapper", never, { "sidebarWidth": { "alias": "sidebarWidth"; "required": false; "isSignal": true; }; "sidebarWidthIcon": { "alias": "sidebarWidthIcon"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface HlmSidebarConfig {
+    sidebarWidth: string;
+    sidebarWidthMobile: string;
+    sidebarWidthIcon: string;
+    sidebarCookieName: string;
+    sidebarCookieMaxAge: number;
+    sidebarKeyboardShortcut: string;
+    mobileBreakpoint: string;
+    closeMobileSidebarOnMenuButtonClick: boolean;
+}
+declare function provideHlmSidebarConfig(config: Partial<HlmSidebarConfig>): ValueProvider;
+declare function injectHlmSidebarConfig(): HlmSidebarConfig;
+
+declare const HlmSidebarImports: readonly [typeof HlmSidebar, typeof HlmSidebarContent, typeof HlmSidebarFooter, typeof HlmSidebarGroup, typeof HlmSidebarGroupAction, typeof HlmSidebarGroupContent, typeof HlmSidebarGroupLabel, typeof HlmSidebarHeader, typeof HlmSidebarInput, typeof HlmSidebarInset, typeof HlmSidebarMenu, typeof HlmSidebarMenuSkeleton, typeof HlmSidebarMenuAction, typeof HlmSidebarMenuBadge, typeof HlmSidebarMenuButton, typeof HlmSidebarMenuItem, typeof HlmSidebarMenuSub, typeof HlmSidebarMenuSubButton, typeof HlmSidebarRail, typeof HlmSidebarSeparator, typeof HlmSidebarTrigger, typeof HlmSidebarWrapper, typeof HlmSidebarMenuSubItem];
+
+declare class HlmSkeleton {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSkeleton, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmSkeleton, "[hlmSkeleton],hlm-skeleton", never, {}, {}, never, never, true, never>;
+}
+
+declare const HlmSkeletonImports: readonly [typeof HlmSkeleton];
+
+declare class HlmSlider {
+    protected readonly _slider: BrnSlider;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSlider, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HlmSlider, "hlm-slider, brn-slider [hlm]", never, {}, {}, never, never, true, [{ directive: typeof i1$k.BrnSlider; inputs: { "id": "id"; "value": "value"; "disabled": "disabled"; "min": "min"; "max": "max"; "step": "step"; "minStepsBetweenThumbs": "minStepsBetweenThumbs"; "inverted": "inverted"; "orientation": "orientation"; "showTicks": "showTicks"; "maxTicks": "maxTicks"; "tickLabelInterval": "tickLabelInterval"; "formatTick": "formatTick"; "draggableRange": "draggableRange"; "draggableRangeOnly": "draggableRangeOnly"; "aria-label": "aria-label"; "aria-labelledby": "aria-labelledby"; }; outputs: { "valueChange": "valueChange"; }; }]>;
+}
+
+declare const HlmSliderImports: readonly [typeof HlmSlider];
+
+declare class HlmToaster {
+    readonly invert: i0.InputSignalWithTransform<boolean, string | boolean>;
+    readonly theme: i0.InputSignal<"light" | "dark" | "system">;
+    readonly position: i0.InputSignal<ngx_sonner.Position>;
+    readonly hotKey: i0.InputSignal<string[]>;
+    readonly richColors: i0.InputSignalWithTransform<boolean, string | boolean>;
+    readonly expand: i0.InputSignalWithTransform<boolean, string | boolean>;
+    readonly duration: i0.InputSignalWithTransform<number, string | number>;
+    readonly visibleToasts: i0.InputSignalWithTransform<number, string | number>;
+    readonly closeButton: i0.InputSignalWithTransform<boolean, string | boolean>;
+    readonly toastOptions: i0.InputSignal<ngx_sonner.ToastOptions>;
+    readonly offset: i0.InputSignal<string | number | null>;
+    readonly dir: i0.InputSignal<"auto" | "ltr" | "rtl">;
+    readonly userClass: i0.InputSignal<ClassValue>;
+    readonly userStyle: i0.InputSignal<Record<string, string>>;
+    protected readonly _computedClass: i0.Signal<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmToaster, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HlmToaster, "hlm-toaster", never, { "invert": { "alias": "invert"; "required": false; "isSignal": true; }; "theme": { "alias": "theme"; "required": false; "isSignal": true; }; "position": { "alias": "position"; "required": false; "isSignal": true; }; "hotKey": { "alias": "hotKey"; "required": false; "isSignal": true; }; "richColors": { "alias": "richColors"; "required": false; "isSignal": true; }; "expand": { "alias": "expand"; "required": false; "isSignal": true; }; "duration": { "alias": "duration"; "required": false; "isSignal": true; }; "visibleToasts": { "alias": "visibleToasts"; "required": false; "isSignal": true; }; "closeButton": { "alias": "closeButton"; "required": false; "isSignal": true; }; "toastOptions": { "alias": "toastOptions"; "required": false; "isSignal": true; }; "offset": { "alias": "offset"; "required": false; "isSignal": true; }; "dir": { "alias": "dir"; "required": false; "isSignal": true; }; "userClass": { "alias": "class"; "required": false; "isSignal": true; }; "userStyle": { "alias": "style"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare const HlmToasterImports: readonly [typeof HlmToaster];
+
+declare class HlmSpinner {
+    /**
+     * The name of the icon to be used as the spinner.
+     * Use provideIcons({ ... }) to register custom icons.
+     */
+    readonly icon: i0.InputSignal<string>;
+    /** Aria label for the spinner for accessibility. */
+    readonly ariaLabel: i0.InputSignal<string>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSpinner, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HlmSpinner, "hlm-spinner", never, { "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "aria-label"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare const HlmSpinnerImports: readonly [typeof HlmSpinner];
+
+declare const HLM_SWITCH_VALUE_ACCESSOR: {
+    provide: i0.InjectionToken<readonly ControlValueAccessor[]>;
+    useExisting: i0.Type<any>;
+    multi: boolean;
+};
+declare class HlmSwitch implements ControlValueAccessor {
+    readonly userClass: i0.InputSignal<ClassValue>;
+    protected readonly _computedClass: i0.Signal<string>;
+    /** The checked state of the switch. */
+    readonly checked: i0.ModelSignal<boolean>;
+    /** Emits when the checked state of the switch changes. */
+    readonly checkedChange: i0.OutputEmitterRef<boolean>;
+    /** The disabled state of the switch. */
+    readonly disabled: i0.InputSignalWithTransform<boolean, BooleanInput>;
+    /** Used to set the id on the underlying brn element. */
+    readonly id: i0.InputSignal<string | null>;
+    /** Used to set the aria-label attribute on the underlying brn element. */
+    readonly ariaLabel: i0.InputSignal<string | null>;
+    /** Used to set the aria-labelledby attribute on the underlying brn element. */
+    readonly ariaLabelledby: i0.InputSignal<string | null>;
+    /** Used to set the aria-describedby attribute on the underlying brn element. */
+    readonly ariaDescribedby: i0.InputSignal<string | null>;
+    protected readonly _disabled: i0.WritableSignal<boolean>;
+    protected _onChange?: ChangeFn<boolean>;
+    protected _onTouched?: TouchFn;
+    protected handleChange(value: boolean): void;
+    /** CONROL VALUE ACCESSOR */
+    writeValue(value: boolean): void;
+    registerOnChange(fn: ChangeFn<boolean>): void;
+    registerOnTouched(fn: TouchFn): void;
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSwitch, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HlmSwitch, "hlm-switch", never, { "userClass": { "alias": "class"; "required": false; "isSignal": true; }; "checked": { "alias": "checked"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "aria-label"; "required": false; "isSignal": true; }; "ariaLabelledby": { "alias": "aria-labelledby"; "required": false; "isSignal": true; }; "ariaDescribedby": { "alias": "aria-describedby"; "required": false; "isSignal": true; }; }, { "checked": "checkedChange"; "checkedChange": "checkedChange"; }, never, never, true, never>;
+}
+
+declare class HlmSwitchThumb {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSwitchThumb, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmSwitchThumb, "brn-switch-thumb[hlm],[hlmSwitchThumb]", never, {}, {}, never, never, true, never>;
+}
+
+declare const HlmSwitchImports: readonly [typeof HlmSwitch, typeof HlmSwitchThumb];
+
+declare const HlmTableConfigToken: InjectionToken<HlmTableVariant>;
+interface HlmTableVariant {
+    tableContainer: string;
+    table: string;
+    thead: string;
+    tbody: string;
+    tfoot: string;
+    tr: string;
+    th: string;
+    td: string;
+    caption: string;
+}
+declare const HlmTableVariantDefault: HlmTableVariant;
+declare function provideHlmTableConfig(config: Partial<HlmTableVariant>): ValueProvider;
+declare function injectHlmTableConfig(): HlmTableVariant;
+declare class HlmTableContainer {
+    private readonly _globalOrDefaultConfig;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmTableContainer, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmTableContainer, "div[hlmTableContainer]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Directive to apply Shadcn-like styling to a <table> element.
+ * It resolves and provides base classes for its child table elements.
+ * If a table has the `hlmTable` attribute, it will be styled with the provided variant.
+ * The other table elements will check if a parent table has the `hlmTable` attribute and will be styled accordingly.
+ */
+declare class HlmTable {
+    /** Input to configure the variant of the table, this input has the highest priority. */
+    readonly userVariant: i0.InputSignal<string | Partial<HlmTableVariant>>;
+    /** Global or default configuration provided by injectHlmTableConfig() */
+    private readonly _globalOrDefaultConfig;
+    protected readonly _variant: i0.Signal<HlmTableVariant>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmTable, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmTable, "table[hlmTable]", never, { "userVariant": { "alias": "hlmTable"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+/**
+ * Directive to apply Shadcn-like styling to a <thead> element
+ * within an HlmTableDirective context.
+ */
+declare class HlmTHead {
+    private readonly _globalOrDefaultConfig;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmTHead, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmTHead, "thead[hlmTHead]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Directive to apply Shadcn-like styling to a <tbody> element
+ * within an HlmTableDirective context.
+ */
+declare class HlmTBody {
+    private readonly _globalOrDefaultConfig;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmTBody, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmTBody, "tbody[hlmTBody]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Directive to apply Shadcn-like styling to a <tfoot> element
+ * within an HlmTableDirective context.
+ */
+declare class HlmTFoot {
+    private readonly _globalOrDefaultConfig;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmTFoot, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmTFoot, "tfoot[hlmTFoot]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Directive to apply Shadcn-like styling to a <tr> element
+ * within an HlmTableDirective context.
+ */
+declare class HlmTr {
+    private readonly _globalOrDefaultConfig;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmTr, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmTr, "tr[hlmTr]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Directive to apply Shadcn-like styling to a <th> element
+ * within an HlmTableDirective context.
+ */
+declare class HlmTh {
+    private readonly _globalOrDefaultConfig;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmTh, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmTh, "th[hlmTh]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Directive to apply Shadcn-like styling to a <td> element
+ * within an HlmTableDirective context.
+ */
+declare class HlmTd {
+    private readonly _globalOrDefaultConfig;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmTd, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmTd, "td[hlmTd]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Directive to apply Shadcn-like styling to a <caption> element
+ * within an HlmTableDirective context.
+ */
+declare class HlmCaption {
+    private readonly _globalOrDefaultConfig;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmCaption, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmCaption, "caption[hlmCaption]", never, {}, {}, never, never, true, never>;
+}
+
+declare const HlmTableImports: readonly [typeof HlmCaption, typeof HlmTableContainer, typeof HlmTable, typeof HlmTBody, typeof HlmTd, typeof HlmTFoot, typeof HlmTh, typeof HlmTHead, typeof HlmTr];
+
+declare class HlmTabs {
+    readonly tab: i0.InputSignal<string>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmTabs, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmTabs, "[hlmTabs],hlm-tabs", never, { "tab": { "alias": "tab"; "required": true; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1$l.BrnTabs; inputs: { "orientation": "orientation"; "activationMode": "activationMode"; "brnTabs": "tab"; }; outputs: { "tabActivated": "tabActivated"; }; }]>;
+}
+
+declare class HlmTabsContent {
+    readonly contentFor: i0.InputSignal<string>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmTabsContent, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmTabsContent, "[hlmTabsContent]", never, { "contentFor": { "alias": "hlmTabsContent"; "required": true; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1$l.BrnTabsContent; inputs: { "brnTabsContent": "hlmTabsContent"; }; outputs: {}; }]>;
+}
+
+declare class HlmTabsContentLazy {
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmTabsContentLazy, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmTabsContentLazy, "ng-template[hlmTabsContentLazy]", never, {}, {}, never, never, true, [{ directive: typeof i1$l.BrnTabsContentLazy; inputs: {}; outputs: {}; }]>;
+}
+
+declare const listVariants: (props?: ({
+    variant?: "default" | "line" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare class HlmTabsList {
+    readonly variant: i0.InputSignal<"default" | "line" | null | undefined>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmTabsList, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmTabsList, "[hlmTabsList],hlm-tabs-list", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1$l.BrnTabsList; inputs: {}; outputs: {}; }]>;
+}
+
+declare class HlmTabsPaginatedList extends BrnTabsPaginatedList {
+    constructor();
+    readonly items: i0.Signal<readonly BrnTabsTrigger[]>;
+    /** Explicitly annotating type to avoid non-portable inferred type */
+    readonly itemsChanges: Observable<ReadonlyArray<BrnPaginatedTabHeaderItem>>;
+    readonly tabListContainer: i0.Signal<ElementRef<HTMLElement>>;
+    readonly tabList: i0.Signal<ElementRef<HTMLElement>>;
+    readonly tabListInner: i0.Signal<ElementRef<HTMLElement>>;
+    readonly nextPaginator: i0.Signal<ElementRef<HTMLElement>>;
+    readonly previousPaginator: i0.Signal<ElementRef<HTMLElement>>;
+    readonly tabListClass: i0.InputSignal<ClassValue>;
+    protected readonly _tabListClass: i0.Signal<string>;
+    readonly paginationButtonClass: i0.InputSignal<ClassValue>;
+    protected readonly _paginationButtonClass: i0.Signal<string>;
+    protected _itemSelected(event: KeyboardEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmTabsPaginatedList, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HlmTabsPaginatedList, "hlm-paginated-tabs-list", never, { "tabListClass": { "alias": "tabListClass"; "required": false; "isSignal": true; }; "paginationButtonClass": { "alias": "paginationButtonClass"; "required": false; "isSignal": true; }; }, {}, ["items"], ["*"], true, never>;
+}
+
+declare class HlmTabsTrigger {
+    readonly triggerFor: i0.InputSignal<string>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmTabsTrigger, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmTabsTrigger, "[hlmTabsTrigger]", never, { "triggerFor": { "alias": "hlmTabsTrigger"; "required": true; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1$l.BrnTabsTrigger; inputs: { "brnTabsTrigger": "hlmTabsTrigger"; "disabled": "disabled"; }; outputs: {}; }]>;
+}
+
+declare const HlmTabsImports: readonly [typeof HlmTabs, typeof HlmTabsList, typeof HlmTabsTrigger, typeof HlmTabsContent, typeof HlmTabsContentLazy, typeof HlmTabsPaginatedList];
+
+declare const HlmTextareaImports: readonly [typeof HlmTextarea];
+
+declare const DEFAULT_TOOLTIP_SVG_CLASS = "bg-foreground fill-foreground z-50 block size-2.5 translate-y-[calc(-50%-2px)] rotate-45 rounded-[2px]";
+declare const DEFAULT_TOOLTIP_CONTENT_CLASSES = "bg-foreground text-background animate-in fade-in-0 zoom-in-95 data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=closed]:zoom-out-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 z-50 w-fit origin-(--radix-tooltip-content-transform-origin) rounded-md px-3 py-1.5 text-xs text-balance";
+declare const tooltipPositionVariants: (props?: ({
+    position?: "top" | "bottom" | "left" | "right" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare class HlmTooltip {
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmTooltip, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmTooltip, "[hlmTooltip]", never, {}, {}, never, never, true, [{ directive: typeof i1$j.BrnTooltip; inputs: { "brnTooltip": "hlmTooltip"; "position": "position"; "hideDelay": "hideDelay"; "showDelay": "showDelay"; "tooltipDisabled": "tooltipDisabled"; }; outputs: {}; }]>;
+}
+
+declare const HlmTooltipImports: readonly [typeof HlmTooltip];
+
+declare const toggleVariants: (props?: ({
+    variant?: "default" | "outline" | null | undefined;
+    size?: "sm" | "lg" | "default" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type ToggleVariants = VariantProps<typeof toggleVariants>;
+declare class HlmToggle {
+    readonly variant: i0.InputSignal<"default" | "outline" | null | undefined>;
+    readonly size: i0.InputSignal<"sm" | "lg" | "default" | null | undefined>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmToggle, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmToggle, "button[hlmToggle]", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1$m.BrnToggle; inputs: { "id": "id"; "value": "value"; "disabled": "disabled"; "state": "state"; "aria-label": "aria-label"; "type": "type"; }; outputs: { "stateChange": "stateChange"; }; }]>;
+}
+
+declare const HlmToggleImports: readonly [typeof HlmToggle];
+
+declare class HlmToggleGroup {
+    readonly variant: i0.InputSignal<"default" | "outline" | null | undefined>;
+    readonly size: i0.InputSignal<"sm" | "lg" | "default" | null | undefined>;
+    readonly spacing: i0.InputSignalWithTransform<number, NumberInput>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmToggleGroup, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmToggleGroup, "[hlmToggleGroup],hlm-toggle-group", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "spacing": { "alias": "spacing"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1$n.BrnToggleGroup; inputs: { "type": "type"; "value": "value"; "nullable": "nullable"; "disabled": "disabled"; }; outputs: { "valueChange": "valueChange"; }; }]>;
+}
+
+declare class HlmToggleGroupItem {
+    protected readonly _toggleGroup: _billy_mcdowell_prmn_angular_v3.HlmToggleGroup;
+    readonly variant: i0.InputSignal<"default" | "outline" | null | undefined>;
+    readonly size: i0.InputSignal<"sm" | "lg" | "default" | null | undefined>;
+    protected readonly _variant: i0.Signal<"default" | "outline" | null | undefined>;
+    protected readonly _size: i0.Signal<"sm" | "lg" | "default" | null | undefined>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmToggleGroupItem, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmToggleGroupItem, "button[hlmToggleGroupItem]", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1$n.BrnToggleGroupItem; inputs: { "id": "id"; "value": "value"; "disabled": "disabled"; "state": "state"; "aria-label": "aria-label"; "type": "type"; }; outputs: { "stateChange": "stateChange"; }; }]>;
+}
+
+declare const HlmToggleGroupToken: InjectionToken<HlmToggleGroup>;
+declare function injectHlmToggleGroup(): HlmToggleGroup;
+declare function provideHlmToggleGroup(toggleGroup: Type<HlmToggleGroup>): ExistingProvider;
+
+declare const HlmToggleGroupImports: readonly [typeof HlmToggleGroup, typeof HlmToggleGroupItem];
+
+declare const hlmBlockquote = "mt-6 border-border border-l-2 pl-6 italic";
+declare class HlmBlockquote {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmBlockquote, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmBlockquote, "[hlmBlockquote]", never, {}, {}, never, never, true, never>;
+}
+
+declare const hlmCode = "relative rounded bg-muted px-[0.3rem] py-[0.2rem] font-mono text-sm font-semibold";
+declare class HlmCode {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmCode, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmCode, "[hlmCode]", never, {}, {}, never, never, true, never>;
+}
+
+declare const hlmH1 = "scroll-m-20 text-4xl font-extrabold tracking-tight lg:text-5xl";
+declare class HlmH1 {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmH1, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmH1, "[hlmH1]", never, {}, {}, never, never, true, never>;
+}
+
+declare const hlmH2 = "scroll-m-20 border-border border-b pb-2 text-3xl font-semibold tracking-tight transition-colors first:mt-0";
+declare class HlmH2 {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmH2, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmH2, "[hlmH2]", never, {}, {}, never, never, true, never>;
+}
+
+declare const hlmH3 = "scroll-m-20 text-2xl font-semibold tracking-tight";
+declare class HlmH3 {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmH3, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmH3, "[hlmH3]", never, {}, {}, never, never, true, never>;
+}
+
+declare const hlmH4 = "scroll-m-20 text-xl font-semibold tracking-tight";
+declare class HlmH4 {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmH4, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmH4, "[hlmH4]", never, {}, {}, never, never, true, never>;
+}
+
+declare const hlmLarge = "text-lg font-semibold";
+declare class HlmLarge {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmLarge, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmLarge, "[hlmLarge]", never, {}, {}, never, never, true, never>;
+}
+
+declare const hlmLead = "text-xl text-muted-foreground";
+declare class HlmLead {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmLead, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmLead, "[hlmLead]", never, {}, {}, never, never, true, never>;
+}
+
+declare const hlmMuted = "text-sm text-muted-foreground";
+declare class HlmMuted {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmMuted, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmMuted, "[hlmMuted]", never, {}, {}, never, never, true, never>;
+}
+
+declare const hlmP = "leading-7 [&:not(:first-child)]:mt-6";
+declare class HlmP {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmP, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmP, "[hlmP]", never, {}, {}, never, never, true, never>;
+}
+
+declare const hlmSmall = "text-sm font-medium leading-none";
+declare class HlmSmall {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSmall, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmSmall, "[hlmSmall]", never, {}, {}, never, never, true, never>;
+}
+
+declare const hlmUl = "my-6 ml-6 list-disc [&>li]:mt-2";
+declare class HlmUl {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmUl, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmUl, "[hlmUl]", never, {}, {}, never, never, true, never>;
+}
+
+declare const HlmTypographyImports: (typeof HlmBlockquote)[];
+
+declare function hlm(...inputs: ClassValue[]): string;
+/**
+ * This function dynamically adds and removes classes for a given element without requiring
+ * the a class binding (e.g. `[class]="..."`) which may interfere with other class bindings.
+ *
+ * 1. This will merge the existing classes on the element with the new classes.
+ * 2. It will also remove any classes that were previously added by this function but are no longer present in the new classes.
+ * 3. Multiple calls to this function on the same element will be merged efficiently.
+ */
+declare function classes(computed: () => ClassValue[] | string, options?: ClassesOptions): void;
+interface ClassesOptions {
+    elementRef?: ElementRef<HTMLElement>;
+    injector?: Injector;
+}
+
+export { DEFAULT_TOOLTIP_CONTENT_CLASSES, DEFAULT_TOOLTIP_SVG_CLASS, HLM_CHECKBOX_VALUE_ACCESSOR, HLM_DATE_PICKER_MUTLI_VALUE_ACCESSOR, HLM_DATE_PICKER_VALUE_ACCESSOR, HLM_DATE_RANGE_PICKER_VALUE_ACCESSOR, HLM_NATIVE_SELECT_VALUE_ACCESSOR, HLM_SWITCH_VALUE_ACCESSOR, HlmAccordion, HlmAccordionContent, HlmAccordionIcon, HlmAccordionImports, HlmAccordionItem, HlmAccordionTrigger, HlmAlert, HlmAlertDescription, HlmAlertDialog, HlmAlertDialogAction, HlmAlertDialogCancel, HlmAlertDialogContent, HlmAlertDialogDescription, HlmAlertDialogFooter, HlmAlertDialogHeader, HlmAlertDialogImports, HlmAlertDialogOverlay, HlmAlertDialogPortal, HlmAlertDialogTitle, HlmAlertDialogTrigger, HlmAlertIcon, HlmAlertImports, HlmAlertTitle, HlmAspectRatio, HlmAspectRatioImports, HlmAutocomplete, HlmAutocompleteContent, HlmAutocompleteEmpty, HlmAutocompleteGroup, HlmAutocompleteImports, HlmAutocompleteInput, HlmAutocompleteItem, HlmAutocompleteLabel, HlmAutocompleteList, HlmAutocompletePortal, HlmAutocompleteSearch, HlmAutocompleteSeparator, HlmAutocompleteStatus, HlmAvatar, HlmAvatarBadge, HlmAvatarFallback, HlmAvatarGroup, HlmAvatarGroupCount, HlmAvatarImage, HlmAvatarImports, HlmBadge, HlmBadgeImports, HlmBlockquote, HlmBreadCrumbImports, HlmBreadcrumb, HlmBreadcrumbEllipsis, HlmBreadcrumbItem, HlmBreadcrumbLink, HlmBreadcrumbList, HlmBreadcrumbPage, HlmBreadcrumbSeparator, HlmButton, HlmButtonGroup, HlmButtonGroupImports, HlmButtonGroupSeparator, HlmButtonGroupText, HlmButtonImports, HlmCalendar, HlmCalendarImports, HlmCalendarMulti, HlmCalendarRange, HlmCaption, HlmCard, HlmCardAction, HlmCardContent, HlmCardDescription, HlmCardFooter, HlmCardHeader, HlmCardImports, HlmCardTitle, HlmCheckbox, HlmCheckboxImports, HlmCode, HlmCollapsible, HlmCollapsibleContent, HlmCollapsibleImports, HlmCollapsibleTrigger, HlmCommand, HlmCommandDialog, HlmCommandEmpty, HlmCommandEmptyState, HlmCommandGroup, HlmCommandGroupLabel, HlmCommandImports, HlmCommandInput, HlmCommandItem, HlmCommandList, HlmCommandSeparator, HlmCommandShortcut, HlmContextMenuImports, HlmContextMenuTrigger, HlmDatePicker, HlmDatePickerImports, HlmDatePickerMulti, HlmDateRangePicker, HlmDialog, HlmDialogClose, HlmDialogContent, HlmDialogDescription, HlmDialogFooter, HlmDialogHeader, HlmDialogImports, HlmDialogOverlay, HlmDialogPortal, HlmDialogService, HlmDialogTitle, HlmDialogTrigger, HlmDropdownMenu, HlmDropdownMenuCheckbox, HlmDropdownMenuCheckboxIndicator, HlmDropdownMenuGroup, HlmDropdownMenuImports, HlmDropdownMenuItem, HlmDropdownMenuItemSubIndicator, HlmDropdownMenuLabel, HlmDropdownMenuRadio, HlmDropdownMenuRadioIndicator, HlmDropdownMenuSeparator, HlmDropdownMenuShortcut, HlmDropdownMenuSub, HlmDropdownMenuTrigger, HlmEmpty, HlmEmptyContent, HlmEmptyDescription, HlmEmptyHeader, HlmEmptyImports, HlmEmptyMedia, HlmEmptyTitle, HlmError, HlmField, HlmFieldContent, HlmFieldDescription, HlmFieldError, HlmFieldGroup, HlmFieldImports, HlmFieldLabel, HlmFieldLegend, HlmFieldSeparator, HlmFieldSet, HlmFieldTitle, HlmFormField, HlmFormFieldImports, HlmH1, HlmH2, HlmH3, HlmH4, HlmHint, HlmHoverCard, HlmHoverCardContent, HlmHoverCardImports, HlmHoverCardPortal, HlmHoverCardTrigger, HlmIcon, HlmIconImports, HlmInput, HlmInputGroup, HlmInputGroupAddon, HlmInputGroupButton, HlmInputGroupImports, HlmInputGroupInput, HlmInputGroupText, HlmInputGroupTextarea, HlmInputImports, HlmInputOtp, HlmInputOtpFakeCaret, HlmInputOtpGroup, HlmInputOtpImports, HlmInputOtpSeparator, HlmInputOtpSlot, HlmItem, HlmItemActions, HlmItemContent, HlmItemDescription, HlmItemFooter, HlmItemGroup, HlmItemHeader, HlmItemImports, HlmItemMedia, HlmItemSeparator, HlmItemTitle, HlmKbd, HlmKbdGroup, HlmKbdImports, HlmLabel, HlmLabelImports, HlmLarge, HlmLead, HlmMenubar, HlmMenubarImports, HlmMenubarTrigger, HlmMuted, HlmNativeSelect, HlmNativeSelectImports, HlmNativeSelectOptGroup, HlmNativeSelectOption, HlmNavigationMenu, HlmNavigationMenuContent, HlmNavigationMenuImports, HlmNavigationMenuItem, HlmNavigationMenuLink, HlmNavigationMenuList, HlmNavigationMenuPortal, HlmNavigationMenuTrigger, HlmNumberedPagination, HlmNumberedPaginationQueryParams, HlmP, HlmPagination, HlmPaginationContent, HlmPaginationEllipsis, HlmPaginationImports, HlmPaginationItem, HlmPaginationLink, HlmPaginationNext, HlmPaginationPrevious, HlmPopover, HlmPopoverContent, HlmPopoverImports, HlmPopoverPortal, HlmPopoverTrigger, HlmProgress, HlmProgressImports, HlmProgressIndicator, HlmRadio, HlmRadioGroup, HlmRadioGroupImports, HlmRadioIndicator, HlmResizableGroup, HlmResizableHandle, HlmResizableImports, HlmResizablePanel, HlmScrollArea, HlmScrollAreaImports, HlmSelect, HlmSelectContent, HlmSelectGroup, HlmSelectImports, HlmSelectLabel, HlmSelectOption, HlmSelectScrollDown, HlmSelectScrollUp, HlmSelectSeparator, HlmSelectTrigger, HlmSelectValue, HlmSeparator, HlmSeparatorImports, HlmSheet, HlmSheetClose, HlmSheetContent, HlmSheetDescription, HlmSheetFooter, HlmSheetHeader, HlmSheetImports, HlmSheetOverlay, HlmSheetPortal, HlmSheetTitle, HlmSheetTrigger, HlmSidebar, HlmSidebarContent, HlmSidebarFooter, HlmSidebarGroup, HlmSidebarGroupAction, HlmSidebarGroupContent, HlmSidebarGroupLabel, HlmSidebarHeader, HlmSidebarImports, HlmSidebarInput, HlmSidebarInset, HlmSidebarMenu, HlmSidebarMenuAction, HlmSidebarMenuBadge, HlmSidebarMenuButton, HlmSidebarMenuItem, HlmSidebarMenuSkeleton, HlmSidebarMenuSub, HlmSidebarMenuSubButton, HlmSidebarMenuSubItem, HlmSidebarRail, HlmSidebarSeparator, HlmSidebarService, HlmSidebarTrigger, HlmSidebarWrapper, HlmSkeleton, HlmSkeletonImports, HlmSlider, HlmSliderImports, HlmSmall, HlmSpinner, HlmSpinnerImports, HlmSwitch, HlmSwitchImports, HlmSwitchThumb, HlmTBody, HlmTFoot, HlmTHead, HlmTable, HlmTableConfigToken, HlmTableContainer, HlmTableImports, HlmTableVariantDefault, HlmTabs, HlmTabsContent, HlmTabsContentLazy, HlmTabsImports, HlmTabsList, HlmTabsPaginatedList, HlmTabsTrigger, HlmTd, HlmTextarea, HlmTextareaImports, HlmTh, HlmToaster, HlmToasterImports, HlmToggle, HlmToggleGroup, HlmToggleGroupImports, HlmToggleGroupItem, HlmToggleGroupToken, HlmToggleImports, HlmTooltip, HlmTooltipImports, HlmTr, HlmTypographyImports, HlmUl, buttonGroupVariants, buttonVariants, classes, createPageArray, hlm, hlmBlockquote, hlmCode, hlmDialogOverlayClass, hlmH1, hlmH2, hlmH3, hlmH4, hlmLarge, hlmLead, hlmMuted, hlmP, hlmSeparatorClass, hlmSmall, hlmUl, injectBrnButtonConfig, injectHlmContextMenuConfig, injectHlmDatePickerConfig, injectHlmDatePickerMultiConfig, injectHlmDateRangePickerConfig, injectHlmDropdownMenuConfig, injectHlmIconConfig, injectHlmItemConfig, injectHlmItemMediaConfig, injectHlmMenubarConfig, injectHlmSidebarConfig, injectHlmTableConfig, injectHlmToggleGroup, inputVariants, listVariants, outOfBoundCorrection, provideBrnButtonConfig, provideHlmContextMenuConfig, provideHlmDatePickerConfig, provideHlmDatePickerMultiConfig, provideHlmDateRangePickerConfig, provideHlmDropdownMenuConfig, provideHlmIconConfig, provideHlmItemConfig, provideHlmItemMediaConfig, provideHlmMenubarConfig, provideHlmSidebarConfig, provideHlmTableConfig, provideHlmToggleGroup, selectTriggerVariants, sheetVariants, textareaVariants, toggleVariants, tooltipPositionVariants };
+export type { AlertVariants, BadgeVariants, BrnButtonConfig, ButtonVariants, EmptyMediaVariants, FieldVariants, HlmContextMenuConfig, HlmDatePickerConfig, HlmDatePickerMultiConfig, HlmDateRangePickerConfig, HlmDialogOptions, HlmDropdownMenuConfig, HlmIconConfig, HlmItemConfig, HlmItemMediaConfig, HlmMenubarConfig, HlmSidebarConfig, HlmTableVariant, IconSize, ItemMediaVariants, ItemVariants, SidebarVariant, ToggleVariants };