@basis-ng/primitives 0.0.1-alpha.15 → 0.0.1-alpha.150

package/types/basis-ng-primitives.d.ts

@@ -0,0 +1,1847 @@
+import * as _angular_core from '@angular/core';
+import { ElementRef, OnInit, OnDestroy, TemplateRef, AfterViewInit, AfterContentInit, PipeTransform } from '@angular/core';
+import { FormValueControl } from '@angular/forms/signals';
+import { ActiveDescendantKeyManager } from '@angular/cdk/a11y';
+import * as i1 from '@angular/cdk/listbox';
+import { CdkOption, CdkListbox, ListboxValueChangeEvent } from '@angular/cdk/listbox';
+import { BreakpointObserver } from '@angular/cdk/layout';
+import { CdkDialogContainer, DialogRef } from '@angular/cdk/dialog';
+import * as i1$1 from '@angular/cdk/menu';
+import { CdkMenuTrigger } from '@angular/cdk/menu';
+import * as i1$2 from '@angular/cdk/overlay';
+import { CdkOverlayOrigin, CdkConnectedOverlay, ScrollStrategyOptions, ConnectedPosition, ConnectionPositionPair, Overlay as Overlay$1 } from '@angular/cdk/overlay';
+import * as i1$3 from '@angular/aria/tabs';
+import * as i1$4 from '@angular/cdk/drag-drop';
+import { CdkDragDrop, CdkDrag } from '@angular/cdk/drag-drop';
+
+/**
+ * Displays an alert with optional title, icon and a dismiss button.
+ */
+declare class Alert {
+    /**
+     * Alert title text. Rendered when provided.
+     */
+    readonly title: _angular_core.InputSignal<string | null>;
+    /**
+     * Icon name to display to the left of the content.
+     */
+    readonly icon: _angular_core.InputSignal<string | null>;
+    /**
+     * Whether the alert shows a dismiss button.
+     */
+    readonly dismissible: _angular_core.InputSignal<boolean>;
+    /**
+     * Emitted when the alert is dismissed.
+     */
+    readonly dismissed: _angular_core.OutputEmitterRef<void>;
+    /**
+     * Emit the dismissed event.
+     */
+    dismiss(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Alert, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Alert, "b-alert", never, { "title": { "alias": "title"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "dismissible": { "alias": "dismissible"; "required": false; "isSignal": true; }; }, { "dismissed": "dismissed"; }, never, ["*"], true, never>;
+}
+
+/**
+ * A minimal badge component that projects inline content inside a span.
+ */
+declare class Badge {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Badge, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Badge, "span[b-badge]", never, {}, {}, never, ["*"], true, never>;
+}
+
+/**
+ * Groups buttons and optionally adds spacing between them.
+ */
+declare class ButtonGroup {
+    /**
+     * Whether to add spacing between grouped buttons.
+     */
+    readonly spaced: _angular_core.InputSignal<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ButtonGroup, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ButtonGroup, "b-button-group", never, { "spaced": { "alias": "spaced"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+/**
+ * A lightweight attribute button component that projects content into a native button.
+ */
+declare class Button {
+    /**
+     * Reference to the host button element.
+     */
+    el: ElementRef<any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Button, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Button, "button[b-button]", never, {}, {}, never, ["*"], true, never>;
+}
+
+/**
+ * A minimal calendar component that displays a month grid and emits selected dates.
+ * Selector and CSS follow the project's conventions.
+ */
+declare class Calendar implements FormValueControl<Date | null> {
+    readonly today: Date;
+    readonly month: _angular_core.WritableSignal<number>;
+    readonly year: _angular_core.WritableSignal<number>;
+    readonly value: _angular_core.ModelSignal<Date | null>;
+    readonly valueChange: _angular_core.OutputEmitterRef<Date | null>;
+    readonly dateSelected: _angular_core.OutputEmitterRef<Date>;
+    readonly weekdays: _angular_core.InputSignal<string[]>;
+    readonly weekStart: _angular_core.InputSignal<number>;
+    /** Weekday labels rotated according to `weekStart` */
+    visibleWeekdays: _angular_core.Signal<string[]>;
+    readonly viewMode: _angular_core.WritableSignal<"day" | "month" | "year">;
+    monthLabel: _angular_core.Signal<string>;
+    /** Input to override month labels (12 entries). Defaults to English short names. */
+    readonly months: _angular_core.InputSignal<string[]>;
+    /** Final months array used in template: prefers `months` input when provided */
+    monthsLabels: _angular_core.Signal<string[]>;
+    private readonly _cellWidgets;
+    readonly dayRows: _angular_core.Signal<{
+        date: Date;
+        outside: boolean;
+    }[][]>;
+    readonly dayRowIndexes: _angular_core.Signal<number[]>;
+    readonly monthRows: _angular_core.Signal<string[][]>;
+    readonly monthRowIndexes: _angular_core.Signal<number[]>;
+    readonly yearRows: _angular_core.Signal<number[][]>;
+    readonly yearRowIndexes: _angular_core.Signal<number[]>;
+    /** Grid of years for year selection (12 years centered around current year) */
+    yearsGrid: _angular_core.Signal<number[]>;
+    calendarGrid: _angular_core.Signal<{
+        date: Date;
+        outside: boolean;
+    }[]>;
+    prevMonth(): void;
+    nextMonth(): void;
+    onHeaderClick(): void;
+    selectMonth(m: number): void;
+    selectYear(y: number): void;
+    selectDate(d: Date): void;
+    onKeyDown(event: KeyboardEvent): void;
+    /** Centralized focus logic for cell widgets */
+    private focusCell;
+    /** Focus the currently selected date cell after navigation/selection changes */
+    private focusSelectedAfterNavigation;
+    isSelected(date: Date): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Calendar, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Calendar, "b-calendar", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "weekdays": { "alias": "weekdays"; "required": false; "isSignal": true; }; "weekStart": { "alias": "weekStart"; "required": false; "isSignal": true; }; "months": { "alias": "months"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "valueChange": "valueChange"; "dateSelected": "dateSelected"; }, never, never, true, never>;
+}
+
+/**
+ * A simple card container for grouping related content.
+ */
+declare class Card {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Card, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Card, "b-card", never, {}, {}, never, ["*"], true, never>;
+}
+
+/**
+ * Container for the main content of a card.
+ */
+declare class CardContent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CardContent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CardContent, "b-card-content", never, {}, {}, never, ["*"], true, never>;
+}
+
+/**
+ * Small descriptive text for a card, typically shown below the title.
+ */
+declare class CardDescription {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CardDescription, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CardDescription, "b-card-description", never, {}, {}, never, ["*"], true, never>;
+}
+
+/**
+ * Footer area for a card, commonly used for actions or meta content.
+ */
+declare class CardFooter {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CardFooter, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CardFooter, "b-card-footer", never, {}, {}, never, ["*"], true, never>;
+}
+
+/**
+ * Header section for a card, usually contains the title or leading content.
+ */
+declare class CardHeader {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CardHeader, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CardHeader, "b-card-header", never, {}, {}, never, ["*"], true, never>;
+}
+
+/**
+ * Title element for a card.
+ */
+declare class CardTitle {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CardTitle, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CardTitle, "b-card-title", never, {}, {}, never, ["*"], true, never>;
+}
+
+/**
+ * Custom checkbox control synced with the host input element.
+ */
+declare class Checkbox implements FormValueControl<boolean> {
+    /**
+     * Current value of the checkbox.
+     */
+    readonly value: _angular_core.ModelSignal<boolean>;
+    /**
+     * Emitted when the value changes.
+     */
+    readonly valueChange: _angular_core.OutputEmitterRef<boolean>;
+    /**
+     * Visual size of the checkbox.
+     */
+    readonly size: _angular_core.ModelSignal<"sm" | "md" | "lg">;
+    /**
+     * Whether the checkbox is disabled. Automatically bound by Signal Forms.
+     */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Toggle the checkbox when the user clicks on it.
+     */
+    onToggle(): void;
+    /**
+     * Prevent the page from scrolling when pressing the space key.
+     */
+    suppressSpace(event: Event): void;
+    /**
+     * Update the current value (FormValueControl API).
+     * @param value - New boolean value to apply.
+     */
+    setValue(value: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Checkbox, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Checkbox, "button[b-checkbox]", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "valueChange": "valueChange"; "size": "sizeChange"; }, never, never, true, never>;
+}
+
+/**
+ * Presents a list of selectable command options and manages keyboard navigation.
+ */
+declare class CommandOptionsComponent implements OnInit {
+    /**
+     * Query list of option children.
+     */
+    readonly options: _angular_core.Signal<readonly CdkOption<any>[]>;
+    /**
+     * Keyboard manager for option navigation.
+     */
+    readonly listKeyManager: _angular_core.Signal<ActiveDescendantKeyManager<CdkOption<any>>>;
+    /**
+     * Currently selected values.
+     */
+    readonly value: _angular_core.WritableSignal<string[]>;
+    /**
+     * Value of the currently highlighted option.
+     */
+    readonly highlightedOption: _angular_core.WritableSignal<string>;
+    /**
+     * Message shown when there are no options.
+     */
+    readonly noOptionsMessage: _angular_core.InputSignal<string>;
+    cdkListbox: CdkListbox<any>;
+    /**
+     * Emitted when the options list should be closed (single-select or explicit clear).
+     */
+    closeEmitter: _angular_core.OutputEmitterRef<void>;
+    /**
+     * Whether multiple options can be selected.
+     */
+    readonly multiple: _angular_core.InputSignal<boolean>;
+    ngOnInit(): void;
+    constructor();
+    /**
+     * Select the provided value(s) or the currently active option.
+     * @param value - Optional array of values to select.
+     */
+    selectOption(value?: string[]): void;
+    /**
+     * Move highlight to the next option.
+     */
+    nextOption(): void;
+    /**
+     * Move highlight to the previous option.
+     */
+    previousOption(): void;
+    /**
+     * Update DOM classes for the highlighted option.
+     */
+    updateHighlightedOption(): void;
+    /**
+     * Handle external value changes from the cdk listbox.
+     * @param value - New array of selected values.
+     */
+    handleValueChange(event: ListboxValueChangeEvent<unknown>): void;
+    /**
+     * Called on Enter key; closes the list for single-select.
+     */
+    onEnter(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CommandOptionsComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CommandOptionsComponent, "ul[b-command-options]", never, { "noOptionsMessage": { "alias": "noOptionsMessage"; "required": false; "isSignal": true; }; "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; }, { "closeEmitter": "closeEmitter"; }, ["options"], ["*"], true, [{ directive: typeof i1.CdkListbox; inputs: { "cdkListboxValue": "cdkListboxValue"; "cdkListboxMultiple": "multiple"; }; outputs: { "cdkListboxValueChange": "cdkListboxValueChange"; }; }]>;
+}
+
+/**
+ * Input with integrated command options and keyboard handling.
+ */
+declare class CommandComponent implements OnDestroy {
+    /**
+     * Child CommandOptionsComponent instance.
+     */
+    readonly commandOptions: _angular_core.Signal<CommandOptionsComponent | undefined>;
+    /**
+     * Maximum height for the command list.
+     */
+    readonly maxHeight: _angular_core.InputSignal<string>;
+    /**
+     * Computed selected value from the command options.
+     */
+    readonly value: _angular_core.Signal<string[] | undefined>;
+    /**
+     * Computed available options from the child component.
+     */
+    readonly options: _angular_core.Signal<readonly i1.CdkOption<any>[] | undefined>;
+    /**
+     * Breakpoint observer for responsive behavior.
+     */
+    breakpointObserver: BreakpointObserver;
+    /**
+     * Signal that indicates whether the viewport is desktop-sized.
+     */
+    readonly isDesktop: _angular_core.WritableSignal<boolean>;
+    /**
+     * Element reference to the host component.
+     */
+    el: ElementRef<any>;
+    /**
+     * Emitted when the input value changes.
+     */
+    readonly inputValueChange: _angular_core.OutputEmitterRef<string>;
+    /**
+     * Debounce delay in milliseconds for input events.
+     */
+    readonly debounce: _angular_core.InputSignal<number>;
+    /**
+     * Utility functions for common tasks.
+     */
+    private utils;
+    /**
+     * Key for debouncing input events.
+     */
+    private readonly debounceKey;
+    /**
+     * Handle native input events and emit debounced value.
+     * @param event - Native input event.
+     */
+    onInput(event: Event): void;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CommandComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CommandComponent, "b-command", never, { "maxHeight": { "alias": "maxHeight"; "required": false; "isSignal": true; }; "debounce": { "alias": "debounce"; "required": false; "isSignal": true; }; }, { "inputValueChange": "inputValueChange"; }, ["commandOptions"], ["*"], true, never>;
+}
+
+/**
+ * Represents the template and configuration registered for a dialog instance.
+ */
+interface DialogData {
+    /** Template reference rendered inside the dialog. */
+    template: TemplateRef<unknown>;
+    /** Configuration applied when opening the dialog. */
+    config: DialogConfig;
+}
+/**
+ * Configuration options that control dialog behavior and interaction.
+ */
+interface DialogConfig {
+    /** Whether a backdrop is displayed behind the dialog. */
+    hasBackdrop: boolean;
+    /** Whether focus is restored to the previously focused element after close. */
+    restoreFocus: boolean;
+    /** Delay in milliseconds before the dialog finishes closing. */
+    closeDelay: number;
+    /** Whether clicking the backdrop should request dialog closure. */
+    closeOnBackdropClick: boolean;
+    /** Whether pressing the Escape key should request dialog closure. */
+    closeOnEscapeKey: boolean;
+}
+/**
+ * Provides registration and lifecycle control for application dialogs.
+ */
+declare class DialogManager {
+    /** Angular CDK dialog service used to manage overlay instances. */
+    private readonly dialog;
+    /** Utility service used for debounced close behavior. */
+    private readonly utils;
+    /** Registry mapping dialog identifiers to their data. */
+    private readonly dialogs;
+    /**
+     * Registers a dialog definition under a unique identifier, overwriting any existing entry.
+     *
+     * @param id - Unique identifier for the dialog.
+     * @param data - Template and configuration to register.
+     */
+    registerDialog(id: string, data: DialogData): void;
+    /**
+     * Removes a previously registered dialog definition.
+     *
+     * @param id - Identifier of the dialog to remove.
+     */
+    removeDialog(id: string): void;
+    /**
+     * Opens a dialog using its registered template and configuration.
+     *
+     * @param id - Identifier of the dialog to open.
+     * @throws Error - When no dialog is registered with the provided identifier.
+     */
+    openDialog(id: string): void;
+    /**
+     * Closes a dialog by identifier applying any configured close delay.
+     *
+     * @param id - Identifier of the dialog to close.
+     */
+    closeDialog(id: string): void;
+    /**
+     * Closes all currently open dialogs immediately.
+     */
+    closeAllDialogs(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DialogManager, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<DialogManager>;
+}
+
+/**
+ * Internal dialog container that wires backdrop and escape-key behavior.
+ */
+declare class DialogContent extends CdkDialogContainer implements OnInit {
+    dialogRef: DialogRef<any, any>;
+    dialogManager: DialogManager;
+    /**
+     * Signal used to animate or flag leaving state.
+     */
+    readonly leaving: _angular_core.WritableSignal<boolean>;
+    constructor();
+    ngOnInit(): void;
+    /**
+     * Attach backdrop and keyboard handlers based on dialog config.
+     */
+    handleDialogEvents(): void;
+    /**
+     * Close dialog on backdrop click when configured.
+     * @param data - Dialog configuration.
+     */
+    handleBackdropClose(data: DialogConfig): void;
+    /**
+     * Close dialog on Escape key when configured.
+     * @param data - Dialog configuration.
+     */
+    handleEscapeKeyClose(data: DialogConfig): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DialogContent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DialogContent, "b-dialog-content", never, {}, {}, never, never, true, never>;
+}
+
+type Direction = 'top' | 'bottom' | 'left' | 'right';
+
+/**
+ * A draggable floating drawer that can slide from any side.
+ */
+declare class Drawer implements OnDestroy {
+    /**
+     * Model indicating whether the drawer is open.
+     */
+    readonly isOpen: _angular_core.ModelSignal<boolean>;
+    /**
+     * Side of the viewport the drawer appears from.
+     */
+    readonly side: _angular_core.InputSignal<Direction>;
+    /**
+     * Whether the drawer can be dragged closed.
+     */
+    readonly draggable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Whether clicking outside closes the drawer.
+     * When false, a full-viewport blocking overlay is mounted at body level
+     * so outside clicks (and pointer events) cannot reach other elements.
+     */
+    readonly closable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Emitted when the sheet is closed.
+     */
+    closeSheet: _angular_core.OutputEmitterRef<void>;
+    /**
+     * Signal used to animate or flag dragging state.
+     */
+    readonly isDragging: _angular_core.WritableSignal<boolean>;
+    /**
+     * Starting pointer coordinate for the active drag axis.
+     */
+    readonly startOffset: _angular_core.WritableSignal<number>;
+    /**
+     * Current close progress of the drawer, from 0 (open) to 100 (closed).
+     */
+    private readonly dragProgress;
+    /**
+     * Drag threshold (percentage) to trigger close on release.
+     */
+    readonly closeThreshold: _angular_core.InputSignal<number>;
+    /**
+     * Computed CSS transform for the drawer based on drag/open state.
+     */
+    readonly transform: _angular_core.Signal<string>;
+    /**
+     * Current progress to use for the rendered transform.
+     */
+    readonly currentProgress: _angular_core.Signal<number>;
+    /**
+     * Element reference to the host component.
+     */
+    private readonly el;
+    /**
+     * Body-level blocking overlay used when closable=false to prevent
+     * pointer events from reaching elements behind the open drawer.
+     */
+    private blockingOverlay;
+    constructor();
+    ngOnDestroy(): void;
+    /**
+     * Close the drawer when clicking outside of it.
+     * The stopPropagation in the drawer-content prevents clicks inside from closing it.
+     * @param event - Click event.
+     */
+    closeOnOutsideClick(event: Event): void;
+    /**
+     * Begin tracking pointer movement for drag-to-dismiss.
+     * @param event - Pointer down event.
+     */
+    startDrag(event: PointerEvent): void;
+    /**
+     * Update drawer position during drag.
+     * @param event - Current pointer event.
+     */
+    updateDrag(event: PointerEvent): void;
+    /**
+     * Snap the drawer to open or closed based on threshold.
+     */
+    snapToOpenOrClose(): void;
+    /**
+     * Closes the drawer and emits the close event.
+     */
+    requestClose(): void;
+    /**
+     * Maps the current side to the transform axis and sign.
+     */
+    private getTransform;
+    /**
+     * Returns the pointer coordinate relevant to the active drag axis.
+     */
+    private getPointerOffset;
+    /**
+     * Indicates whether the drawer moves horizontally.
+     */
+    private isHorizontal;
+    /**
+     * Returns the positive pointer direction that closes the drawer.
+     */
+    private getCloseDirection;
+    /**
+     * Mounts a transparent full-viewport div at body level that captures all
+     * pointer events, preventing them from reaching elements behind the drawer.
+     */
+    private mountBlockingOverlay;
+    /**
+     * Removes the blocking overlay from the DOM if present.
+     */
+    private removeBlockingOverlay;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Drawer, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Drawer, "b-drawer", never, { "isOpen": { "alias": "isOpen"; "required": false; "isSignal": true; }; "side": { "alias": "side"; "required": false; "isSignal": true; }; "draggable": { "alias": "draggable"; "required": false; "isSignal": true; }; "closable": { "alias": "closable"; "required": false; "isSignal": true; }; "closeThreshold": { "alias": "closeThreshold"; "required": false; "isSignal": true; }; }, { "isOpen": "isOpenChange"; "closeSheet": "closeSheet"; }, never, ["*"], true, never>;
+}
+
+/**
+ * Wrapper for grouping input-related elements.
+ */
+declare class InputGroup {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<InputGroup, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<InputGroup, "b-input-group", never, {}, {}, never, ["*"], true, never>;
+}
+
+/**
+ * A full-viewport backdrop layer that can dim background content behind projected overlays.
+ */
+declare class Backdrop {
+    /**
+     * Whether the backdrop is active.
+     */
+    readonly isOpen: _angular_core.ModelSignal<boolean>;
+    /**
+     * Optional open progress from 0 (open) to 100 (closed).
+     */
+    readonly progress: _angular_core.InputSignal<number | null>;
+    /**
+     * Maximum darkness applied when fully open.
+     */
+    readonly maxOpacity: _angular_core.InputSignal<number>;
+    /**
+     * Whether clicking the backdrop closes it automatically.
+     */
+    readonly closeOnClick: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Whether opacity changes should animate.
+     */
+    readonly animated: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Emitted whenever the backdrop surface is clicked.
+     */
+    readonly backdropClick: _angular_core.OutputEmitterRef<void>;
+    /**
+     * Current effective opacity based on explicit progress or open state.
+     */
+    readonly opacity: _angular_core.Signal<number>;
+    handleBackdropClick(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Backdrop, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Backdrop, "b-backdrop", never, { "isOpen": { "alias": "isOpen"; "required": false; "isSignal": true; }; "progress": { "alias": "progress"; "required": false; "isSignal": true; }; "maxOpacity": { "alias": "maxOpacity"; "required": false; "isSignal": true; }; "closeOnClick": { "alias": "closeOnClick"; "required": false; "isSignal": true; }; "animated": { "alias": "animated"; "required": false; "isSignal": true; }; }, { "isOpen": "isOpenChange"; "backdropClick": "backdropClick"; }, never, ["*"], true, never>;
+}
+
+/**
+ * Enhanced native input with optional numeric formatting and integrations.
+ */
+declare class Input implements AfterViewInit {
+    /**
+     * Input type.
+     */
+    readonly type: _angular_core.InputSignal<"number" | "text" | "password" | "email">;
+    /**
+     * Number of decimals when formatting decimal numbers.
+     */
+    readonly decimals: _angular_core.InputSignal<number>;
+    /**
+     * Whether number formatting uses integer or decimal logic.
+     */
+    readonly numberType: _angular_core.InputSignal<"integer" | "decimal">;
+    /**
+     * Computed signal indicating if the current type is numeric.
+     */
+    readonly isNumberType: _angular_core.Signal<boolean>;
+    /**
+     * Host input element.
+     */
+    readonly el: ElementRef<HTMLInputElement>;
+    ngAfterViewInit(): void;
+    /**
+     * Set the native input value.
+     * @param value - String value to set on the element.
+     */
+    setValue(value: string): void;
+    /**
+     * Handle native input events.
+     * @param event - Input event.
+     */
+    onInput(event: Event): void;
+    /**
+     * Handle blur events and format numeric values when applicable.
+     * @param event - Focus event.
+     */
+    onBlur(event: FocusEvent): void;
+    /**
+     * Format a numeric string according to the current numberType and decimals.
+     * @param value - Raw input string.
+     * @returns Formatted string or null when input is empty.
+     */
+    formatNumber(value: string | null): string | null;
+    /**
+     * Programmatically blur and format numeric value if applicable.
+     */
+    blur(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Input, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Input, "input[b-input]", ["bInput"], { "type": { "alias": "type"; "required": false; "isSignal": true; }; "decimals": { "alias": "decimals"; "required": false; "isSignal": true; }; "numberType": { "alias": "numberType"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Root menu container that applies CDK menu behavior.
+ */
+declare class Menu {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Menu, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Menu, "b-menu", never, {}, {}, never, ["*"], true, [{ directive: typeof i1$1.CdkMenu; inputs: {}; outputs: {}; }]>;
+}
+
+/**
+ * Menu group wrapper that applies CDK menu group behavior.
+ */
+declare class MenuGroup {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MenuGroup, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MenuGroup, "b-menu-group", never, {}, {}, never, ["*"], true, [{ directive: typeof i1$1.CdkMenuGroup; inputs: {}; outputs: {}; }]>;
+}
+
+/**
+ * Menu item wrapper that forwards behavior to the CDK menu item.
+ */
+declare class MenuItem {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MenuItem, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MenuItem, "button[b-menu-item]", never, {}, {}, never, ["*"], true, [{ directive: typeof i1$1.CdkMenuItem; inputs: { "cdkMenuItemDisabled": "disabled"; "cdkMenuitemTypeaheadLabel": "typeaheadLabel"; }; outputs: { "cdkMenuItemTriggered": "triggered"; }; }]>;
+}
+
+/**
+ * Menu item checkbox that connects to the CDK menu checkbox behavior.
+ */
+declare class MenuItemCheckbox {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MenuItemCheckbox, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MenuItemCheckbox, "button[b-menu-item-checkbox]", never, {}, {}, never, ["*"], true, [{ directive: typeof i1$1.CdkMenuItemCheckbox; inputs: { "cdkMenuItemDisabled": "disabled"; "cdkMenuitemTypeaheadLabel": "typeaheadLabel"; "cdkMenuItemChecked": "active"; }; outputs: { "cdkMenuItemTriggered": "triggered"; }; }]>;
+}
+
+/**
+ * Menu radio item that integrates CDK menu radio behavior.
+ */
+declare class MenuItemRadio {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MenuItemRadio, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MenuItemRadio, "button[b-menu-item-radio]", never, {}, {}, never, ["*"], true, [{ directive: typeof i1$1.CdkMenuItemRadio; inputs: { "cdkMenuItemDisabled": "disabled"; "cdkMenuitemTypeaheadLabel": "typeaheadLabel"; "cdkMenuItemChecked": "active"; }; outputs: { "cdkMenuItemTriggered": "triggered"; }; }]>;
+}
+
+/**
+ * Label element used inside menus to group or describe items.
+ */
+declare class MenuLabel {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MenuLabel, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MenuLabel, "b-menu-label", never, {}, {}, never, ["*"], true, never>;
+}
+
+type Position = 'top-left' | 'top-center' | 'top-right' | 'bottom-left' | 'bottom-center' | 'bottom-right' | 'left-top' | 'left-center' | 'left-bottom' | 'right-top' | 'right-center' | 'right-bottom';
+
+/**
+ * Directive to add menu trigger behavior to an element.
+ */
+declare class MenuTriggerDirective implements OnInit {
+    /**
+     * Injected CdkMenuTrigger instance to control menu behavior.
+     */
+    trigger: CdkMenuTrigger;
+    /**
+     * Position of the menu relative to the trigger element.
+     */
+    readonly menuTriggerPosition: _angular_core.InputSignal<Position | Position[]>;
+    /**
+     * Whether the trigger is for a submenu.
+     */
+    readonly submenu: _angular_core.InputSignal<boolean>;
+    ngOnInit(): void;
+    /**
+     * Sets the menu position based on the provided input.
+     * Supports both single and multiple positions.
+     * If it's a submenu, offsets are not applied.
+     */
+    setPosition(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MenuTriggerDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MenuTriggerDirective, "[menuTriggerFor]", never, { "menuTriggerPosition": { "alias": "menuTriggerPosition"; "required": false; "isSignal": true; }; "submenu": { "alias": "submenu"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1$1.CdkMenuTrigger; inputs: { "cdkMenuTriggerFor": "menuTriggerFor"; }; outputs: {}; }]>;
+}
+
+/**
+ * Component representing an individual option in a select or combobox.
+ * This component integrates with Angular CDK Option to manage the option's state and behavior.
+ */
+declare class Option {
+    /**
+     * The `ElementRef` of the option.
+     * This provides direct access to the DOM element of the option.
+     */
+    el: ElementRef<any>;
+    /**
+     * The `CdkOption` instance associated with this option.
+     * This provides methods and properties for managing the option's state, such as selection and value.
+     */
+    cdkOption: CdkOption<any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Option, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Option, "li[b-option]", never, {}, {}, never, ["*"], true, [{ directive: typeof i1.CdkOption; inputs: { "cdkOption": "value"; "cdkOptionDisabled": "disabled"; }; outputs: {}; }]>;
+}
+
+/**
+ * OTP (One-Time Password) input component that manages multiple digit inputs.
+ */
+declare class Otp implements AfterContentInit, FormValueControl<string> {
+    /**
+     * Number of digit inputs.
+     */
+    readonly length: _angular_core.Signal<number>;
+    /**
+     * Current OTP value.
+     */
+    readonly value: _angular_core.ModelSignal<string>;
+    /**
+     * Emitted when the OTP value changes.
+     */
+    readonly valueChange: _angular_core.OutputEmitterRef<string>;
+    /**
+     * Whether the OTP input has been modified.
+     */
+    dirty: _angular_core.InputSignal<boolean>;
+    /**
+     * Query list of digit input directives.
+     */
+    readonly digitInputs: _angular_core.Signal<readonly OtpDigitDirective[]>;
+    /**
+     * Internal storage for digit values.
+     */
+    private values;
+    /**
+     * Whether the OTP inputs are disabled.
+     */
+    readonly disabled: _angular_core.ModelSignal<boolean>;
+    /**
+     * Lifecycle hook invoked after content initialization.
+     */
+    ngAfterContentInit(): void;
+    /**
+     * Callback invoked when the OTP value changes.
+     */
+    private onInput;
+    /**
+     * Callback invoked on keydown events for navigation and deletion.
+     */
+    private onKeyDown;
+    /**
+     * Callback invoked on paste events to fill multiple digits.
+     */
+    private onPaste;
+    /**
+     * Focus the digit input at the specified index.
+     * @param idx - Index of the digit input to focus.
+     */
+    private focusDigit;
+    /**
+     * Emit the current OTP value to all listeners.
+     */
+    private emitValue;
+    /**
+     * Reset the OTP input values.
+     */
+    private resetValues;
+    /**
+     * Set the disabled state of the OTP inputs.
+     * @param isDisabled - Whether inputs should be disabled.
+     */
+    setDisabledState(isDisabled: boolean): void;
+    /**
+     * Update the current OTP value (FormValueControl API).
+     * @param value - New otp string to apply.
+     */
+    setValue(value: string): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Otp, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Otp, "b-otp", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "dirty": { "alias": "dirty"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "valueChange": "valueChange"; "disabled": "disabledChange"; }, ["digitInputs"], ["*"], true, never>;
+}
+declare class OtpDigitDirective {
+    /**
+     * Host input element for the OTP digit.
+     */
+    el: ElementRef<any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OtpDigitDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<OtpDigitDirective, "input[b-otp-digit]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Directive that marks an element as an overlay trigger and toggles its active state on click.
+ */
+declare class OverlayTrigger extends CdkOverlayOrigin {
+    /**
+     * Model that indicates whether the trigger is active.
+     *
+     * @defaultValue false
+     */
+    active: _angular_core.ModelSignal<boolean>;
+    /**
+     * Reference to the `ElementRef` of the host element.
+     * This is used to access the native DOM element.
+     */
+    el: ElementRef<any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OverlayTrigger, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<OverlayTrigger, "[bOverlayTrigger]", ["bOverlayTrigger"], { "active": { "alias": "active"; "required": false; "isSignal": true; }; }, { "active": "activeChange"; }, never, never, true, [{ directive: typeof i1$2.CdkOverlayOrigin; inputs: {}; outputs: {}; }]>;
+}
+
+/**
+ * Directive that wires an Angular CDK connected overlay to a trigger and exposes
+ * reactive signals for positions and scroll strategy.
+ */
+declare class Overlay {
+    /**
+     * Reference to the CDK connected overlay instance.
+     */
+    cdkConnectedOverlay: CdkConnectedOverlay;
+    /**
+     * Options for scroll handling provided by the CDK.
+     */
+    scrollStrategyOptions: ScrollStrategyOptions;
+    /**
+     * The overlay trigger object (signal) that controls the overlay origin and active state.
+     */
+    trigger: _angular_core.InputSignal<OverlayTrigger | undefined>;
+    /**
+     * Whether the overlay is open.
+     */
+    open: _angular_core.Signal<boolean>;
+    /** Preferred overlay positions in priority order.
+  
+     * @defaultValue ['bottom-center', 'top-center']
+     */
+    positions: _angular_core.InputSignal<Position[]>;
+    /** Whether clicking outside closes the overlay.
+  
+     * @defaultValue true
+     */
+    closeOnClickOutside: _angular_core.ModelSignal<boolean>;
+    /** Whether pressing Escape closes the overlay.
+  
+     * @defaultValue true
+     */
+    closeOnTypeEscape: _angular_core.ModelSignal<boolean>;
+    /**
+     * Whether to focus the trigger element when the overlay closes.
+     *
+     * @defaultValue true
+     */
+    readonly focusTriggerOnClose: _angular_core.ModelSignal<boolean>;
+    /** Scroll strategy for the overlay.
+  
+     * @defaultValue 'reposition'
+     */
+    scrollStrategy: _angular_core.ModelSignal<"close" | "reposition" | "block">;
+    /**
+     * Computed array of CDK ConnectedPosition values derived from `positions`.
+     */
+    connectedPositions: _angular_core.Signal<ConnectedPosition[]>;
+    /**
+     * Linked signal that holds the currently active ConnectionPositionPair.
+     */
+    connectedPositionPair: _angular_core.WritableSignal<ConnectionPositionPair>;
+    /**
+     * Computed overlay direction string derived from the active connection pair (e.g. 'top', 'bottom').
+     */
+    direction: _angular_core.Signal<string | undefined>;
+    /**
+     * Flag to indicate if el overlay ya fue abierto al menos una vez.
+     */
+    private hasBeenOpened;
+    constructor();
+    /**
+     * Attach or detach the overlay based on the `open` signal.
+     * Also manages focus on the trigger element when closing.
+     */
+    handleAttach(): void;
+    /**
+     * Set the active connection pair when the CDK overlay reports a position change.
+     *
+     * @param event - The position change event containing the new connection pair.
+     */
+    setPositionPair(event: {
+        connectionPair: ConnectionPositionPair;
+    }): void;
+    /**
+     * Deactivate the overlay trigger when the overlay detaches.
+     */
+    deactivateTrigger(): void;
+    /**
+     * Close the overlay if a click occurs outside and `closeOnClickOutside` is enabled.
+     */
+    closeIfClickedOutside(): void;
+    /**
+     * Close the overlay when the Escape key is pressed and `closeOnTypeEscape` is enabled.
+     *
+     * @param event - The keyboard event emitted by the overlay.
+     */
+    closeOnEscape(event: KeyboardEvent): void;
+    /**
+     * Apply the selected scroll strategy to the CDK connected overlay.
+     */
+    setScrollStrategy(): void;
+    /**
+     * Update the overlay's available positions from the computed `connectedPositions`.
+     */
+    setPositions(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Overlay, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<Overlay, "[bOverlay]", never, { "trigger": { "alias": "trigger"; "required": false; "isSignal": true; }; "positions": { "alias": "positions"; "required": false; "isSignal": true; }; "closeOnClickOutside": { "alias": "closeOnClickOutside"; "required": false; "isSignal": true; }; "closeOnTypeEscape": { "alias": "closeOnTypeEscape"; "required": false; "isSignal": true; }; "focusTriggerOnClose": { "alias": "focusTriggerOnClose"; "required": false; "isSignal": true; }; "scrollStrategy": { "alias": "scrollStrategy"; "required": false; "isSignal": true; }; }, { "closeOnClickOutside": "closeOnClickOutsideChange"; "closeOnTypeEscape": "closeOnTypeEscapeChange"; "focusTriggerOnClose": "focusTriggerOnCloseChange"; "scrollStrategy": "scrollStrategyChange"; }, never, never, true, [{ directive: typeof i1$2.CdkConnectedOverlay; inputs: { "cdkConnectedOverlayBackdropClass": "backdropClass"; "cdkConnectedOverlayDisposeOnNavigation": "disposeOnNavigation"; "cdkConnectedOverlayFlexibleDimensions": "flexibleDimensions"; "cdkConnectedOverlayGrowAfterOpen": "growAfterOpen"; "cdkConnectedOverlayHasBackdrop": "hasBackdrop"; "cdkConnectedOverlayHeight": "height"; "cdkConnectedOverlayLockPosition": "lockPosition"; "cdkConnectedOverlayMinHeight": "minHeight"; "cdkConnectedOverlayMinWidth": "minWidth"; "cdkConnectedOverlayOffsetX": "offsetX"; "cdkConnectedOverlayOffsetY": "offsetY"; "cdkConnectedOverlayOrigin": "trigger"; "cdkConnectedOverlayPanelClass": "panelClass"; "cdkConnectedOverlayPositionStrategy": "positionStrategy"; "cdkConnectedOverlayPush": "push"; "cdkConnectedOverlayTransformOriginOn": "transformOriginSelector"; "cdkConnectedOverlayViewportMargin": "viewportMargin"; "cdkConnectedOverlayWidth": "width"; }; outputs: { "attach": "attach"; "detach": "detach"; "overlayKeydown": "overlayKeydown"; "overlayOutsideClick": "overlayOutsideClick"; "positionChange": "positionChange"; }; }]>;
+}
+
+/**
+ * Popover directive that configures an overlay for displaying popover content.
+ * Popovers differ from tooltips in that they allow multi-line content and use
+ * padding-based sizing (no fixed heights) and do not expose variant classes.
+ */
+declare class Popover extends Overlay {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Popover, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<Popover, "[bPopover]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Trigger directive that emits activation events for popovers.
+ * Exposes the same `trigger` and `el` properties expected by `ConnectedOverlay`.
+ */
+declare class PopoverTrigger extends OverlayTrigger {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PopoverTrigger, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<PopoverTrigger, "[bPopoverTrigger]", ["bPopoverTrigger"], {}, {}, never, never, true, never>;
+}
+
+declare class Range implements AfterViewInit {
+    readonly value: _angular_core.ModelSignal<string>;
+    el: ElementRef<any>;
+    ngAfterViewInit(): void;
+    onInput(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Range, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Range, "input[b-range]", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, never, true, never>;
+}
+
+/**
+ * Directive to mark an element as a trigger for an overlay.
+ * Integrates with Angular CDK's `CdkOverlayOrigin` to provide
+ * a reference point for overlay positioning.
+ */
+declare class OverlayOrigin {
+    /**
+     * Reference to the `CdkOverlayOrigin` instance.
+     * Used as the origin point for overlay positioning.
+     */
+    trigger: CdkOverlayOrigin;
+    /**
+     * Reference to the `ElementRef` of the host element.
+     * This is used to access the native DOM element.
+     */
+    el: ElementRef<any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OverlayOrigin, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<OverlayOrigin, "[bOverlayOrigin]", ["bOverlayOrigin"], {}, {}, never, never, true, [{ directive: typeof i1$2.CdkOverlayOrigin; inputs: {}; outputs: {}; }]>;
+}
+
+/**
+ * Directive to manage overlay behavior and positioning.
+ * Integrates with Angular CDK's `CdkConnectedOverlay` to provide
+ * flexible overlay positioning and triggering mechanisms.
+ */
+declare class ConnectedOverlay {
+    /**
+     * Controls whether the overlay is open.
+     * @default false
+     */
+    readonly open: _angular_core.ModelSignal<boolean>;
+    /**
+     * The trigger directive that activates the overlay.
+     * This input is required.
+     */
+    readonly trigger: _angular_core.InputSignal<OverlayOrigin>;
+    /**
+     * A computed map of positions to their corresponding `ConnectedPosition` configurations.
+     */
+    readonly positionsMap: _angular_core.Signal<Record<Position, ConnectedPosition>>;
+    /**
+     * List of positions for the overlay.
+     * @default ['bottom-left']
+     */
+    readonly positions: _angular_core.InputSignal<Position[]>;
+    /**
+     * Controls whether the trigger element should be focused when the overlay is closed.
+     * @default true
+     */
+    readonly focusTriggerOnClose: _angular_core.InputSignal<boolean>;
+    /**
+     * Computed list of `ConnectedPosition` objects based on the `positions` input.
+     */
+    readonly connectedPositions: _angular_core.Signal<ConnectedPosition[]>;
+    /**
+     * Signal to track the currently active `ConnectionPositionPair`.
+     */
+    readonly connectedPositionPair: _angular_core.WritableSignal<ConnectionPositionPair>;
+    /**
+     * Injected instance of `CdkConnectedOverlay`.
+     */
+    cdkConnectedOverlay: CdkConnectedOverlay;
+    /**
+     * Injected instance of `Overlay`.
+     */
+    overlay: Overlay$1;
+    /**
+     * Computed direction of the overlay based on the active position pair.
+     */
+    readonly direction: _angular_core.Signal<string | undefined>;
+    /**
+     * Event emitter for overlay detach events.
+     */
+    detachEmitter: _angular_core.OutputEmitterRef<void>;
+    /**
+     * Event emitter for overlay attach events.
+     */
+    attachEmitter: _angular_core.OutputEmitterRef<void>;
+    /**
+     * Event emitter for overlay outside click events.
+     */
+    outsideClickEmitter: _angular_core.OutputEmitterRef<void>;
+    /**
+     * Event emitter for overlay backdrop click events.
+     */
+    backdropClickEmitter: _angular_core.OutputEmitterRef<void>;
+    /**
+     * Flag to indicate if el overlay ya fue abierto al menos una vez.
+     */
+    private hasBeenOpened;
+    /**
+     * Constructor to initialize the directive and set up reactive effects.
+     */
+    constructor();
+    /**
+     * Handles the origin of the overlay.
+     * This method sets the `cdkConnectedOverlay.origin` to the trigger element.
+     */
+    handleOrigin(): void;
+    /**
+     * Handles the connected positions for the overlay.
+     * This method updates the `cdkConnectedOverlay` positions based on the current state.
+     */
+    handleConnectedPositions(): void;
+    /**
+     * Handles the opening and closing of the overlay based on the `open` input.
+     * Determines whether to open or close the overlay and invokes the appropriate method.
+     */
+    handleOpen(): void;
+    /**
+     * Toggles the open state of the overlay.
+     * If the overlay is open, it will be closed, and vice versa.
+     */
+    toggleOverlay(): void;
+    /**
+     * Closes the overlay by setting the `open` state to false.
+     */
+    closeOverlay(): void;
+    /**
+     * Opens the overlay by setting the `open` state to true.
+     */
+    openOverlay(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ConnectedOverlay, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ConnectedOverlay, "[bConnectedOverlay]", never, { "open": { "alias": "open"; "required": false; "isSignal": true; }; "trigger": { "alias": "trigger"; "required": true; "isSignal": true; }; "positions": { "alias": "positions"; "required": false; "isSignal": true; }; "focusTriggerOnClose": { "alias": "focusTriggerOnClose"; "required": false; "isSignal": true; }; }, { "open": "openChange"; "detachEmitter": "detachEmitter"; "attachEmitter": "attachEmitter"; "outsideClickEmitter": "outsideClickEmitter"; "backdropClickEmitter": "backdropClickEmitter"; }, never, never, true, [{ directive: typeof i1$2.CdkConnectedOverlay; inputs: { "cdkConnectedOverlayWidth": "width"; "cdkConnectedOverlayMinWidth": "minWidth"; "cdkConnectedOverlayBackdropClass": "customBackdropClass"; "cdkConnectedOverlayPanelClass": "panelClass"; }; outputs: { "detach": "detach"; "attach": "attach"; "overlayOutsideClick": "outsideClick"; "backdropClick": "backdropClick"; "positionChange": "positionChange"; }; }]>;
+}
+
+/**
+ * Content container for select overlays that manages option navigation.
+ */
+declare class SelectContent implements OnInit {
+    /**
+     * Reference to the host element.
+     */
+    el: ElementRef<any>;
+    /**
+     * Injected CDK listbox instance.
+     */
+    listBox: CdkListbox<any>;
+    /**
+     * Option nodes within the select content.
+     */
+    readonly options: _angular_core.Signal<readonly CdkOption<any>[]>;
+    /**
+     * Key manager for handling option navigation.
+     */
+    readonly listKeyManager: _angular_core.Signal<ActiveDescendantKeyManager<CdkOption<any>>>;
+    /**
+     * Emits value changes from the listbox.
+     */
+    changeValueEmitter: _angular_core.OutputEmitterRef<string[]>;
+    /**
+     * Whether multiple selection is allowed.
+     */
+    readonly multiple: _angular_core.ModelSignal<boolean>;
+    /**
+     * Injected connected overlay for positioning.
+     */
+    overlay: ConnectedOverlay;
+    /**
+     * Computed overlay direction.
+     */
+    readonly direction: _angular_core.Signal<string | undefined>;
+    ngOnInit(): void;
+    /**
+     * Emits the value change event from the listbox.
+     * @param event - The value change event from the listbox.
+     */
+    emitValueChange(event: ListboxValueChangeEvent<unknown>): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SelectContent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SelectContent, "ul[b-select-content]", never, { "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; }, { "changeValueEmitter": "changeValueEmitter"; "multiple": "multipleChange"; }, ["options"], ["*"], true, [{ directive: typeof i1.CdkListbox; inputs: { "cdkListboxMultiple": "multiple"; }; outputs: { "cdkListboxValueChange": "cdkListboxValueChange"; }; }]>;
+}
+
+/**
+ * A button that acts as the trigger for a select dropdown.
+ */
+declare class SelectTrigger {
+    /**
+     * Host button element.
+     */
+    el: ElementRef<any>;
+    /**
+     * Emitted when the trigger is activated (click or key events).
+     */
+    buttonClicked: _angular_core.OutputEmitterRef<void>;
+    /**
+     * Whether the trigger is disabled.
+     */
+    readonly disabled: _angular_core.WritableSignal<boolean>;
+    /**
+     * Whether the trigger has been activated to open the select.
+     */
+    triggered: _angular_core.WritableSignal<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SelectTrigger, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SelectTrigger, "button[b-select-trigger]", never, {}, { "buttonClicked": "buttonClicked"; }, never, ["*"], true, never>;
+}
+
+/**
+ * Displays the selected value or a placeholder in a select component.
+ */
+declare class SelectValue {
+    /**
+     * Host element reference.
+     */
+    el: ElementRef<any>;
+    /**
+     * Computed selected content to display.
+     */
+    readonly content: _angular_core.WritableSignal<string>;
+    /**
+     * Placeholder shown when no selection exists.
+     */
+    readonly placeholder: _angular_core.InputSignal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SelectValue, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SelectValue, "b-select-value", never, { "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Select component that wires trigger, content and value together using signals.
+ */
+declare class Select implements OnInit, FormValueControl<string[]> {
+    /** Connected overlay instance used to show the dropdown. */
+    readonly overlay: _angular_core.Signal<ConnectedOverlay | undefined>;
+    /** Trigger that toggles the select overlay. */
+    readonly selectTrigger: _angular_core.Signal<SelectTrigger | undefined>;
+    /** Visual value display component. */
+    readonly selectValue: _angular_core.Signal<SelectValue | undefined>;
+    /** Content pane that contains options. */
+    readonly selectContent: _angular_core.Signal<SelectContent | undefined>;
+    /** Function to display the selected value(s). */
+    readonly displayWith: _angular_core.InputSignal<(value: string[]) => string>;
+    /** Whether the select is disabled. Automatically bound by Signal Forms. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Current value array for the select. */
+    readonly value: _angular_core.ModelSignal<string[]>;
+    /** Emitted when the value changes. */
+    readonly valueChange: _angular_core.OutputEmitterRef<string[]>;
+    constructor();
+    ngOnInit(): void;
+    /**
+     * Update the displayed value when value or displayWith changes.
+     */
+    private updateDisplayedValue;
+    /**
+     * Subscribe to content value changes (content is recreated each time overlay opens).
+     */
+    private handleContentValueChanges;
+    /**
+     * Wire trigger click to toggle overlay (trigger persists across lifecycle).
+     */
+    private setupTriggerEvents;
+    /**
+     * Wire overlay events (overlay persists across lifecycle).
+     */
+    private setupOverlayEvents;
+    /**
+     * Update the current value.
+     * @param value - New value array to apply.
+     */
+    setValue(value: string[]): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Select, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Select, "b-select", never, { "displayWith": { "alias": "displayWith"; "required": true; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "valueChange": "valueChange"; }, ["overlay", "selectTrigger", "selectValue", "selectContent"], ["*"], true, never>;
+}
+
+/**
+ * Directive to automatically focus the select filter input when it is initialized.
+ */
+declare class SelectFilter implements OnInit {
+    /**
+     * Element reference used to focus the filter input.
+     */
+    el: ElementRef<any>;
+    ngOnInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SelectFilter, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SelectFilter, "[bSelectFilter]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * A loading directive that overlays a skeleton shimmer on the host element while preserving size.
+ */
+declare class Skeleton {
+    /**
+     * Whether the host should display the skeleton state.
+     */
+    readonly loading: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Skeleton, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<Skeleton, "[bSkeleton]", never, { "loading": { "alias": "bSkeleton"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * A spinner component to indicate loading states.
+ */
+declare class Spinner {
+    /**
+     * Size variant of the spinner.
+     */
+    readonly size: _angular_core.InputSignal<"sm" | "md" | "lg">;
+    /**
+     * Computed pixel size for the icon.
+     */
+    readonly sizeInPx: _angular_core.Signal<16 | 20 | 28>;
+    readonly type: _angular_core.InputSignal<"circle" | "bars">;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Spinner, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Spinner, "b-spinner", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * A switch component that toggles between on and off states.
+ */
+declare class SwitchComponent implements AfterViewInit {
+    /**
+     * Current boolean state of the switch.
+     */
+    readonly value: _angular_core.WritableSignal<boolean>;
+    /**
+     * Output emitted when the switch value changes.
+     */
+    readonly valueChange: _angular_core.OutputEmitterRef<boolean>;
+    /**
+     * Host input element.
+     */
+    el: ElementRef<any>;
+    ngAfterViewInit(): void;
+    /**
+     * Toggles the switch value.
+     */
+    toggleValue(): void;
+    /**
+     * Sets the switch to a specific value.
+     * @param newValue The new boolean value to set.
+     */
+    setValue(newValue: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SwitchComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SwitchComponent, "input[b-switch]", never, {}, { "valueChange": "valueChange"; }, never, never, true, never>;
+}
+
+/**
+ * A single tab within a tabs list.
+ */
+declare class Tab implements OnDestroy {
+    /**
+     * Parent tabs container.
+     */
+    private tabsContainer;
+    /**
+     * Host element reference.
+     */
+    readonly el: ElementRef<any>;
+    /**
+     * Unique value identifying this tab.
+     */
+    readonly value: _angular_core.InputSignal<string>;
+    private focusMonitor;
+    constructor();
+    ngOnDestroy(): void;
+    /**
+     * Whether this tab is currently selected.
+     */
+    readonly isSelected: _angular_core.Signal<boolean>;
+    /**
+     * Handle click events to select this tab.
+     */
+    onClick(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Tab, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Tab, "button[b-tab], [b-tab]", never, { "value": { "alias": "value"; "required": true; "isSignal": true; }; }, {}, never, ["*"], true, [{ directive: typeof i1$3.Tab; inputs: { "value": "value"; }; outputs: {}; }]>;
+}
+
+/**
+ * Tabs container that manages keyboard navigation and active tab state.
+ */
+declare class Tabs {
+    /**
+     * Current selected tab value(s).
+     */
+    readonly value: _angular_core.ModelSignal<string[]>;
+    /**
+     * Output emitted when the tab selection changes.
+     */
+    readonly valueChange: _angular_core.OutputEmitterRef<string[]>;
+    /**
+     * Query list of Tab child components.
+     */
+    readonly tabs: _angular_core.Signal<readonly Tab[]>;
+    private tabList;
+    constructor();
+    onSelectionChange(selectedValue: string | undefined): void;
+    /**
+     * Select a tab by its value.
+     */
+    selectTab(tabValue: string): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Tabs, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Tabs, "b-tabs", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "valueChange": "valueChange"; }, ["tabs"], ["*"], true, [{ directive: typeof i1$3.Tabs; inputs: {}; outputs: {}; }, { directive: typeof i1$3.TabList; inputs: { "selectionMode": "selectionMode"; "selectedTab": "selectedTab"; }; outputs: { "selectedTabChange": "selectedTabChange"; }; }]>;
+}
+
+/**
+ * Wrapper for grouping textarea-related elements vertically.
+ */
+declare class TextareaGroup {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TextareaGroup, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TextareaGroup, "b-textarea-group", never, {}, {}, never, ["*"], true, never>;
+}
+
+/**
+ * A styled textarea component.
+ */
+declare class Textarea {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Textarea, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Textarea, "textarea[b-textarea]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Tooltip directive that configures an overlay for displaying tooltip content.
+ */
+declare class Tooltip extends Overlay implements OnInit {
+    ngOnInit(): void;
+    /**
+     * Sets the closeOnTypeEscape property to false for tooltips.
+     */
+    private setCloseOnTypeEscapeToFalse;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Tooltip, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<Tooltip, "[bTooltip]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Tooltip content that is displayed within a connected overlay.
+ */
+declare class TooltipContent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TooltipContent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TooltipContent, "b-tooltip-content", never, {}, {}, never, ["*"], true, never>;
+}
+
+/**
+ * Trigger directive that emits activation events for tooltips.
+ *
+ * This directive now extends `OverlayOrigin` so it exposes the same
+ * `trigger` and `el` properties expected by `ConnectedOverlay`.
+ */
+declare class TooltipTrigger extends OverlayTrigger {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TooltipTrigger, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TooltipTrigger, "[bTooltipTrigger]", ["bTooltipTrigger"], {}, {}, never, never, true, never>;
+}
+
+/**
+ * Root container for a tree structure, enabling drag-and-drop and nested nodes.
+ */
+declare class Tree implements OnInit {
+    /**
+     * Whether nodes are draggable.
+     */
+    readonly draggable: _angular_core.InputSignal<boolean>;
+    /**
+     * Injected CDK drop list instance for this tree.
+     */
+    private readonly tree;
+    /**
+     * Nested TreeNode children.
+     */
+    private readonly nestedNodes;
+    /**
+     * Whether to close nested nodes recursively when closing a node.
+     */
+    readonly closeRecursively: _angular_core.InputSignal<boolean>;
+    /**
+     * Whether drag-and-drop is only enabled when nodes are collapsed.
+     */
+    readonly dragOnlyWhenCollapsed: _angular_core.InputSignal<boolean>;
+    /**
+     * Computed signal indicating if the tree is disabled (inverse of draggable).
+     */
+    private readonly isTreeDisabled;
+    /**
+     * Emitted when a drag-drop operation finishes.
+     */
+    readonly dropEmitter: _angular_core.OutputEmitterRef<CdkDragDrop<string[], string[], any>>;
+    constructor();
+    ngOnInit(): void;
+    /**
+     * Subscribe to nested node close events and close children recursively.
+     */
+    private setupRecursiveClose;
+    /**
+     * Close all nested nodes recursively.
+     */
+    closeNestedNodes(): void;
+    /**
+     * Disable drag for all direct children nodes.
+     */
+    disableDirectChildren(): void;
+    /**
+     * Enable drag for all direct children nodes.
+     */
+    enableDirectChildren(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Tree, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Tree, "b-tree", never, { "draggable": { "alias": "draggable"; "required": false; "isSignal": true; }; "closeRecursively": { "alias": "closeRecursively"; "required": false; "isSignal": true; }; "dragOnlyWhenCollapsed": { "alias": "dragOnlyWhenCollapsed"; "required": false; "isSignal": true; }; }, { "dropEmitter": "dropEmitter"; }, ["nestedNodes"], ["*"], true, [{ directive: typeof i1$4.CdkDropList; inputs: { "id": "id"; "cdkDropListConnectedTo": "connectedTo"; }; outputs: { "cdkDropListDropped": "cdkDropListDropped"; }; }, { directive: typeof i1$4.CdkDropListGroup; inputs: {}; outputs: {}; }]>;
+}
+
+/**
+ * Individual node within a tree structure, supporting drag-and-drop and nested trees.
+ */
+declare class TreeNode implements OnInit {
+    /**
+     * Whether this node is expanded to show nested content.
+     */
+    readonly expanded: _angular_core.ModelSignal<boolean>;
+    /**
+     * Injected CDK drag instance for this node.
+     */
+    protected readonly node: CdkDrag<any>;
+    /**
+     * Child nested tree, if present.
+     */
+    readonly nestedTree: _angular_core.Signal<Tree | undefined>;
+    /**
+     * Computed signal indicating if this node has a nested tree.
+     */
+    protected readonly hasNestedTree: _angular_core.Signal<boolean>;
+    /**
+     * Computed signal for node disabled state.
+     */
+    protected readonly isNodeDisabled: _angular_core.Signal<boolean>;
+    /**
+     * Internal state for dragOnlyWhenCollapsed from parent Tree.
+     */
+    private _dragOnlyWhenCollapsed;
+    /**
+     * Track if any parent node is expanded (disables drag when dragOnlyWhenCollapsed is active).
+     */
+    private _hasExpandedParent;
+    /**
+     * Computed to determine if drag handle should be hidden.
+     */
+    protected readonly shouldHideDragHandle: _angular_core.Signal<boolean>;
+    /**
+     * Emitted when a nested tree is closed.
+     */
+    readonly closeEmitter: _angular_core.OutputEmitterRef<void>;
+    constructor();
+    ngOnInit(): void;
+    /**
+     * Update drag state based on expanded state and parent state.
+     */
+    private updateDragState;
+    /**
+     * Handle drag state for nodes with children.
+     */
+    private handleNodeWithChildren;
+    /**
+     * Handle drag state for leaf nodes (no children).
+     */
+    private handleLeafNode;
+    /**
+     * Enable or disable the underlying CDK drag for this node.
+     * @param disabled - Whether the node should be disabled.
+     */
+    handleNodeDisability(disabled: boolean): void;
+    /**
+     * Set drag only when collapsed mode from parent Tree.
+     * @param enabled - Whether drag should only work when collapsed.
+     */
+    setDragOnlyWhenCollapsed(enabled: boolean): void;
+    /**
+     * Set whether this node has an expanded parent.
+     * @param hasExpandedParent - Whether the direct parent is expanded.
+     */
+    setHasExpandedParent(hasExpandedParent: boolean): void;
+    /**
+     * Toggle the node expansion.
+     */
+    toggleExtension(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TreeNode, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TreeNode, "b-tree-node", never, { "expanded": { "alias": "expanded"; "required": false; "isSignal": true; }; }, { "expanded": "expandedChange"; "closeEmitter": "closeEmitter"; }, ["nestedTree"], ["*", "b-tree"], true, [{ directive: typeof i1$4.CdkDrag; inputs: { "cdkDragDisabled": "disabled"; }; outputs: {}; }]>;
+}
+
+/**
+ * Directive that registers and controls a dialog template instance.
+ *
+ * Registers itself in the {@link DialogManager} on init and exposes open/close APIs.
+ */
+declare class Dialog implements OnInit, OnDestroy {
+    /**
+     * Unique dialog identifier bound from the `bDialog` attribute.
+     */
+    readonly id: _angular_core.InputSignal<string>;
+    /**
+     * Whether the dialog renders a backdrop element.
+     *
+     * @defaultValue true
+     */
+    readonly hasBackdrop: _angular_core.InputSignal<boolean>;
+    /**
+     * Closes the dialog when the user clicks on the backdrop.
+     *
+     * @defaultValue true
+     */
+    readonly closeOnBackdropClick: _angular_core.InputSignal<boolean>;
+    /**
+     * Closes the dialog when the Escape key is pressed while focused inside.
+     *
+     * @defaultValue true
+     */
+    readonly closeOnEscapeKey: _angular_core.InputSignal<boolean>;
+    /**
+     * Restores focus to the previously focused element after the dialog closes.
+     *
+     * @defaultValue true
+     */
+    readonly restoreFocus: _angular_core.InputSignal<boolean>;
+    /**
+     * Delay in milliseconds before the dialog is fully closed (useful for animations).
+     *
+     * @defaultValue 150
+     */
+    readonly closeDelay: _angular_core.InputSignal<number>;
+    /**
+     * Computed dialog data passed to the service containing template and configuration.
+     */
+    readonly data: _angular_core.Signal<DialogData>;
+    /**
+     * Delay in milliseconds before opening the dialog (for entrance timing / animations).
+     *
+     * @defaultValue 0
+     */
+    readonly openDelay: _angular_core.InputSignal<number>;
+    /**
+     * Event emitted after the dialog has been programmatically or automatically closed.
+     */
+    readonly closed: _angular_core.OutputEmitterRef<void>;
+    /**
+     * Reference to the dialog service handling registration and state.
+     */
+    private readonly dialogManager;
+    /**
+     * Template reference representing the dialog content projected when opened.
+     */
+    private readonly templateRef;
+    /**
+     * Lifecycle hook that registers the dialog with the dialog service.
+     */
+    ngOnInit(): void;
+    /**
+     * Opens the dialog via the dialog service using its identifier.
+     */
+    open(): void;
+    /**
+     * Closes the dialog and emits the `closed` output.
+     */
+    close(): void;
+    /**
+     * Lifecycle hook that removes the dialog from the dialog service registry.
+     */
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Dialog, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<Dialog, "[bDialog]", ["bDialog"], { "id": { "alias": "bDialog"; "required": true; "isSignal": true; }; "hasBackdrop": { "alias": "hasBackdrop"; "required": false; "isSignal": true; }; "closeOnBackdropClick": { "alias": "closeOnBackdropClick"; "required": false; "isSignal": true; }; "closeOnEscapeKey": { "alias": "closeOnEscapeKey"; "required": false; "isSignal": true; }; "restoreFocus": { "alias": "restoreFocus"; "required": false; "isSignal": true; }; "closeDelay": { "alias": "closeDelay"; "required": false; "isSignal": true; }; "openDelay": { "alias": "openDelay"; "required": false; "isSignal": true; }; }, { "closed": "closed"; }, never, never, true, never>;
+}
+
+/**
+ * Pipe to translate keys using the TranslationManager service.
+ */
+declare class TranslatePipe implements PipeTransform {
+    /** TranslationManager instance for handling translations */
+    private translationManager;
+    /** ChangeDetectorRef to trigger change detection on language change */
+    private cdr;
+    /** Last language used to detect changes */
+    private lastLang;
+    /**
+     * Transforms a translation key into the corresponding translated string.
+     * @param key - The translation key to be translated.
+     * @returns The translated string.
+     */
+    transform(key: string): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TranslatePipe, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<TranslatePipe, "translate", true>;
+}
+
+/**
+ * Interface that defines the breakpoints for different device types
+ */
+interface DeviceBreakpoints {
+    /** Maximum width for mobile devices in pixels */
+    mobile: number;
+    /** Maximum width for tablet devices in pixels */
+    tablet: number;
+    /** Maximum width for desktop devices in pixels */
+    desktop: number;
+}
+/** Available device types */
+type DeviceType = 'mobile' | 'tablet' | 'desktop';
+/**
+ * Service that handles responsive design functionality
+ * Detects current device type based on window width and configurable breakpoints
+ */
+declare class ResponsiveManager {
+    /** Signal that holds the breakpoint configuration */
+    private readonly breakpoints;
+    /** Signal that holds the current window width */
+    private readonly windowWidth;
+    /**
+     * Computed signal that returns the current device type based on window width
+     * @returns The current device type ('mobile', 'tablet', or 'desktop')
+     */
+    readonly currentDevice: _angular_core.Signal<DeviceType>;
+    constructor();
+    /**
+     * Initializes the window width signal with the current window inner width
+     * Only called in browser environment
+     */
+    private initializeWindowWidth;
+    /**
+     * Sets up the resize event listener to update window width
+     * Only called in browser environment
+     */
+    private setupResizeListener;
+    /**
+     * Updates the breakpoint configuration
+     * @param newBreakpoints - Partial breakpoint configuration to update
+     */
+    updateBreakpoints(newBreakpoints: Partial<DeviceBreakpoints>): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ResponsiveManager, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ResponsiveManager>;
+}
+
+declare class ThemeManager {
+    /**
+     * Signal representing the current theme.
+     *
+     * Possible values:
+     * - `'light'`: Light theme.
+     * - `'dark'`: Dark theme.
+     * - `'auto'`: Automatically determine the theme.
+     */
+    readonly theme: _angular_core.WritableSignal<"light" | "dark" | "auto">;
+    /**
+     * Renderer2 instance for manipulating the DOM.
+     * Used to set the `data-theme` attribute on the document root (`<html>`).
+     */
+    private renderer;
+    /**
+     * RendererFactory2 instance for creating Renderer2 instances.
+     * Injected to create the renderer.
+     */
+    private rendererFactory;
+    /**
+     * PLATFORM_ID token to identify the platform.
+     */
+    private platformId;
+    /**
+     * Flag indicating whether the application is running in a browser.
+     */
+    private isBrowser;
+    constructor();
+    /**
+     * Applies the specified theme to the document root (`<html>`).
+     *
+     * @param theme - The theme to apply. Possible values:
+     *   - `'light'`: Apply the light theme.
+     *   - `'dark'`: Apply the dark theme.
+     *   - `'auto'`: Remove the theme attribute and let the system decide.
+     */
+    applyTheme(theme: 'light' | 'dark' | 'auto'): void;
+    /**
+     * Toggles the theme between `'light'` and `'dark'`.
+     * If the current theme is `'light'`, it switches to `'dark'`, and vice versa.
+     */
+    toggleTheme(): void;
+    /**
+     * Removes the `data-theme` attribute from the document body.
+     * This is used when the theme is set to `'auto'`.
+     */
+    removeTheme(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThemeManager, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ThemeManager>;
+}
+
+/**
+ * Dictionary type for translations.
+ * Maps language codes to key-value pairs of translation strings.
+ */
+type TranslationDictionary = Record<string, Record<string, string>>;
+/**
+ * Service for managing translations and language switching.
+ *
+ * @remarks
+ * - Loads language files via HTTP.
+ * - Provides reactive signals for language and dictionary.
+ * - Use `translate(key)` to get the translated string for the current language.
+ *
+ * @example
+ * ```typescript
+ * translationManager.setLanguage('es');
+ * translationManager.translate('home.title');
+ * ```
+ */
+declare class TranslationManager {
+    /** Current language code. */
+    private readonly _language;
+    /** Dictionary of translations. */
+    private readonly _dictionary;
+    /** Reactive signal for current language. */
+    readonly language: _angular_core.Signal<string>;
+    /** Reactive signal for current dictionary. */
+    readonly dictionary: _angular_core.Signal<TranslationDictionary>;
+    /** HttpClient for loading language files. */
+    private http;
+    /**
+     * Sets the current language and loads its dictionary.
+     * @param lang - Language code (e.g., 'en', 'es').
+     */
+    setLanguage(lang: string): void;
+    /**
+     * Sets the translation dictionary directly.
+     * @param dict - Translation dictionary object.
+     */
+    setDictionary(dict: TranslationDictionary): void;
+    /**
+     * Translates a key using the current language.
+     * @param key - Dot-separated translation key (e.g., 'home.title').
+     * @returns Translated string or the key if not found.
+     */
+    translate(key: string): string;
+    /**
+     * Resolves a dot-separated key in an object.
+     * @param obj - Object to resolve key in.
+     * @param key - Dot-separated key string.
+     * @returns Value or undefined if not found.
+     */
+    private resolveKey;
+    /**
+     * Loads a language file via HTTP and updates the dictionary.
+     * @param lang - Language code to load.
+     */
+    loadLanguage(lang: string): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TranslationManager, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<TranslationManager>;
+}
+
+/**
+ * Utility service for common operations.
+ */
+declare class Utils {
+    private debounceTimers;
+    /**
+     * Executes a function after a delay, canceling any previous calls with the same key.
+     *
+     * @param key - Unique key to identify the debounce timer.
+     * @param func - The function to debounce.
+     * @param delay - The delay in milliseconds before executing the function.
+     */
+    debounce(key: string, func: () => void, delay: number): void;
+    /**
+     * Cancels the debounce timer for a specific key.
+     *
+     * @param key - Unique key to identify the debounce timer.
+     */
+    stopDebounce(key: string): void;
+    /**
+     * Generates a simple UUID.
+     *
+     * @returns A string representing a UUID.
+     */
+    generateUUID(): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Utils, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<Utils>;
+}
+
+type Alignment = 'left' | 'center' | 'right' | 'top' | 'bottom';
+
+export { Alert, Backdrop, Badge, Button, ButtonGroup, Calendar, Card, CardContent, CardDescription, CardFooter, CardHeader, CardTitle, Checkbox, CommandComponent, CommandOptionsComponent, ConnectedOverlay, Dialog, DialogContent, DialogManager, Drawer, Input, InputGroup, Menu, MenuGroup, MenuItem, MenuItemCheckbox, MenuItemRadio, MenuLabel, MenuTriggerDirective, Option, Otp, OtpDigitDirective, Overlay, OverlayOrigin, OverlayTrigger, Popover, PopoverTrigger, Range, ResponsiveManager, Select, SelectContent, SelectFilter, SelectTrigger, SelectValue, Skeleton, Spinner, SwitchComponent, Tab, Tabs, Textarea, TextareaGroup, ThemeManager, Tooltip, TooltipContent, TooltipTrigger, TranslatePipe, TranslationManager, Tree, TreeNode, Utils };
+export type { Alignment, DeviceBreakpoints, DeviceType, DialogConfig, DialogData, Direction, Position, TranslationDictionary };