@surfnet/curve-angular 0.2.0

package/dist/types/surfnet-curve-angular.d.ts

@@ -0,0 +1,1017 @@
+import * as i0 from '@angular/core';
+import { ValueProvider, OnDestroy, Signal, ElementRef, Injector } from '@angular/core';
+import * as i1 from '@spartan-ng/brain/avatar';
+import { BrnAvatar } from '@spartan-ng/brain/avatar';
+import { ClassValue } from 'clsx';
+import * as _angular_router from '@angular/router';
+import * as class_variance_authority_types from 'class-variance-authority/types';
+import { VariantProps } from 'class-variance-authority';
+import * as i1$1 from '@spartan-ng/brain/button';
+import { BooleanInput, NumberInput } from '@angular/cdk/coercion';
+import { ControlValueAccessor } from '@angular/forms';
+import { ChangeFn, TouchFn } from '@spartan-ng/brain/forms';
+import * as i1$2 from '@spartan-ng/brain/field';
+import { Table, ColumnDef, Row, SortingState, ColumnFiltersState, VisibilityState, PaginationState } from '@tanstack/angular-table';
+import * as i1$3 from '@angular/cdk/menu';
+import { MenuAlign, MenuSide } from '@spartan-ng/brain/core';
+import * as i1$4 from '@spartan-ng/brain/label';
+import * as i1$5 from '@spartan-ng/brain/input';
+import * as i1$6 from '@spartan-ng/brain/textarea';
+import * as i1$7 from '@spartan-ng/brain/select';
+import * as i2 from '@spartan-ng/brain/popover';
+import * as i1$8 from '@spartan-ng/brain/separator';
+import * as i1$9 from '@spartan-ng/brain/tooltip';
+
+declare class HlmAvatar extends BrnAvatar {
+    readonly size: i0.InputSignal<"sm" | "default" | "lg">;
+    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.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.BrnAvatarImage; inputs: {}; outputs: {}; }]>;
+}
+
+declare const HlmAvatarImports: readonly [typeof HlmAvatar, typeof HlmAvatarBadge, typeof HlmAvatarFallback, typeof HlmAvatarGroup, typeof HlmAvatarGroupCount, typeof HlmAvatarImage];
+
+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 {
+    /** The link to navigate to the page. */
+    readonly link: i0.InputSignal<string | readonly any[] | _angular_router.UrlTree | null | undefined>;
+    constructor();
+    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];
+/**
+ * @deprecated Use `HlmBreadcrumbImports` instead.
+ */
+declare const HlmBreadCrumbImports: readonly [typeof HlmBreadcrumb, typeof HlmBreadcrumbEllipsis, typeof HlmBreadcrumbSeparator, typeof HlmBreadcrumbItem, typeof HlmBreadcrumbLink, typeof HlmBreadcrumbPage, typeof HlmBreadcrumbList];
+
+declare const buttonVariants: (props?: ({
+    variant?: "default" | "link" | "outline" | "secondary" | "ghost" | "destructive" | null | undefined;
+    size?: "sm" | "default" | "lg" | "xs" | "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" | "link" | "outline" | "secondary" | "ghost" | "destructive" | null | undefined>;
+    readonly size: i0.InputSignal<"sm" | "default" | "lg" | "xs" | "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: {}; }]>;
+}
+
+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 class HlmCard {
+    private readonly _defaultConfig;
+    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 inputId: 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 checkedInput: i0.InputSignalWithTransform<boolean, BooleanInput>;
+    readonly checked: i0.WritableSignal<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>;
+    /** Whether to force the checkbox into an invalid state. */
+    readonly forceInvalid: i0.InputSignalWithTransform<boolean, BooleanInput>;
+    protected readonly _disabled: i0.WritableSignal<boolean>;
+    private readonly _brnCheckbox;
+    private readonly _spartanInvalid;
+    protected readonly _errorStateClass: i0.Signal<"" | "border-destructive focus-visible:border-destructive focus-visible:ring-destructive/20 dark:focus-visible:ring-destructive/40">;
+    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; }; "inputId": { "alias": "inputId"; "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; }; "checkedInput": { "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; }; "forceInvalid": { "alias": "forceInvalid"; "required": false; "isSignal": true; }; }, { "checkedChange": "checkedChange"; "indeterminate": "indeterminateChange"; }, never, never, true, [{ directive: typeof i1$2.BrnFieldControlDescribedBy; inputs: {}; outputs: {}; }]>;
+}
+
+declare const HlmCheckboxImports: readonly [typeof HlmCheckbox];
+
+/**
+ * Renders a TanStack table instance into the styled helm `table` directives. Mirrors React's
+ * `DataTableContent`: header groups, body rows (with `data-state="selected"` per selected
+ * row), and an empty-state row when there are no rows.
+ *
+ * String / primitive header and cell defs are rendered as inert escaped text by `*flexRender`
+ * (matching React's `flexRender` of a string node); component cell defs created with
+ * `flexRenderComponent()` are mounted in place. To render markup, return a
+ * `flexRenderComponent()` rather than an HTML string — raw strings are never parsed as HTML.
+ */
+declare class HlmDataTableContent<TData> {
+    /** The TanStack table instance, e.g. from `injectDataTable`. */
+    readonly table: i0.InputSignal<Table<TData>>;
+    /** The column defs — used to span the empty-state row across all columns. */
+    readonly columns: i0.InputSignal<ColumnDef<TData, unknown>[]>;
+    /** Content shown in the body when there are no rows. */
+    readonly noResultsLabel: i0.InputSignal<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmDataTableContent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HlmDataTableContent<any>, "hlm-data-table-content", never, { "table": { "alias": "table"; "required": true; "isSignal": true; }; "columns": { "alias": "columns"; "required": true; "isSignal": true; }; "noResultsLabel": { "alias": "noResultsLabel"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Selection summary plus Previous / Next paging controls. Mirrors React's
+ * `DataTablePagination`.
+ */
+declare class HlmDataTablePagination<TData> {
+    /** The TanStack table instance, e.g. from `injectDataTable`. */
+    readonly table: i0.InputSignal<Table<TData>>;
+    /** Label for the "previous page" button. */
+    readonly previousLabel: i0.InputSignal<string>;
+    /** Label for the "next page" button. */
+    readonly nextLabel: i0.InputSignal<string>;
+    /** Builds the selection-summary text from the selected and total row counts. */
+    readonly selectionLabel: i0.InputSignal<(selectedCount: number, totalCount: number) => string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmDataTablePagination<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HlmDataTablePagination<any>, "hlm-data-table-pagination", never, { "table": { "alias": "table"; "required": true; "isSignal": true; }; "previousLabel": { "alias": "previousLabel"; "required": false; "isSignal": true; }; "nextLabel": { "alias": "nextLabel"; "required": false; "isSignal": true; }; "selectionLabel": { "alias": "selectionLabel"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Layout wrapper for data-table controls (filter inputs, column toggles, actions). Mirrors
+ * React's `DataTableToolbar` — a styled flex row above the table.
+ */
+declare class HlmDataTableToolbar {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmDataTableToolbar, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmDataTableToolbar, "[hlmDataTableToolbar]", never, {}, {}, never, never, true, never>;
+}
+
+interface InjectDataTableOptions<TData> {
+    data: TData[];
+    columns: ColumnDef<TData, unknown>[];
+    /** Derive a stable row id (e.g. from a record's id) so row selection survives data changes. */
+    getRowId?: (originalRow: TData, index: number, parent?: Row<TData>) => string;
+    initialSorting?: SortingState;
+    initialColumnFilters?: ColumnFiltersState;
+    initialColumnVisibility?: VisibilityState;
+    initialPagination?: PaginationState;
+}
+/**
+ * Angular analog of React's `useDataTable`. Wraps `createAngularTable` with the core,
+ * sorted, filtered and paginated row models and manages sorting, column-filter,
+ * column-visibility, row-selection and pagination state with signals.
+ *
+ * Must be called from an injection context (a component constructor or field initializer),
+ * since `createAngularTable` injects. Pass an options factory so reactive `data` re-renders
+ * the table:
+ *
+ * ```ts
+ * readonly table = injectDataTable(() => ({ data: this.data(), columns }));
+ * ```
+ */
+declare function injectDataTable<TData>(options: () => InjectDataTableOptions<TData>): Table<TData>;
+
+declare const HlmDataTableImports: readonly [typeof HlmDataTableContent, typeof HlmDataTablePagination, typeof HlmDataTableToolbar];
+
+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$3.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$3.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$3.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],hlm-dropdown-menu-item", 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$3.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$3.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$3.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$3.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 const fieldVariants: (props?: ({
+    orientation?: "vertical" | "horizontal" | "responsive" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type FieldVariants = VariantProps<typeof fieldVariants>;
+declare class HlmField {
+    readonly orientation: i0.InputSignal<"vertical" | "horizontal" | "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, [{ directive: typeof i1$2.BrnField; inputs: { "data-invalid": "data-invalid"; "forceInvalid": "forceInvalid"; }; outputs: {}; }]>;
+}
+
+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 implements OnDestroy {
+    private static _id;
+    private readonly _a11y;
+    readonly id: i0.InputSignal<string>;
+    private _registeredId?;
+    private readonly _cleanup;
+    constructor();
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmFieldDescription, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmFieldDescription, "[hlmFieldDescription],hlm-field-description", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class HlmFieldError implements OnDestroy {
+    private static _id;
+    private readonly _field;
+    private readonly _a11y;
+    private _registeredId?;
+    private readonly _hasParentField;
+    /** The unique ID for the field error. If none is supplied, it will be auto-generated. */
+    readonly id: i0.InputSignal<string>;
+    /**
+     * The name of the specific validator error key to match (e.g. 'required').
+     * When omitted, the error is shown if any validation error is present.
+     */
+    readonly validator: i0.InputSignal<string | undefined>;
+    /** Forces the error message to be visible regardless of the control's validation state. */
+    readonly forceShow: i0.InputSignalWithTransform<boolean, BooleanInput>;
+    protected readonly _display: i0.Signal<boolean>;
+    protected readonly _hasError: i0.Signal<boolean>;
+    private readonly _cleanup;
+    constructor();
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmFieldError, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HlmFieldError, "hlm-field-error", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; "validator": { "alias": "validator"; "required": false; "isSignal": true; }; "forceShow": { "alias": "forceShow"; "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$4.BrnLabel; inputs: { "id": "id"; "for": "for"; }; 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 {
+    readonly variant: i0.InputSignal<"label" | "legend">;
+    constructor();
+    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 HlmFieldContent, typeof HlmFieldDescription, typeof HlmFieldError, typeof HlmFieldGroup, typeof HlmFieldLabel, typeof HlmFieldLegend, typeof HlmFieldSeparator, typeof HlmFieldSet, typeof HlmFieldTitle];
+
+declare class HlmInput {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmInput, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmInput, "[hlmInput]", never, {}, {}, never, never, true, [{ directive: typeof i1$5.BrnInput; inputs: { "id": "id"; "forceInvalid": "forceInvalid"; }; outputs: {}; }, { directive: typeof i1$2.BrnFieldControlDescribedBy; inputs: {}; outputs: {}; }]>;
+}
+
+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, "[hlmInputGroupAddon],hlm-input-group-addon", never, { "align": { "alias": "align"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class HlmInputGroupButton {
+    readonly size: i0.InputSignal<"sm" | "xs" | "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, "[hlmInputGroupText],hlm-input-group-text", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmTextarea {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmTextarea, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmTextarea, "[hlmTextarea]", never, {}, {}, never, never, true, [{ directive: typeof i1$6.BrnTextarea; inputs: { "id": "id"; "forceInvalid": "forceInvalid"; }; outputs: {}; }, { directive: typeof i1$2.BrnFieldControlDescribedBy; inputs: {}; outputs: {}; }]>;
+}
+
+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 const HlmLabelImports: readonly [typeof HlmLabel];
+
+declare class HlmSelect {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSelect, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmSelect, "[hlmSelect],hlm-select", never, {}, {}, never, never, true, [{ directive: typeof i1$7.BrnSelect; inputs: { "disabled": "disabled"; "value": "value"; "isItemEqualToValue": "isItemEqualToValue"; "itemToString": "itemToString"; }; outputs: { "valueChange": "valueChange"; }; }, { directive: typeof i2.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 HlmSelectContent {
+    protected readonly _computedListboxClasses: i0.Signal<string>;
+    readonly showScroll: i0.InputSignalWithTransform<boolean, BooleanInput>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSelectContent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HlmSelectContent, "hlm-select-content", never, { "showScroll": { "alias": "showScroll"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, [{ directive: typeof i1$7.BrnSelectContent; inputs: {}; outputs: {}; }]>;
+}
+
+declare class HlmSelectGroup {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSelectGroup, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmSelectGroup, "[hlmSelectGroup],hlm-select-group", never, {}, {}, never, never, true, [{ directive: typeof i1$7.BrnSelectGroup; inputs: {}; outputs: {}; }]>;
+}
+
+declare class HlmSelectItem {
+    private readonly _brnSelectItem;
+    protected readonly _active: i0.Signal<boolean>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSelectItem, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HlmSelectItem, "hlm-select-item", never, {}, {}, never, ["*"], true, [{ directive: typeof i1$7.BrnSelectItem; inputs: { "id": "id"; "disabled": "disabled"; "value": "value"; }; outputs: {}; }]>;
+}
+
+declare class HlmSelectLabel {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSelectLabel, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmSelectLabel, "[hlmSelectLabel],hlm-select-label", never, {}, {}, never, never, true, [{ directive: typeof i1$7.BrnSelectLabel; inputs: { "id": "id"; }; outputs: {}; }]>;
+}
+
+declare class HlmSelectMultiple {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSelectMultiple, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmSelectMultiple, "[hlmSelectMultiple],hlm-select-multiple", never, {}, {}, never, never, true, [{ directive: typeof i1$7.BrnSelectMultiple; inputs: { "disabled": "disabled"; "value": "value"; "isItemEqualToValue": "isItemEqualToValue"; "itemToString": "itemToString"; }; outputs: { "valueChange": "valueChange"; }; }, { directive: typeof i2.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 HlmSelectPlaceholder {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSelectPlaceholder, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmSelectPlaceholder, "[hlmSelectPlaceholder],hlm-select-placeholder", never, {}, {}, never, never, true, [{ directive: typeof i1$7.BrnSelectPlaceholder; inputs: {}; outputs: {}; }]>;
+}
+
+declare class HlmSelectPortal {
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSelectPortal, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmSelectPortal, "[hlmSelectPortal]", never, {}, {}, never, never, true, [{ directive: typeof i2.BrnPopoverContent; inputs: { "context": "context"; "class": "class"; }; outputs: {}; }]>;
+}
+
+declare class HlmSelectScrollDown {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSelectScrollDown, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HlmSelectScrollDown, "hlm-select-scroll-down", never, {}, {}, never, never, true, [{ directive: typeof i1$7.BrnSelectScrollDown; inputs: {}; outputs: {}; }]>;
+}
+
+declare class HlmSelectScrollUp {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSelectScrollUp, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HlmSelectScrollUp, "hlm-select-scroll-up", never, {}, {}, never, never, true, [{ directive: typeof i1$7.BrnSelectScrollUp; inputs: {}; outputs: {}; }]>;
+}
+
+declare class HlmSelectSeparator {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSelectSeparator, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmSelectSeparator, "[hlmSelectSeparator],hlm-select-separator", never, {}, {}, never, never, true, [{ directive: typeof i1$7.BrnSelectSeparator; inputs: { "orientation": "orientation"; }; outputs: {}; }]>;
+}
+
+declare class HlmSelectTrigger {
+    private static _id;
+    readonly userClass: i0.InputSignal<ClassValue>;
+    protected readonly _computedClass: i0.Signal<string>;
+    readonly buttonId: i0.InputSignal<string>;
+    readonly size: i0.InputSignal<"sm" | "default">;
+    /** Whether to force the trigger into an invalid state. */
+    readonly forceInvalid: i0.InputSignalWithTransform<boolean, BooleanInput>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSelectTrigger, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HlmSelectTrigger, "hlm-select-trigger", never, { "userClass": { "alias": "class"; "required": false; "isSignal": true; }; "buttonId": { "alias": "buttonId"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "forceInvalid": { "alias": "forceInvalid"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class HlmSelectValue {
+    private readonly _brnSelectValue;
+    protected readonly _hidden: i0.Signal<boolean>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSelectValue, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmSelectValue, "[hlmSelectValue],hlm-select-value", never, {}, {}, never, never, true, [{ directive: typeof i1$7.BrnSelectValue; inputs: { "placeholder": "placeholder"; }; outputs: {}; }]>;
+}
+
+declare class HlmSelectValueTemplate {
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSelectValueTemplate, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmSelectValueTemplate, "[hlmSelectValueTemplate]", never, {}, {}, never, never, true, [{ directive: typeof i1$7.BrnSelectValueTemplate; inputs: {}; outputs: {}; }]>;
+}
+
+declare class HlmSelectValues {
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSelectValues, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmSelectValues, "[hlmSelectValues]", never, {}, {}, never, never, true, [{ directive: typeof i1$7.BrnSelectValues; inputs: {}; outputs: {}; }]>;
+}
+
+declare class HlmSelectValuesContent {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSelectValuesContent, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmSelectValuesContent, "[hlmSelectValuesContent],hlm-select-values-content", never, {}, {}, never, never, true, never>;
+}
+
+declare const HlmSelectImports: readonly [typeof HlmSelect, typeof HlmSelectContent, typeof HlmSelectGroup, typeof HlmSelectItem, typeof HlmSelectLabel, typeof HlmSelectMultiple, typeof HlmSelectPlaceholder, typeof HlmSelectPortal, typeof HlmSelectScrollDown, typeof HlmSelectScrollUp, typeof HlmSelectSeparator, typeof HlmSelectTrigger, typeof HlmSelectValue, typeof HlmSelectValues, typeof HlmSelectValuesContent, typeof HlmSelectValueTemplate];
+
+declare const hlmSeparatorClass = "inline-flex shrink-0 bg-border data-horizontal:h-px data-horizontal:w-full data-vertical:w-px data-vertical:self-stretch";
+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$8.BrnSeparator; inputs: { "orientation": "orientation"; "decorative": "decorative"; }; outputs: {}; }]>;
+}
+
+declare const HlmSeparatorImports: readonly [typeof HlmSeparator];
+
+type SidebarVariant = 'sidebar' | 'floating' | 'inset';
+declare class HlmSidebarService {
+    private readonly _platformId;
+    private readonly _request;
+    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;
+    private restoreStateFromCookie;
+    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 {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSidebarInput, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmSidebarInput, "input[hlmSidebarInput]", never, {}, {}, never, never, true, [{ directive: typeof HlmInput; inputs: {}; outputs: {}; }]>;
+}
+
+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" | "default" | "lg">;
+    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$9.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 _sidebarService;
+    readonly srOnlyText: i0.InputSignal<string>;
+    protected _onClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSidebarTrigger, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HlmSidebarTrigger, "button[hlmSidebarTrigger]", never, { "srOnlyText": { "alias": "srOnlyText"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof HlmButton; inputs: { "variant": "variant"; "size": "size"; }; 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 HlmTableContainer {
+    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.
+ */
+declare class HlmTable {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmTable, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmTable, "table[hlmTable]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Directive to apply Shadcn-like styling to a <thead> element
+ * within an HlmTable context.
+ */
+declare class HlmTHead {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmTHead, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmTHead, "thead[hlmTHead],thead[hlmTableHeader]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Directive to apply Shadcn-like styling to a <tbody> element
+ * within an HlmTable context.
+ */
+declare class HlmTBody {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmTBody, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmTBody, "tbody[hlmTBody],tbody[hlmTableBody]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Directive to apply Shadcn-like styling to a <tfoot> element
+ * within an HlmTable context.
+ */
+declare class HlmTFoot {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmTFoot, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmTFoot, "tfoot[hlmTFoot],tfoot[hlmTableFooter]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Directive to apply Shadcn-like styling to a <tr> element
+ * within an HlmTable context.
+ */
+declare class HlmTr {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmTr, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmTr, "tr[hlmTr],tr[hlmTableRow]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Directive to apply Shadcn-like styling to a <th> element
+ * within an HlmTable context.
+ */
+declare class HlmTh {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmTh, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmTh, "th[hlmTh],th[hlmTableHead]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Directive to apply Shadcn-like styling to a <td> element
+ * within an HlmTable context.
+ */
+declare class HlmTd {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmTd, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmTd, "td[hlmTd],td[hlmTableCell]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Directive to apply Shadcn-like styling to a <caption> element
+ * within an HlmTable context.
+ */
+declare class HlmCaption {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmCaption, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmCaption, "caption[hlmCaption],caption[hlmTableCaption]", 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 const HlmTextareaImports: readonly [typeof HlmTextarea];
+
+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 { HLM_CHECKBOX_VALUE_ACCESSOR, HlmAvatar, HlmAvatarBadge, HlmAvatarFallback, HlmAvatarGroup, HlmAvatarGroupCount, HlmAvatarImage, HlmAvatarImports, HlmBreadCrumbImports, HlmBreadcrumb, HlmBreadcrumbEllipsis, HlmBreadcrumbImports, HlmBreadcrumbItem, HlmBreadcrumbLink, HlmBreadcrumbList, HlmBreadcrumbPage, HlmBreadcrumbSeparator, HlmButton, HlmButtonImports, HlmCaption, HlmCard, HlmCardAction, HlmCardContent, HlmCardDescription, HlmCardFooter, HlmCardHeader, HlmCardImports, HlmCardTitle, HlmCheckbox, HlmCheckboxImports, HlmDataTableContent, HlmDataTableImports, HlmDataTablePagination, HlmDataTableToolbar, HlmDropdownMenu, HlmDropdownMenuCheckbox, HlmDropdownMenuCheckboxIndicator, HlmDropdownMenuGroup, HlmDropdownMenuImports, HlmDropdownMenuItem, HlmDropdownMenuItemSubIndicator, HlmDropdownMenuLabel, HlmDropdownMenuRadio, HlmDropdownMenuRadioIndicator, HlmDropdownMenuSeparator, HlmDropdownMenuShortcut, HlmDropdownMenuSub, HlmDropdownMenuTrigger, HlmField, HlmFieldContent, HlmFieldDescription, HlmFieldError, HlmFieldGroup, HlmFieldImports, HlmFieldLabel, HlmFieldLegend, HlmFieldSeparator, HlmFieldSet, HlmFieldTitle, HlmInput, HlmInputGroup, HlmInputGroupAddon, HlmInputGroupButton, HlmInputGroupImports, HlmInputGroupInput, HlmInputGroupText, HlmInputGroupTextarea, HlmInputImports, HlmLabel, HlmLabelImports, HlmSelect, HlmSelectContent, HlmSelectGroup, HlmSelectImports, HlmSelectItem, HlmSelectLabel, HlmSelectMultiple, HlmSelectPlaceholder, HlmSelectPortal, HlmSelectScrollDown, HlmSelectScrollUp, HlmSelectSeparator, HlmSelectTrigger, HlmSelectValue, HlmSelectValueTemplate, HlmSelectValues, HlmSelectValuesContent, HlmSeparator, HlmSeparatorImports, 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, HlmTBody, HlmTFoot, HlmTHead, HlmTable, HlmTableContainer, HlmTableImports, HlmTd, HlmTextarea, HlmTextareaImports, HlmTh, HlmTr, buttonVariants, classes, hlm, hlmSeparatorClass, injectBrnButtonConfig, injectDataTable, injectHlmDropdownMenuConfig, injectHlmSidebarConfig, provideBrnButtonConfig, provideHlmDropdownMenuConfig, provideHlmSidebarConfig };
+export type { BrnButtonConfig, ButtonVariants, FieldVariants, HlmDropdownMenuConfig, HlmSidebarConfig, InjectDataTableOptions, SidebarVariant };