@vsn-ux/ngx-gaia 0.7.3 → 0.8.1

package/index.d.ts

@@ -1,5 +1,964 @@
+import * as lucide_angular from 'lucide-angular';
+import { X, LucideIconData } from 'lucide-angular';
+import * as _angular_core from '@angular/core';
+import { Provider, DoCheck, Signal, InjectionToken, TemplateRef, WritableSignal, AfterViewInit, Renderer2, ElementRef, AfterContentInit } from '@angular/core';
+import { ControlValueAccessor, CheckboxRequiredValidator, ValidationErrors, RequiredValidator } from '@angular/forms';
+import * as _vsn_ux_ngx_gaia from '@vsn-ux/ngx-gaia';
+import * as i1 from '@angular/cdk/menu';
+import * as rxjs from 'rxjs';
+import { Observable, Subject } from 'rxjs';
+import * as i1$1 from '@angular/cdk/a11y';
+import { ComponentType } from '@angular/cdk/portal';
+import * as i1$3 from '@angular/cdk/overlay';
+import { ConnectedPosition, CdkOverlayOrigin } from '@angular/cdk/overlay';
+import * as i1$2 from '@angular/cdk/listbox';
+import { CdkOption, CdkListbox } from '@angular/cdk/listbox';
+
+declare class GaAlertTitleComponent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GaAlertTitleComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<GaAlertTitleComponent, "ga-alert-title", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare function GA_ALERT_I18N_FACTORY(): GaAlertI18nDefault;
+declare abstract class GaAlertI18n {
+    abstract dismissLabel: string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GaAlertI18n, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<GaAlertI18n>;
+}
+declare class GaAlertI18nDefault extends GaAlertI18n {
+    /** A label for the dismiss button */
+    dismissLabel: string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GaAlertI18nDefault, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<GaAlertI18nDefault>;
+}
+declare function provideGaAlertI18n(value: GaAlertI18n | (() => GaAlertI18n)): _angular_core.EnvironmentProviders;
+
+type GaAlertVariant = 'brand' | 'information' | 'error' | 'warning' | 'success';
+declare class GaAlertComponent {
+    protected readonly i18n: GaAlertI18n;
+    readonly dismissIcon: typeof X;
+    readonly variant: _angular_core.InputSignal<GaAlertVariant>;
+    readonly explicitIcon: _angular_core.InputSignal<lucide_angular.LucideIconData | undefined>;
+    readonly dismissible: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly progress: _angular_core.InputSignal<number | "indeterminate" | undefined>;
+    readonly progressLabel: _angular_core.InputSignal<string | undefined>;
+    readonly progressLabelledBy: _angular_core.InputSignal<string | undefined>;
+    readonly dismiss: _angular_core.OutputEmitterRef<void>;
+    readonly icon: _angular_core.Signal<lucide_angular.LucideIconData | null | undefined>;
+    readonly title: _angular_core.Signal<GaAlertTitleComponent | undefined>;
+    readonly progressId: string;
+    readonly variantClass: _angular_core.Signal<string>;
+    readonly hasProgress: _angular_core.Signal<boolean>;
+    readonly progressValue: _angular_core.Signal<number | undefined>;
+    readonly progressBarWidth: _angular_core.Signal<string | undefined>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GaAlertComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<GaAlertComponent, "ga-alert", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "explicitIcon": { "alias": "icon"; "required": false; "isSignal": true; }; "dismissible": { "alias": "dismissible"; "required": false; "isSignal": true; }; "progress": { "alias": "progress"; "required": false; "isSignal": true; }; "progressLabel": { "alias": "progressLabel"; "required": false; "isSignal": true; }; "progressLabelledBy": { "alias": "progressLabelledBy"; "required": false; "isSignal": true; }; }, { "dismiss": "dismiss"; }, ["title"], ["ga-alert-title", "ga-alert-title-actions", "*"], true, never>;
+}
+
+declare class GaAlertTitleActionsComponent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GaAlertTitleActionsComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<GaAlertTitleActionsComponent, "ga-alert-title-actions", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare class GaAlertModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GaAlertModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<GaAlertModule, never, [typeof GaAlertComponent, typeof GaAlertTitleComponent, typeof GaAlertTitleActionsComponent], [typeof GaAlertComponent, typeof GaAlertTitleComponent, typeof GaAlertTitleActionsComponent]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<GaAlertModule>;
+}
+
+type GaBadgeVariant = 'default' | 'default-inverted' | 'information' | 'error' | 'warning' | 'success' | 'muted' | 'disabled';
+type GaBadgeType = 'text' | 'dot';
+declare class GaBadgeComponent {
+    readonly variant: _angular_core.InputSignal<GaBadgeVariant>;
+    readonly type: _angular_core.InputSignal<GaBadgeType>;
+    readonly variantClass: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GaBadgeComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<GaBadgeComponent, "ga-badge", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class GaBadgeModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GaBadgeModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<GaBadgeModule, never, [typeof GaBadgeComponent], [typeof GaBadgeComponent]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<GaBadgeModule>;
+}
+
+type GaButtonType = 'primary' | 'secondary' | 'ghost' | 'transparent';
+declare class GaButtonDirective {
+    private readonly i18n;
+    private readonly el;
+    readonly variant: _angular_core.InputSignal<"" | GaButtonType>;
+    readonly isLoading: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly loadingLabel: _angular_core.InputSignal<string>;
+    readonly disabledImplicit: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly disabled: _angular_core.Signal<"" | null>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GaButtonDirective, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<GaButtonDirective, "button[gaButton], a[gaButton]", never, { "variant": { "alias": "gaButton"; "required": true; "isSignal": true; }; "isLoading": { "alias": "gaButtonLoading"; "required": false; "isSignal": true; }; "loadingLabel": { "alias": "gaButtonLoadingLabel"; "required": false; "isSignal": true; }; "disabledImplicit": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+type GaIconButtonVariant = 'primary' | 'secondary' | 'ghost' | 'transparent';
+declare class GaIconButtonDirective {
+    private readonly i18n;
+    private readonly el;
+    readonly icon: _angular_core.InputSignal<lucide_angular.LucideIconData>;
+    readonly variant: _angular_core.InputSignal<GaIconButtonVariant>;
+    readonly isLoading: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly loadingLabel: _angular_core.InputSignal<string>;
+    readonly disabledImplicit: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly disabled: _angular_core.Signal<"" | null>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GaIconButtonDirective, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<GaIconButtonDirective, "button[gaIconButton], a[gaIconButton]", never, { "icon": { "alias": "gaIconButton"; "required": true; "isSignal": true; }; "variant": { "alias": "gaIconButtonVariant"; "required": false; "isSignal": true; }; "isLoading": { "alias": "gaIconButtonLoading"; "required": false; "isSignal": true; }; "loadingLabel": { "alias": "gaIconButtonLoadingLabel"; "required": false; "isSignal": true; }; "disabledImplicit": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare function GA_BUTTON_I18N_FACTORY(): GaButtonI18nDefault;
+declare abstract class GaButtonI18n {
+    abstract loadingLabel: string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GaButtonI18n, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<GaButtonI18n>;
+}
+declare class GaButtonI18nDefault extends GaButtonI18n {
+    /** A label for the default loading state */
+    loadingLabel: string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GaButtonI18nDefault, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<GaButtonI18nDefault>;
+}
+declare function provideGaButtonI18n(value: GaButtonI18n | (() => GaButtonI18n)): _angular_core.EnvironmentProviders;
+
+declare class GaButtonModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GaButtonModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<GaButtonModule, never, [typeof GaButtonDirective, typeof GaIconButtonDirective], [typeof GaButtonDirective, typeof GaIconButtonDirective]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<GaButtonModule>;
+}
+
+declare class GaCardComponent {
+    readonly selectable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly selected: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GaCardComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<GaCardComponent, "ga-card", never, { "selectable": { "alias": "selectable"; "required": false; "isSignal": true; }; "selected": { "alias": "selected"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class GaCardModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GaCardModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<GaCardModule, never, [typeof GaCardComponent], [typeof GaCardComponent]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<GaCardModule>;
+}
+
+declare const CHECKBOX_CONTROL_VALUE_ACCESSOR: Provider;
+declare class GaCheckboxComponent implements ControlValueAccessor, DoCheck {
+    /** @ignore */
+    protected readonly tabindex?: string | undefined;
+    /** @ignore */
+    private readonly _uniqueId;
+    /** @ignore */
+    private readonly injector;
+    readonly icons: {
+        Minus: lucide_angular.LucideIconData;
+        Check: lucide_angular.LucideIconData;
+    };
+    /** @ignore */
+    private _onTouched?;
+    /** @ignore */
+    private _onModelChanged?;
+    /** @ignore */
+    private _invalidNgModel;
+    private _ngModelName;
+    /** The value attribute of the native input element */
+    readonly value: _angular_core.InputSignal<string | null>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly checked: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly nameInput: _angular_core.InputSignal<string | null>;
+    readonly id: _angular_core.InputSignal<string | null>;
+    readonly indeterminate: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly ariaLabel: _angular_core.InputSignal<string | null>;
+    readonly ariaLabelledby: _angular_core.InputSignal<string | null>;
+    readonly ariaDescribedby: _angular_core.InputSignal<string | null>;
+    readonly ariaInvalid: _angular_core.InputSignal<string | null>;
+    readonly ariaErrormessage: _angular_core.InputSignal<string | null>;
+    readonly required: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly disabledModel: _angular_core.WritableSignal<boolean>;
+    readonly checkedModel: _angular_core.WritableSignal<boolean>;
+    readonly change: _angular_core.OutputEmitterRef<boolean>;
+    readonly indeterminateChange: _angular_core.OutputEmitterRef<boolean>;
+    /** @ignore */
+    readonly inputId: _angular_core.Signal<string | null>;
+    /** @ignore */
+    readonly name: _angular_core.Signal<string | number>;
+    /** @ignore */
+    readonly invalid: _angular_core.Signal<boolean>;
+    constructor(
+    /** @ignore */
+    tabindex?: string | undefined);
+    ngDoCheck(): void;
+    /** @ignore */
+    onInputChange(event: Event): void;
+    /** @ignore */
+    onBlur(): void;
+    /** @ignore */
+    registerOnChange(fn: (value: any) => void): void;
+    /** @ignore */
+    registerOnTouched(fn: any): void;
+    /** @ignore */
+    writeValue(value: any): void;
+    /** @ignore */
+    setDisabledState(isDisabled: boolean): void;
+    /** @ignore */
+    private updateModel;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GaCheckboxComponent, [{ attribute: "tabindex"; }]>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<GaCheckboxComponent, "ga-checkbox", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "checked": { "alias": "checked"; "required": false; "isSignal": true; }; "nameInput": { "alias": "name"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "indeterminate": { "alias": "indeterminate"; "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; }; "ariaInvalid": { "alias": "aria-invalid"; "required": false; "isSignal": true; }; "ariaErrormessage": { "alias": "aria-errormessage"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; }, { "change": "change"; "indeterminateChange": "indeterminateChange"; }, never, ["*"], true, never>;
+}
+
+declare const GA_CHECKBOX_REQUIRED_VALIDATOR: Provider;
 /**
- * Generated bundle index. Do not edit.
+ * Validator for Gaia checkbox's required attribute in template-driven checkbox.
+ * Current CheckboxRequiredValidator only work with `input type=checkbox` and does not
+ * work with `ga-checkbox`.
  */
-/// <amd-module name="@vsn-ux/ngx-gaia" />
-export * from './public-api';
+declare class GaCheckboxRequiredValidator extends CheckboxRequiredValidator {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GaCheckboxRequiredValidator, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<GaCheckboxRequiredValidator, "ga-checkbox[required][formControlName], ga-checkbox[required][formControl], ga-checkbox[required][ngModel]", never, {}, {}, never, never, true, never>;
+}
+
+declare class GaCheckboxModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GaCheckboxModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<GaCheckboxModule, never, [typeof GaCheckboxComponent, typeof GaCheckboxRequiredValidator], [typeof GaCheckboxComponent, typeof GaCheckboxRequiredValidator]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<GaCheckboxModule>;
+}
+
+declare class GaSegmentedControlComponent {
+    readonly selected: _angular_core.ModelSignal<string | undefined>;
+    readonly change: _angular_core.OutputEmitterRef<string | undefined>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GaSegmentedControlComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<GaSegmentedControlComponent, "ga-segmented-control", never, { "selected": { "alias": "selected"; "required": false; "isSignal": true; }; }, { "selected": "selectedChange"; "change": "change"; }, never, ["*"], true, never>;
+}
+
+declare class GaSegmentedControlButtonDirective {
+    /** @ignore */
+    private readonly group;
+    readonly value: _angular_core.InputSignal<string | undefined>;
+    readonly selected: _angular_core.Signal<boolean>;
+    onClick(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GaSegmentedControlButtonDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<GaSegmentedControlButtonDirective, "[gaSegmentedControlButton]", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class GaSegmentedControlIconButtonComponent {
+    readonly value: _angular_core.InputSignal<string>;
+    readonly icon: _angular_core.InputSignal<lucide_angular.LucideIconData>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GaSegmentedControlIconButtonComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<GaSegmentedControlIconButtonComponent, "ga-segmented-control-icon-button", never, { "value": { "alias": "value"; "required": true; "isSignal": true; }; "icon": { "alias": "icon"; "required": true; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class GaSegmentedControlTextButtonComponent {
+    readonly value: _angular_core.InputSignal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GaSegmentedControlTextButtonComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<GaSegmentedControlTextButtonComponent, "ga-segmented-control-text-button", never, { "value": { "alias": "value"; "required": true; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class GaSegmentedControlModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GaSegmentedControlModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<GaSegmentedControlModule, never, [typeof GaSegmentedControlComponent, typeof GaSegmentedControlIconButtonComponent, typeof GaSegmentedControlTextButtonComponent], [typeof GaSegmentedControlComponent, typeof GaSegmentedControlIconButtonComponent, typeof GaSegmentedControlTextButtonComponent]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<GaSegmentedControlModule>;
+}
+
+type GaIconData = LucideIconData;
+declare const GA_ICON_DEFAULT_SIZE = 24;
+declare class GaIconComponent {
+    private readonly elementRef;
+    private readonly baseFontSize;
+    readonly icon: _angular_core.InputSignal<string | LucideIconData>;
+    readonly size: _angular_core.InputSignal<string | number>;
+    readonly color: _angular_core.InputSignal<string | undefined>;
+    readonly strokeWidth: _angular_core.InputSignalWithTransform<number | undefined, unknown>;
+    readonly sizeWithDimension: _angular_core.Signal<string>;
+    constructor(ariaHiddenAttr: string);
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GaIconComponent, [{ attribute: "aria-hidden"; }]>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<GaIconComponent, "ga-icon", never, { "icon": { "alias": "icon"; "required": true; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "strokeWidth": { "alias": "strokeWidth"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class GaIconModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GaIconModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<GaIconModule, never, [typeof GaIconComponent], [typeof GaIconComponent]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<GaIconModule>;
+}
+
+declare class GaInputComponent implements DoCheck {
+    private readonly implicitNgControl;
+    private readonly implicitInvalid;
+    readonly invalidInput: _angular_core.InputSignalWithTransform<boolean | null, unknown>;
+    readonly invalid: _angular_core.Signal<boolean>;
+    ngDoCheck(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GaInputComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<GaInputComponent, "ga-input", never, { "invalidInput": { "alias": "invalidInput"; "required": false; "isSignal": true; }; }, {}, ["implicitNgControl"], ["*"], true, never>;
+}
+
+type GaFormControl = {
+    readonly _formControlId: Signal<string | null | undefined>;
+    readonly _formControlDisabled: Signal<boolean | null | undefined>;
+};
+declare const GA_FORM_CONTROL: InjectionToken<GaFormControl>;
+declare class GaFormControlDirective implements GaFormControl {
+    readonly _formControlId: _angular_core.InputSignal<string | undefined>;
+    readonly _formControlDisabled: _angular_core.InputSignal<boolean | undefined>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GaFormControlDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<GaFormControlDirective, "[gaFormControl]", never, { "_formControlId": { "alias": "gaFormControl"; "required": false; "isSignal": true; }; "_formControlDisabled": { "alias": "gaFormControlDisabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class GaInputDirective implements DoCheck, GaFormControl {
+    readonly uniqueId: string;
+    private readonly implicitNgControl;
+    protected readonly hasWrapper: GaInputComponent | null;
+    private readonly implicitInvalid;
+    private readonly implicitErrors;
+    readonly invalidInput: _angular_core.InputSignalWithTransform<boolean | null, unknown>;
+    readonly idInput: _angular_core.InputSignal<string | undefined>;
+    readonly disabledInput: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly invalid: _angular_core.Signal<boolean>;
+    readonly id: _angular_core.Signal<string>;
+    readonly disabled: _angular_core.WritableSignal<boolean>;
+    readonly errors: _angular_core.Signal<ValidationErrors | null>;
+    readonly _formControlId: _angular_core.Signal<string>;
+    readonly _formControlDisabled: _angular_core.Signal<boolean>;
+    ngDoCheck(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GaInputDirective, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<GaInputDirective, "[gaInput]", never, { "invalidInput": { "alias": "invalid"; "required": false; "isSignal": true; }; "idInput": { "alias": "id"; "required": false; "isSignal": true; }; "disabledInput": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class GaInputModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GaInputModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<GaInputModule, never, [typeof GaInputComponent, typeof GaInputDirective], [typeof GaInputComponent, typeof GaInputDirective]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<GaInputModule>;
+}
+
+declare class GaFormFieldComponent {
+    readonly uniqueId: string;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean | undefined, unknown>;
+    readonly formControl: _angular_core.Signal<_vsn_ux_ngx_gaia.GaFormControl | undefined>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GaFormFieldComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<GaFormFieldComponent, "ga-form-field", ["gaFormField"], { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, ["formControl"], ["*"], true, never>;
+}
+
+declare class GaFieldLabelComponent {
+    private readonly document;
+    readonly formField: GaFormFieldComponent;
+    readonly uniqueId: string;
+    readonly for: _angular_core.InputSignal<string | undefined>;
+    readonly definition: _angular_core.InputSignal<string | TemplateRef<any> | null>;
+    readonly state: _angular_core.InputSignal<string | undefined>;
+    protected readonly controlId: _angular_core.Signal<string | null | undefined>;
+    protected readonly disabled: _angular_core.Signal<boolean>;
+    readonly controlElement: _angular_core.Signal<HTMLElement | null>;
+    focusControl(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GaFieldLabelComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<GaFieldLabelComponent, "ga-label", never, { "for": { "alias": "for"; "required": false; "isSignal": true; }; "definition": { "alias": "definition"; "required": false; "isSignal": true; }; "state": { "alias": "state"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class GaFieldInfoComponent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GaFieldInfoComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<GaFieldInfoComponent, "ga-info", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare class GaLabelledByFormFieldDirective {
+    protected readonly formField: GaFormFieldComponent | null;
+    readonly ariaLabelledBy: _angular_core.InputSignal<string | null>;
+    protected readonly labelledBy: _angular_core.Signal<string | null>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GaLabelledByFormFieldDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<GaLabelledByFormFieldDirective, "[gaLabelledByFormField]", never, { "ariaLabelledBy": { "alias": "aria-labelledby"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class GaFormFieldModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GaFormFieldModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<GaFormFieldModule, never, [typeof GaFormFieldComponent, typeof GaFieldLabelComponent, typeof GaFieldInfoComponent, typeof GaFormControlDirective], [typeof GaFormFieldComponent, typeof GaFieldLabelComponent, typeof GaFieldInfoComponent, typeof GaFormControlDirective]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<GaFormFieldModule>;
+}
+
+declare class GaMenuComponent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GaMenuComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<GaMenuComponent, "ga-menu", never, {}, {}, never, ["*"], true, [{ directive: typeof i1.CdkMenu; inputs: {}; outputs: {}; }]>;
+}
+
+declare class GaMenuItemComponent {
+    readonly icon: _angular_core.InputSignal<string | lucide_angular.LucideIconData | undefined>;
+    readonly description: _angular_core.InputSignal<string>;
+    readonly shortcut: _angular_core.InputSignal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GaMenuItemComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<GaMenuItemComponent, "[gaMenuItem]", never, { "icon": { "alias": "gaMenuItemIcon"; "required": false; "isSignal": true; }; "description": { "alias": "gaMenuItemDescription"; "required": false; "isSignal": true; }; "shortcut": { "alias": "gaMenuItemShortcut"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, [{ directive: typeof i1.CdkMenuItem; inputs: {}; outputs: {}; }]>;
+}
+
+declare class GaMenuTitleComponent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GaMenuTitleComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<GaMenuTitleComponent, "ga-menu-title", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare class GaMenuTriggerDirective {
+    private readonly cdkMenuTrigger;
+    readonly menuRef: _angular_core.InputSignal<TemplateRef<any>>;
+    readonly isOpen: _angular_core.Signal<boolean>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GaMenuTriggerDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<GaMenuTriggerDirective, "[gaMenuTrigger]", ["gaMenuTrigger"], { "menuRef": { "alias": "gaMenuTrigger"; "required": true; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.CdkMenuTrigger; inputs: {}; outputs: { "cdkMenuOpened": "gaMenuOpened"; "cdkMenuClosed": "gaMenuClosed"; }; }]>;
+}
+
+declare class GaMenuSeparatorComponent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GaMenuSeparatorComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<GaMenuSeparatorComponent, "ga-menu-separator", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare class GaMenuTriggerIconComponent {
+    protected readonly menuTrigger: GaMenuTriggerDirective;
+    protected readonly icon: _angular_core.Signal<lucide_angular.LucideIconData>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GaMenuTriggerIconComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<GaMenuTriggerIconComponent, "ga-menu-trigger-icon", never, {}, {}, never, never, true, never>;
+}
+
+declare class GaMenuModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GaMenuModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<GaMenuModule, never, [typeof GaMenuComponent, typeof GaMenuItemComponent, typeof GaMenuTriggerDirective, typeof GaMenuSeparatorComponent, typeof GaMenuTitleComponent, typeof GaMenuTriggerIconComponent], [typeof GaMenuComponent, typeof GaMenuItemComponent, typeof GaMenuTriggerDirective, typeof GaMenuSeparatorComponent, typeof GaMenuTitleComponent, typeof GaMenuTriggerIconComponent]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<GaMenuModule>;
+}
+
+type GaModalRole = 'dialog' | 'alertdialog';
+type GaModalSize = 'sm' | 'md' | 'lg';
+type GaModalType = 'none' | 'info' | 'danger' | 'warning' | 'success';
+declare class GaModalOptions {
+    /**
+     * Defines the predefined size of the modal.
+     *
+     * @default `md`
+     */
+    size?: GaModalSize;
+    /**
+     * Defines the type of the modal:
+     *  - `none` for no icon.
+     *  - `information` for info dialog.
+     *  - `danger` for danger dialog.
+     *  - `warning` for warning dialog.
+     *  - `success` for success dialog.
+     */
+    type?: GaModalType;
+    /**
+     * The ARIA role of the dialog element.
+     *
+     * @default `dialog`
+     */
+    role?: GaModalRole;
+    /**
+     * Defines if the modal should be closed when the escape key is pressed.
+     *
+     * @default `true`
+     */
+    closeOnEscape?: boolean;
+    /**
+     * Defines if the modal should be closed when the backdrop is clicked.
+     *
+     * @default `true`
+     */
+    closeOnOutsideClick?: boolean;
+    /**
+     * Defines if the modal should be closed when the route changes.
+     *
+     * @default `true`
+     */
+    closeOnNavigation?: boolean;
+}
+declare const DEFAULT_MODAL_OPTIONS: Required<GaModalOptions>;
+declare function provideGaModalOptions(options: GaModalOptions): Provider;
+
+declare abstract class GaModalComponent<I = void, O = void> {
+    private readonly closeSubject;
+    private readonly overlayRef;
+    private readonly destroyRef;
+    private readonly router;
+    private readonly globalOptions;
+    protected readonly options: GaModalOptions & {
+        labelledBy?: string;
+        describedBy?: string;
+    };
+    private readonly trapfocus;
+    protected readonly data: I;
+    protected readonly labelledBy: _angular_core.WritableSignal<string | null>;
+    protected readonly describedBy: _angular_core.WritableSignal<string | null>;
+    constructor();
+    close(result?: O): void;
+    afterClosed({ closeOnUnsubscribe }?: {
+        closeOnUnsubscribe: boolean;
+    }): Observable<O | undefined>;
+    /**
+     * "Soft close" hook which is called whenever the modal is being closed
+     * by "Escape" key or Backdrop click.
+     * Return true to permit closing. False - to refuse.
+     */
+    protected onSoftClose(): boolean | Observable<boolean>;
+    private softClose;
+    protected createOptions(options?: GaModalOptions & {
+        labelledBy?: string;
+        describedBy?: string;
+    }): {
+        size: _vsn_ux_ngx_gaia.GaModalSize;
+        type: _vsn_ux_ngx_gaia.GaModalType;
+        role: _vsn_ux_ngx_gaia.GaModalRole;
+        closeOnEscape: boolean;
+        closeOnOutsideClick: boolean;
+        closeOnNavigation: boolean;
+        labelledBy?: string;
+        describedBy?: string;
+    };
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GaModalComponent<any, any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<GaModalComponent<any, any>, "ng-component", never, {}, {}, never, never, true, [{ directive: typeof i1$1.CdkTrapFocus; inputs: {}; outputs: {}; }]>;
+}
+
+declare class GaModalRef<C extends GaModalComponent<any, any>> {
+    instance: C;
+}
+
+type ExtractInput<C extends GaModalComponent<any>> = C extends GaModalComponent<infer I, any> ? I : never;
+
+declare class GaModalService {
+    /** @ignore */
+    private overlay;
+    /** @ignore */
+    private injector;
+    /** @ignore */
+    private parentModalService;
+    /** @ignore */
+    private openModalsAtThisLevel;
+    get activeModals(): WritableSignal<GaModalComponent<any, any>[]>;
+    open<C extends GaModalComponent<any, any>>(component: ComponentType<C>, ...args: ExtractInput<C> extends void ? [(undefined | null)?] : [ExtractInput<C>]): C;
+    closeAll(): void;
+    /** @ignore */
+    private attachContent;
+    /** @ignore */
+    private createOverlay;
+    /** @ignore */
+    private createInjector;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GaModalService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<GaModalService>;
+}
+
+declare class GaModalCloseDirective {
+    private readonly modalRef;
+    readonly modalResult: _angular_core.InputSignal<any>;
+    onClick(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GaModalCloseDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<GaModalCloseDirective, "[gaModalClose]", never, { "modalResult": { "alias": "modalResult"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+declare class GaModalTitleDirective implements AfterViewInit {
+    private readonly renderer;
+    private readonly elementRef;
+    private readonly modalRef;
+    private readonly id;
+    constructor(id?: string);
+    ngAfterViewInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GaModalTitleDirective, [{ attribute: "id"; }]>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<GaModalTitleDirective, "[gaModalTitle]", never, {}, {}, never, never, true, never>;
+}
+declare class GaModalDescriptionDirective implements AfterViewInit {
+    readonly renderer: Renderer2;
+    readonly elementRef: ElementRef<any>;
+    private readonly modalRef;
+    private readonly id;
+    constructor(id?: string);
+    ngAfterViewInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GaModalDescriptionDirective, [{ attribute: "id"; }]>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<GaModalDescriptionDirective, "[gaModalDescription]", never, {}, {}, never, never, true, never>;
+}
+
+declare class GaModalDescriptionComponent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GaModalDescriptionComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<GaModalDescriptionComponent, "ga-modal-description", never, {}, {}, never, ["*"], true, [{ directive: typeof GaModalDescriptionDirective; inputs: {}; outputs: {}; }]>;
+}
+
+declare class GaModalContentComponent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GaModalContentComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<GaModalContentComponent, "ga-modal-content", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare class GaModalActionsComponent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GaModalActionsComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<GaModalActionsComponent, "ga-modal-actions", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare function GA_MODAL_I18N_FACTORY(): GaModalI18nDefault;
+declare abstract class GaModalI18n {
+    abstract dismissLabel: string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GaModalI18n, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<GaModalI18n>;
+}
+declare class GaModalI18nDefault extends GaModalI18n {
+    /** A label for the dismiss button */
+    dismissLabel: string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GaModalI18nDefault, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<GaModalI18nDefault>;
+}
+declare function provideGaModalI18n(value: GaModalI18n | (() => GaModalI18n)): _angular_core.EnvironmentProviders;
+
+declare class GaModalHeaderComponent {
+    protected readonly icons: {
+        X: lucide_angular.LucideIconData;
+        Info: lucide_angular.LucideIconData;
+        CircleCheck: lucide_angular.LucideIconData;
+        TriangleAlert: lucide_angular.LucideIconData;
+        OctagonAlert: lucide_angular.LucideIconData;
+    };
+    protected readonly modalRef: GaModalRef<any>;
+    protected readonly i18n: GaModalI18n;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GaModalHeaderComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<GaModalHeaderComponent, "ga-modal-header", never, {}, {}, never, ["[gaModalTitle]", "ga-modal-description"], true, never>;
+}
+
+declare class GaModalModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GaModalModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<GaModalModule, never, [typeof GaModalCloseDirective, typeof GaModalTitleDirective, typeof GaModalDescriptionDirective, typeof GaModalDescriptionComponent, typeof GaModalContentComponent, typeof GaModalActionsComponent, typeof GaModalHeaderComponent], [typeof GaModalCloseDirective, typeof GaModalTitleDirective, typeof GaModalDescriptionDirective, typeof GaModalDescriptionComponent, typeof GaModalContentComponent, typeof GaModalActionsComponent, typeof GaModalHeaderComponent]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<GaModalModule>;
+}
+
+declare const GA_MODAL_DATA: InjectionToken<any>;
+
+type GaTooltipPosition = 'top' | 'bottom' | 'left' | 'right';
+type GaTooltipDirection = 'start' | 'end' | 'center';
+type GaTooltipPlacement = `${GaTooltipPosition}-${GaTooltipDirection}`;
+type GaTooltipControlMode = 'hover' | 'click' | 'none';
+declare class GaTooltipComponent {
+    readonly uniqueId: string;
+    private mouseLeaveSubject;
+    readonly afterMouseLeave: () => rxjs.Observable<void>;
+    readonly mouseOver: _angular_core.WritableSignal<boolean>;
+    readonly content: _angular_core.InputSignal<string | TemplateRef<any>>;
+    readonly template: _angular_core.Signal<TemplateRef<any> | null>;
+    readonly text: _angular_core.Signal<string | null>;
+    readonly position: _angular_core.InputSignal<"top-start" | "top-end" | "top-center" | "bottom-start" | "bottom-end" | "bottom-center" | "left-start" | "left-end" | "left-center" | "right-start" | "right-end" | "right-center" | undefined>;
+    readonly offset: _angular_core.InputSignal<number>;
+    readonly hideTriggered: _angular_core.OutputEmitterRef<void>;
+    readonly triggerHide: () => void;
+    readonly inlineStyle: _angular_core.Signal<string>;
+    readonly cssClass: _angular_core.Signal<string>;
+    handleMouseEnter(): void;
+    handleMouseLeave(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GaTooltipComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<GaTooltipComponent, "ga-tooltip", never, { "content": { "alias": "content"; "required": true; "isSignal": true; }; "position": { "alias": "position"; "required": false; "isSignal": true; }; "offset": { "alias": "offset"; "required": false; "isSignal": true; }; }, { "hideTriggered": "hideTriggered"; }, never, never, true, never>;
+}
+
+declare const GA_TOOLTIP_DEFAULT_OFFSET = 5;
+declare class GaTooltipDirective {
+    private readonly elementRef;
+    private readonly overlay;
+    private readonly ngZone;
+    protected destroyed$: Subject<void>;
+    private _content;
+    private tooltipInstanceDestroyed$;
+    private outputSubscription;
+    private overlayRef?;
+    private tooltipPortal?;
+    private tooltipRef?;
+    private get tooltipInstance();
+    private currentPosition$?;
+    private _placement;
+    private _offset;
+    private mouseOver;
+    private _showControlMode;
+    private _hideControlMode;
+    set content(value: string | TemplateRef<any> | null);
+    get content(): string | TemplateRef<any> | null;
+    disabled: boolean;
+    controlMode: GaTooltipControlMode;
+    /**
+     * @default `gaTooltipControlMode`
+     */
+    set showControlMode(value: GaTooltipControlMode);
+    get showControlMode(): GaTooltipControlMode;
+    /**
+     * @default `gaTooltipControlMode`
+     */
+    set hideControlMode(value: GaTooltipControlMode);
+    get hideControlMode(): GaTooltipControlMode;
+    set offset(value: number);
+    get offset(): number;
+    set placement(value: GaTooltipPlacement);
+    get placement(): GaTooltipPlacement;
+    get ariaDescribedBy(): string | null;
+    ngOnDestroy(): void;
+    show(): void;
+    hide(): void;
+    toggle(): void;
+    handleMouseClick(): void;
+    handleMouseEnter(): void;
+    handleMouseLeave(): void;
+    /**
+     * hides only if mouse is not over the host element nor the tooltip itself
+     */
+    private softHide;
+    private createOverlay;
+    private updateTooltipPlacement;
+    private updatePosition;
+    private getPositions;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GaTooltipDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<GaTooltipDirective, "[gaTooltip]", ["gaTooltip"], { "content": { "alias": "gaTooltip"; "required": false; }; "disabled": { "alias": "gaTooltipDisabled"; "required": false; }; "controlMode": { "alias": "gaTooltipControlMode"; "required": false; }; "showControlMode": { "alias": "gaTooltipShowControlMode"; "required": false; }; "hideControlMode": { "alias": "gaTooltipHideControlMode"; "required": false; }; "offset": { "alias": "gaTooltipOffsetSize"; "required": false; }; "placement": { "alias": "gaTooltipPlacement"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_disabled: unknown;
+    static ngAcceptInputType_offset: unknown;
+}
+
+declare class GaTooltipModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GaTooltipModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<GaTooltipModule, never, [typeof GaTooltipDirective], [typeof GaTooltipDirective]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<GaTooltipModule>;
+}
+
+declare class GaOptionComponent<InputType = any> {
+    private readonly _isSelected;
+    private readonly _isActive;
+    protected readonly selectComponent: GaSelectComponent;
+    readonly cdkOption: CdkOption<any>;
+    readonly value: _angular_core.InputSignal<InputType | null>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly withInput: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly selected: _angular_core.Signal<boolean>;
+    readonly active: _angular_core.Signal<boolean>;
+    constructor();
+    onClick(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GaOptionComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<GaOptionComponent<any>, "ga-option", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "withInput": { "alias": "withInput"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, [{ directive: typeof i1$2.CdkOption; inputs: { "cdkOption": "value"; "cdkOptionDisabled": "disabled"; "cdkOptionTypeaheadLabel": "typeaheadLabel"; }; outputs: {}; }]>;
+}
+
+declare class GaSelectValueComponent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GaSelectValueComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<GaSelectValueComponent, "ga-select-value", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare class GaSelectComponent implements ControlValueAccessor, GaFormControl, DoCheck, AfterContentInit {
+    private readonly _uniqueId;
+    private focusedTriggerElement;
+    private _onTouched?;
+    private _onModelChanged?;
+    protected readonly positions: ConnectedPosition[];
+    private readonly injector;
+    protected readonly overlayOrigin: CdkOverlayOrigin;
+    private readonly implicitInvalid;
+    private readonly _isOpen;
+    readonly value: _angular_core.ModelSignal<unknown>;
+    readonly placeholder: _angular_core.InputSignal<string>;
+    readonly disabledInput: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly invalidInput: _angular_core.InputSignalWithTransform<boolean | null, unknown>;
+    readonly multiple: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly compareWith: _angular_core.InputSignal<((o1: any, o2: any) => boolean) | undefined>;
+    readonly searchable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly canSelectNullable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly textValue: _angular_core.ModelSignal<string>;
+    readonly leftIcon: _angular_core.InputSignal<lucide_angular.LucideIconData | undefined>;
+    readonly idInput: _angular_core.InputSignal<string | null>;
+    readonly opened: _angular_core.OutputEmitterRef<void>;
+    readonly closed: _angular_core.OutputEmitterRef<void>;
+    readonly gaOptions: _angular_core.Signal<readonly GaOptionComponent<any>[]>;
+    protected readonly cdkListbox: _angular_core.Signal<CdkListbox<any>>;
+    protected readonly customSelectValue: _angular_core.Signal<GaSelectValueComponent | undefined>;
+    protected readonly inputSearch: _angular_core.Signal<ElementRef<HTMLInputElement> | undefined>;
+    protected readonly content: _angular_core.Signal<ElementRef<any> | undefined>;
+    readonly id: _angular_core.Signal<string>;
+    readonly isOpen: _angular_core.Signal<boolean>;
+    readonly disabled: _angular_core.WritableSignal<boolean>;
+    protected readonly menuStatusIcon: _angular_core.Signal<lucide_angular.LucideIconData>;
+    readonly selectedOptions: _angular_core.Signal<GaOptionComponent<any>[]>;
+    readonly activeDescendantId: _angular_core.Signal<string | undefined>;
+    readonly hasValue: _angular_core.Signal<boolean>;
+    readonly invalid: _angular_core.Signal<boolean>;
+    readonly _formControlId: _angular_core.Signal<null>;
+    readonly _formControlDisabled: _angular_core.Signal<boolean>;
+    constructor();
+    ngAfterContentInit(): void;
+    ngDoCheck(): void;
+    writeValue(value: any): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState(disabled: boolean): void;
+    toggle(): void;
+    open(): void;
+    close(): void;
+    autoClose(): void;
+    focusListbox(): void;
+    setPreviousItemActive(): void;
+    setNextItemActive(): void;
+    setActiveItemAsSelected(): void;
+    protected onInputKeyDown(event: KeyboardEvent): void;
+    protected onOverlayAttach(): void;
+    protected onOverlayDetach(): void;
+    deselectValue(value: any): void;
+    private syncValue;
+    private setItemActive;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GaSelectComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<GaSelectComponent, "ga-select", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "disabledInput": { "alias": "disabled"; "required": false; "isSignal": true; }; "invalidInput": { "alias": "invalid"; "required": false; "isSignal": true; }; "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "compareWith": { "alias": "compareWith"; "required": false; "isSignal": true; }; "searchable": { "alias": "searchable"; "required": false; "isSignal": true; }; "canSelectNullable": { "alias": "canSelectNullable"; "required": false; "isSignal": true; }; "textValue": { "alias": "textValue"; "required": false; "isSignal": true; }; "leftIcon": { "alias": "leftIcon"; "required": false; "isSignal": true; }; "idInput": { "alias": "id"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "textValue": "textValueChange"; "opened": "opened"; "closed": "closed"; }, ["gaOptions", "cdkListbox", "customSelectValue"], ["ga-select-value", "ga-select-dropdown"], true, [{ directive: typeof i1$3.CdkOverlayOrigin; inputs: {}; outputs: {}; }, { directive: typeof GaLabelledByFormFieldDirective; inputs: {}; outputs: {}; }]>;
+}
+
+declare class GaOptgroupComponent {
+    readonly label: _angular_core.InputSignal<string | undefined>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GaOptgroupComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<GaOptgroupComponent, "ga-optgroup", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class GaSelectDropdownComponent {
+    readonly loading: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GaSelectDropdownComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<GaSelectDropdownComponent, "ga-select-dropdown", never, { "loading": { "alias": "loading"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, [{ directive: typeof i1$2.CdkListbox; inputs: {}; outputs: {}; }]>;
+}
+
+declare class GaSelectDropdownSpinnerComponent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GaSelectDropdownSpinnerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<GaSelectDropdownSpinnerComponent, "ga-select-dropdown-spinner", never, {}, {}, never, never, true, never>;
+}
+
+declare const GA_SELECT_REQUIRED_VALIDATOR: Provider;
+declare class GaSelectRequiredValidator extends RequiredValidator {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GaSelectRequiredValidator, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<GaSelectRequiredValidator, "ga-select[required][formControlName], ga-select[required][formControl], ga-select[required][ngModel]", never, {}, {}, never, never, true, never>;
+}
+
+declare class GaSelectModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GaSelectModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<GaSelectModule, never, [typeof GaSelectComponent, typeof GaOptionComponent, typeof GaOptgroupComponent, typeof GaSelectDropdownComponent, typeof GaSelectDropdownSpinnerComponent, typeof GaSelectValueComponent, typeof GaSelectRequiredValidator], [typeof GaSelectComponent, typeof GaOptionComponent, typeof GaOptgroupComponent, typeof GaSelectDropdownComponent, typeof GaSelectDropdownSpinnerComponent, typeof GaSelectValueComponent, typeof GaSelectRequiredValidator]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<GaSelectModule>;
+}
+
+declare class GaSpinnerComponent {
+    readonly size: _angular_core.InputSignalWithTransform<number, unknown>;
+    readonly strokeWidth: _angular_core.Signal<number>;
+    readonly center: _angular_core.Signal<number>;
+    readonly radius: _angular_core.Signal<number>;
+    readonly circumference: _angular_core.Signal<number>;
+    readonly arcCircumference: _angular_core.Signal<number>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GaSpinnerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<GaSpinnerComponent, "ga-spinner", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class GaSpinnerModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GaSpinnerModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<GaSpinnerModule, never, [typeof GaSpinnerComponent], [typeof GaSpinnerComponent]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<GaSpinnerModule>;
+}
+
+declare class GaRadioButtonComponent {
+    protected readonly tabindex?: string | undefined;
+    private readonly radioGroup;
+    private _uniqueId;
+    /** The value attribute of the native input element */
+    readonly value: _angular_core.InputSignal<string | null>;
+    readonly inputId: _angular_core.InputSignal<string | null>;
+    readonly inputName: _angular_core.InputSignal<string | null>;
+    readonly inputChecked: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly inputDisabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly ariaLabel: _angular_core.InputSignal<string | null>;
+    readonly ariaLabelledby: _angular_core.InputSignal<string | null>;
+    readonly ariaDescribedby: _angular_core.InputSignal<string | null>;
+    readonly ariaInvalid: _angular_core.InputSignal<string | null>;
+    readonly ariaErrormessage: _angular_core.InputSignal<string | null>;
+    /**
+     * Event emitted when the group value changes.
+     * Change events are only emitted when the value changes due to user interaction with
+     * a radio button (the same behavior as `<input type="radio">`).
+     */
+    readonly change: _angular_core.OutputEmitterRef<string | null>;
+    readonly id: _angular_core.Signal<string>;
+    readonly name: _angular_core.Signal<string>;
+    readonly disabled: _angular_core.Signal<boolean>;
+    protected readonly checked: _angular_core.Signal<boolean>;
+    constructor(tabindex?: string | undefined);
+    onInputChange(event: Event): void;
+    onBlur(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GaRadioButtonComponent, [{ attribute: "tabindex"; }]>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<GaRadioButtonComponent, "ga-radio-button", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "inputId": { "alias": "id"; "required": false; "isSignal": true; }; "inputName": { "alias": "name"; "required": false; "isSignal": true; }; "inputChecked": { "alias": "checked"; "required": false; "isSignal": true; }; "inputDisabled": { "alias": "disabled"; "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; }; "ariaInvalid": { "alias": "aria-invalid"; "required": false; "isSignal": true; }; "ariaErrormessage": { "alias": "aria-errormessage"; "required": false; "isSignal": true; }; }, { "change": "change"; }, never, ["*"], true, never>;
+}
+
+/**
+ * Provider Expression that allows ga-radio-group to register as a ControlValueAccessor.
+ * This allows it to support [(ngModel)] and ngControl.
+ */
+declare const RADIO_CONTROL_VALUE_ACCESSOR: Provider;
+declare class GaRadioGroupComponent implements ControlValueAccessor {
+    /** Name of the radio button group. All radio buttons inside this group will use this name. */
+    readonly name: _angular_core.InputSignal<string>;
+    /**
+     * Value for the radio-group. Should equal the value of the selected radio button if there is
+     * a corresponding radio button with a matching value. If there is not such a corresponding
+     * radio button, this value persists to be applied in case a new radio button is added with a
+     * matching value.
+     */
+    readonly value: _angular_core.InputSignal<string | null>;
+    /** Whether the radio group is disabled */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Event emitted when the group value changes.
+     * Change events are only emitted when the value changes due to user interaction with
+     * a radio button (the same behavior as `<input type="radio">`).
+     */
+    readonly change: _angular_core.OutputEmitterRef<string | null>;
+    readonly valueModel: _angular_core.WritableSignal<string | null>;
+    readonly disabledModel: _angular_core.WritableSignal<boolean>;
+    private _onTouched?;
+    private _onModelChanged?;
+    registerOnChange(fn: (value: any) => void): void;
+    registerOnTouched(fn: any): void;
+    writeValue(value: any): void;
+    setDisabledState(isDisabled: boolean): void;
+    onValueChange(value: string | null): void;
+    onBlur(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GaRadioGroupComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<GaRadioGroupComponent, "ga-radio-group", never, { "name": { "alias": "name"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "change": "change"; }, never, ["*"], true, never>;
+}
+
+declare class GaRadioModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GaRadioModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<GaRadioModule, never, [typeof GaRadioButtonComponent, typeof GaRadioGroupComponent], [typeof GaRadioButtonComponent, typeof GaRadioGroupComponent]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<GaRadioModule>;
+}
+
+/**
+ * Injection token that provides the base root font size in pixels.
+ * This token is used for accurate rem calculations when the default
+ * browser font size (16px) has been overridden by application styles.
+ * Default value is 16px if not explicitly provided.
+ */
+declare const GA_BASE_FONT_SIZE: InjectionToken<number>;
+declare function provideGaBaseFontSize(fontSize: number): _angular_core.EnvironmentProviders;
+
+type GaLinkVariant = 'inline';
+type GaLinkSize = 'small' | 'medium' | 'large';
+declare class GaLinkDirective {
+    readonly variant: _angular_core.InputSignal<"" | "inline">;
+    readonly size: _angular_core.InputSignal<GaLinkSize>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly leadingIcon: _angular_core.InputSignal<string | lucide_angular.LucideIconData>;
+    readonly trailingIcon: _angular_core.InputSignal<string | lucide_angular.LucideIconData>;
+    protected readonly elementRef: ElementRef<any>;
+    protected readonly iconSize: _angular_core.Signal<16 | 24>;
+    protected onClick(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GaLinkDirective, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<GaLinkDirective, "a[gaLink], button[gaLink]", never, { "variant": { "alias": "gaLink"; "required": false; "isSignal": true; }; "size": { "alias": "gaLinkSize"; "required": false; "isSignal": true; }; "disabled": { "alias": "gaLinkDisabled"; "required": false; "isSignal": true; }; "leadingIcon": { "alias": "gaLinkLeadingIcon"; "required": false; "isSignal": true; }; "trailingIcon": { "alias": "gaLinkTrailingIcon"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class GaLinkModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GaLinkModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<GaLinkModule, never, [typeof GaLinkDirective], [typeof GaLinkDirective]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<GaLinkModule>;
+}
+
+declare class GaTextAreaDirective implements DoCheck, GaFormControl {
+    readonly id: _angular_core.InputSignal<string | undefined>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly invalid: _angular_core.InputSignalWithTransform<boolean | undefined, unknown>;
+    readonly _formControlId: _angular_core.Signal<string>;
+    readonly _formControlDisabled: _angular_core.Signal<boolean>;
+    protected readonly uniqueId: _angular_core.Signal<string>;
+    protected readonly invalidInput: _angular_core.Signal<boolean>;
+    private readonly generatedUniqueId;
+    private readonly injector;
+    private readonly implicitInvalid;
+    private readonly disabledModel;
+    ngDoCheck(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GaTextAreaDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<GaTextAreaDirective, "[gaTextArea]", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class GaTextAreaModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GaTextAreaModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<GaTextAreaModule, never, [typeof GaTextAreaDirective], [typeof GaTextAreaDirective]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<GaTextAreaModule>;
+}
+
+export { CHECKBOX_CONTROL_VALUE_ACCESSOR, DEFAULT_MODAL_OPTIONS, GA_ALERT_I18N_FACTORY, GA_BASE_FONT_SIZE, GA_BUTTON_I18N_FACTORY, GA_CHECKBOX_REQUIRED_VALIDATOR, GA_FORM_CONTROL, GA_ICON_DEFAULT_SIZE, GA_MODAL_DATA, GA_MODAL_I18N_FACTORY, GA_SELECT_REQUIRED_VALIDATOR, GA_TOOLTIP_DEFAULT_OFFSET, GaAlertComponent, GaAlertI18n, GaAlertI18nDefault, GaAlertModule, GaAlertTitleActionsComponent, GaAlertTitleComponent, GaBadgeComponent, GaBadgeModule, GaButtonDirective, GaButtonI18n, GaButtonI18nDefault, GaButtonModule, GaCardComponent, GaCardModule, GaCheckboxComponent, GaCheckboxModule, GaCheckboxRequiredValidator, GaFieldInfoComponent, GaFieldLabelComponent, GaFormControlDirective, GaFormFieldComponent, GaFormFieldModule, GaIconButtonDirective, GaIconComponent, GaIconModule, GaInputComponent, GaInputDirective, GaInputModule, GaLabelledByFormFieldDirective, GaLinkDirective, GaLinkModule, GaMenuComponent, GaMenuItemComponent, GaMenuModule, GaMenuSeparatorComponent, GaMenuTitleComponent, GaMenuTriggerDirective, GaMenuTriggerIconComponent, GaModalActionsComponent, GaModalCloseDirective, GaModalComponent, GaModalContentComponent, GaModalDescriptionComponent, GaModalDescriptionDirective, GaModalHeaderComponent, GaModalI18n, GaModalI18nDefault, GaModalModule, GaModalOptions, GaModalRef, GaModalService, GaModalTitleDirective, GaOptgroupComponent, GaOptionComponent, GaRadioButtonComponent, GaRadioGroupComponent, GaRadioModule, GaSegmentedControlButtonDirective, GaSegmentedControlComponent, GaSegmentedControlIconButtonComponent, GaSegmentedControlModule, GaSegmentedControlTextButtonComponent, GaSelectComponent, GaSelectDropdownComponent, GaSelectDropdownSpinnerComponent, GaSelectModule, GaSelectRequiredValidator, GaSelectValueComponent, GaSpinnerComponent, GaSpinnerModule, GaTextAreaDirective, GaTextAreaModule, GaTooltipComponent, GaTooltipDirective, GaTooltipModule, RADIO_CONTROL_VALUE_ACCESSOR, provideGaAlertI18n, provideGaBaseFontSize, provideGaButtonI18n, provideGaModalI18n, provideGaModalOptions };
+export type { GaAlertVariant, GaBadgeType, GaBadgeVariant, GaButtonType, GaFormControl, GaIconButtonVariant, GaIconData, GaLinkSize, GaLinkVariant, GaModalRole, GaModalSize, GaModalType, GaTooltipControlMode, GaTooltipDirection, GaTooltipPlacement, GaTooltipPosition };