@ethlete/cdk 4.28.0 → 4.28.1

package/lib/components/forms/components/input/input.imports.d.ts

@@ -0,0 +1,21 @@
+import { IfInputEmptyDirective } from '../../directives/if-input-empty';
+import { IfInputFilledDirective } from '../../directives/if-input-filled';
+import { InputPrefixDirective } from '../../directives/input-prefix';
+import { InputSuffixDirective } from '../../directives/input-suffix';
+import { LabelComponent } from '../label/components/label';
+import { DateInputComponent } from './components/date-input';
+import { DateTimeInputComponent } from './components/date-time-input';
+import { EmailInputComponent } from './components/email-input';
+import { InputFieldComponent } from './components/input-field';
+import { NumberInputComponent } from './components/number-input';
+import { PasswordInputComponent } from './components/password-input';
+import { SearchInputComponent } from './components/search-input';
+import { TextInputComponent } from './components/text-input';
+import { TextareaInputComponent } from './components/textarea-input';
+import { TimeInputComponent } from './components/time-input';
+import { AutosizeTextareaDirective } from './directives/autosize-textarea';
+import { IfSupportsShowPickerDirective } from './directives/if-supports-show-picker';
+import { ShowPickerTriggerDirective } from './directives/show-picker-trigger';
+import { PasswordInputToggleComponent } from './partials/password-input-toggle';
+import { SearchInputClearComponent } from './partials/search-input-clear';
+export declare const InputImports: readonly [typeof InputFieldComponent, typeof NumberInputComponent, typeof SearchInputComponent, typeof PasswordInputComponent, typeof PasswordInputToggleComponent, typeof TextInputComponent, typeof TextareaInputComponent, typeof InputPrefixDirective, typeof InputSuffixDirective, typeof IfInputFilledDirective, typeof ShowPickerTriggerDirective, typeof IfInputEmptyDirective, typeof SearchInputClearComponent, typeof EmailInputComponent, typeof LabelComponent, typeof DateInputComponent, typeof DateTimeInputComponent, typeof TimeInputComponent, typeof IfSupportsShowPickerDirective, typeof AutosizeTextareaDirective];

package/lib/components/forms/components/input/partials/password-input-toggle/password-input-toggle.component.d.ts

@@ -0,0 +1,8 @@
+import * as i0 from "@angular/core";
+export declare class PasswordInputToggleComponent {
+    protected readonly passwordInput: import("../../directives/password-input").PasswordInputDirective;
+    protected readonly input: import("../../../../directives/input").InputDirective<unknown, HTMLElement>;
+    ariaLabel?: string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PasswordInputToggleComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PasswordInputToggleComponent, "et-password-input-toggle", never, { "ariaLabel": { "alias": "ariaLabel"; "required": false; }; }, {}, never, ["*"], true, never>;
+}

package/lib/components/forms/components/input/partials/search-input-clear/search-input-clear.component.d.ts

@@ -0,0 +1,8 @@
+import * as i0 from "@angular/core";
+export declare class SearchInputClearComponent {
+    protected readonly searchInput: import("../../directives/search-input").SearchInputDirective;
+    protected readonly input: import("../../../../directives/input").InputDirective<unknown, HTMLElement>;
+    ariaLabel?: string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SearchInputClearComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SearchInputClearComponent, "et-search-input-clear", never, { "ariaLabel": { "alias": "ariaLabel"; "required": false; }; }, {}, never, ["*"], true, never>;
+}

package/lib/components/forms/components/label/components/label/label.component.d.ts

@@ -0,0 +1,10 @@
+import { InjectionToken } from '@angular/core';
+import { FormFieldStateService } from '../../../../services';
+import * as i0 from "@angular/core";
+export declare const LABEL_TOKEN: InjectionToken<LabelComponent>;
+export declare class LabelComponent {
+    protected readonly formFieldStateService: FormFieldStateService;
+    readonly id: string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LabelComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LabelComponent, "et-label", ["etLabel"], {}, {}, never, ["*", "[etLabelSuffix]"], true, never>;
+}

package/lib/components/forms/components/label/directives/label-suffix/label-suffix.directive.d.ts

@@ -0,0 +1,8 @@
+import * as i0 from "@angular/core";
+export declare class LabelSuffixDirective {
+    showToScreenReader: boolean;
+    private get _attrAriaHidden();
+    static ɵfac: i0.ɵɵFactoryDeclaration<LabelSuffixDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<LabelSuffixDirective, "[etLabelSuffix]", ["etLabelSuffix"], { "showToScreenReader": { "alias": "showToScreenReader"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_showToScreenReader: unknown;
+}

package/lib/components/forms/components/label/label.imports.d.ts

@@ -0,0 +1,3 @@
+import { LabelComponent } from './components/label';
+import { LabelSuffixDirective } from './directives/label-suffix';
+export declare const LabelImports: readonly [typeof LabelComponent, typeof LabelSuffixDirective];

package/lib/components/forms/components/radio/components/radio/radio.component.d.ts

@@ -0,0 +1,11 @@
+import { InputBase } from '../../../../utils';
+import { RadioDirective } from '../../directives/radio';
+import * as i0 from "@angular/core";
+import * as i1 from "../../directives/radio/radio.directive";
+import * as i2 from "../../../../directives/input/input.directive";
+export declare class RadioComponent extends InputBase {
+    protected readonly radio: RadioDirective;
+    protected readonly radioGroup: import("../../directives/radio-group").RadioGroupDirective;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RadioComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RadioComponent, "et-radio", never, {}, {}, never, never, true, [{ directive: typeof i1.RadioDirective; inputs: { "value": "value"; "disabled": "disabled"; }; outputs: {}; }, { directive: typeof i2.InputDirective; inputs: { "autocomplete": "autocomplete"; }; outputs: {}; }]>;
+}

package/lib/components/forms/components/radio/components/radio-field/radio-field.component.d.ts

@@ -0,0 +1,7 @@
+import * as i0 from "@angular/core";
+import * as i1 from "../../../../directives/static-form-field/static-form-field.directive";
+import * as i2 from "../../directives/radio-field/radio-field.directive";
+export declare class RadioFieldComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<RadioFieldComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RadioFieldComponent, "et-radio-field, et-radio-card-field", never, {}, {}, never, ["*", "*"], true, [{ directive: typeof i1.StaticFormFieldDirective; inputs: {}; outputs: {}; }, { directive: typeof i2.RadioFieldDirective; inputs: {}; outputs: {}; }]>;
+}

package/lib/components/forms/components/radio/components/radio-group/radio-group.component.d.ts

@@ -0,0 +1,11 @@
+import { InputStateService } from '../../../../services';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../../directives/static-form-group/static-form-group.directive";
+import * as i2 from "../../../../directives/writeable-input/writeable-input.directive";
+import * as i3 from "../../../../directives/dynamic-form-group/dynamic-form-group.directive";
+import * as i4 from "../../directives/radio-group/radio-group.directive";
+export declare class RadioGroupComponent {
+    protected readonly inputState: InputStateService<unknown, HTMLElement>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RadioGroupComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RadioGroupComponent, "et-radio-group", never, {}, {}, never, ["*"], true, [{ directive: typeof i1.StaticFormGroupDirective; inputs: {}; outputs: {}; }, { directive: typeof i2.WriteableInputDirective; inputs: {}; outputs: {}; }, { directive: typeof i3.DynamicFormGroupDirective; inputs: { "hideErrorMessage": "hideErrorMessage"; }; outputs: {}; }, { directive: typeof i4.RadioGroupDirective; inputs: {}; outputs: {}; }]>;
+}

package/lib/components/forms/components/radio/directives/radio/radio.directive.d.ts

@@ -0,0 +1,27 @@
+import { InjectionToken } from '@angular/core';
+import { InputDirective } from '../../../../directives/input';
+import { RadioValue } from '../../types';
+import * as i0 from "@angular/core";
+export declare const RADIO_TOKEN: InjectionToken<RadioDirective>;
+export declare class RadioDirective {
+    readonly input: InputDirective<RadioValue, HTMLElement>;
+    get value(): RadioValue;
+    set value(value: RadioValue);
+    private _value$;
+    get disabled(): boolean;
+    set disabled(value: unknown);
+    private _disabled$;
+    readonly checked$: import("rxjs").Observable<boolean>;
+    readonly disabled$: import("rxjs").Observable<boolean>;
+    readonly hostClassBindings: {
+        remove: (tokens: string) => void;
+        removeMany: (tokens: string[]) => void;
+        has: (tokens: string) => boolean;
+        push: (tokens: string, signal: import("@angular/core").Signal<unknown>) => void;
+        pushMany: (map: Record<string, import("@angular/core").Signal<unknown>>) => void;
+    };
+    _onInputInteraction(event: Event): void;
+    _controlTouched(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RadioDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RadioDirective, never, ["etRadio"], { "value": { "alias": "value"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, {}, never, never, true, never>;
+}

package/lib/components/forms/components/radio/directives/radio-field/radio-field.directive.d.ts

@@ -0,0 +1,22 @@
+import { InjectionToken } from '@angular/core';
+import { TypedQueryList } from '@ethlete/core';
+import { InputStateService } from '../../../../services';
+import { RadioValue } from '../../types';
+import { RadioDirective } from '../radio';
+import * as i0 from "@angular/core";
+export declare const RADIO_FIELD_TOKEN: InjectionToken<RadioFieldDirective>;
+export declare class RadioFieldDirective {
+    readonly inputState: InputStateService<RadioValue, HTMLElement>;
+    set radio(radio: TypedQueryList<RadioDirective>);
+    private _radio$;
+    readonly radioQueryList$: import("rxjs").Observable<TypedQueryList<RadioDirective> | null>;
+    readonly hostClassBindings: {
+        remove: (tokens: string) => void;
+        removeMany: (tokens: string[]) => void;
+        has: (tokens: string) => boolean;
+        push: (tokens: string, signal: import("@angular/core").Signal<unknown>) => void;
+        pushMany: (map: Record<string, import("@angular/core").Signal<unknown>>) => void;
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<RadioFieldDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RadioFieldDirective, never, ["etRadioField"], {}, {}, ["radio"], never, true, never>;
+}

package/lib/components/forms/components/radio/directives/radio-group/radio-group.directive.d.ts

@@ -0,0 +1,16 @@
+import { InjectionToken } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare const RADIO_GROUP_TOKEN: InjectionToken<RadioGroupDirective>;
+export declare class RadioGroupDirective {
+    private readonly _formGroupStateService;
+    readonly name: string;
+    readonly hostAttributeBindings: {
+        remove: (tokens: string) => void;
+        removeMany: (tokens: string[]) => void;
+        has: (tokens: string) => boolean;
+        push: (tokens: string, signal: import("@angular/core").Signal<unknown>) => void;
+        pushMany: (map: Record<string, import("@angular/core").Signal<unknown>>) => void;
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<RadioGroupDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RadioGroupDirective, never, ["etRadioGroup"], {}, {}, never, never, true, never>;
+}

package/lib/components/forms/components/radio/radio.imports.d.ts

@@ -0,0 +1,5 @@
+import { LabelComponent } from '../label/components/label';
+import { RadioComponent } from './components/radio';
+import { RadioFieldComponent } from './components/radio-field';
+import { RadioGroupComponent } from './components/radio-group';
+export declare const RadioImports: readonly [typeof RadioComponent, typeof RadioFieldComponent, typeof RadioGroupComponent, typeof LabelComponent];

package/lib/components/forms/components/segmented-button/components/segmented-button/segmented-button.component.d.ts

@@ -0,0 +1,14 @@
+import { ElementRef, OnInit } from '@angular/core';
+import { InputBase } from '../../../../utils';
+import { SegmentedButtonDirective } from '../../directives/segmented-button';
+import * as i0 from "@angular/core";
+import * as i1 from "../../directives/segmented-button/segmented-button.directive";
+import * as i2 from "../../../../directives/input/input.directive";
+export declare class SegmentedButtonComponent extends InputBase implements OnInit {
+    protected readonly segmentedButton: SegmentedButtonDirective;
+    protected readonly segmentedButtonGroup: import("../../directives/segmented-button-group").SegmentedButtonGroupDirective;
+    activeIndicator?: ElementRef<HTMLElement>;
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SegmentedButtonComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SegmentedButtonComponent, "et-segmented-button", never, {}, {}, never, ["*"], true, [{ directive: typeof i1.SegmentedButtonDirective; inputs: { "value": "value"; "disabled": "disabled"; }; outputs: {}; }, { directive: typeof i2.InputDirective; inputs: {}; outputs: {}; }]>;
+}

package/lib/components/forms/components/segmented-button/components/segmented-button-field/segmented-button-field.component.d.ts

@@ -0,0 +1,7 @@
+import * as i0 from "@angular/core";
+import * as i1 from "../../../../directives/static-form-field/static-form-field.directive";
+import * as i2 from "../../directives/segmented-button-field/segmented-button-field.directive";
+export declare class SegmentedButtonFieldComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SegmentedButtonFieldComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SegmentedButtonFieldComponent, "et-segmented-button-field", never, {}, {}, never, ["*"], true, [{ directive: typeof i1.StaticFormFieldDirective; inputs: {}; outputs: {}; }, { directive: typeof i2.SegmentedButtonFieldDirective; inputs: {}; outputs: {}; }]>;
+}

package/lib/components/forms/components/segmented-button/components/segmented-button-group/segmented-button-group.component.d.ts

@@ -0,0 +1,20 @@
+import { InputStateService } from '../../../../services';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../../directives/static-form-group/static-form-group.directive";
+import * as i2 from "../../../../directives/writeable-input/writeable-input.directive";
+import * as i3 from "../../../../directives/dynamic-form-group/dynamic-form-group.directive";
+import * as i4 from "../../directives/segmented-button-group/segmented-button-group.directive";
+export type SegmentedButtonGroupRenderAs = 'buttons' | 'tabs';
+export declare class SegmentedButtonGroupComponent {
+    protected readonly inputState: InputStateService<unknown, HTMLElement>;
+    renderAs: import("@angular/core").InputSignal<SegmentedButtonGroupRenderAs>;
+    hostClassBindings: {
+        remove: (tokens: string) => void;
+        removeMany: (tokens: string[]) => void;
+        has: (tokens: string) => boolean;
+        push: (tokens: string, signal: import("@angular/core").Signal<unknown>) => void;
+        pushMany: (map: Record<string, import("@angular/core").Signal<unknown>>) => void;
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<SegmentedButtonGroupComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SegmentedButtonGroupComponent, "et-segmented-button-group", never, { "renderAs": { "alias": "renderAs"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, [{ directive: typeof i1.StaticFormGroupDirective; inputs: {}; outputs: {}; }, { directive: typeof i2.WriteableInputDirective; inputs: {}; outputs: {}; }, { directive: typeof i3.DynamicFormGroupDirective; inputs: { "hideErrorMessage": "hideErrorMessage"; }; outputs: {}; }, { directive: typeof i4.SegmentedButtonGroupDirective; inputs: {}; outputs: {}; }]>;
+}

package/lib/components/forms/components/segmented-button/directives/segmented-button/segmented-button.directive.d.ts

@@ -0,0 +1,31 @@
+import { InjectionToken } from '@angular/core';
+import { Primitive } from '@ethlete/core';
+import { InputDirective } from '../../../../directives/input';
+import * as i0 from "@angular/core";
+export declare const SEGMENTED_BUTTON_TOKEN: InjectionToken<SegmentedButtonDirective>;
+export declare class SegmentedButtonDirective {
+    private readonly _activeIndicatorElement$;
+    readonly input: InputDirective<Primitive, HTMLElement>;
+    get value(): Primitive;
+    set value(value: Primitive);
+    private _value$;
+    get disabled(): boolean;
+    set disabled(value: unknown);
+    private _disabled$;
+    readonly checked$: import("rxjs").Observable<boolean>;
+    readonly disabled$: import("rxjs").Observable<boolean>;
+    readonly hostClassBindings: {
+        remove: (tokens: string) => void;
+        removeMany: (tokens: string[]) => void;
+        has: (tokens: string) => boolean;
+        push: (tokens: string, signal: import("@angular/core").Signal<unknown>) => void;
+        pushMany: (map: Record<string, import("@angular/core").Signal<unknown>>) => void;
+    };
+    get activeIndicatorElement$(): import("rxjs").Observable<HTMLElement | null>;
+    get activeIndicatorElement(): HTMLElement | null;
+    _setActiveIndicatorElement(element: HTMLElement): void;
+    _onInputInteraction(event: Event): void;
+    _controlTouched(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SegmentedButtonDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SegmentedButtonDirective, never, ["etSegmentedButton"], { "value": { "alias": "value"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, {}, never, never, true, never>;
+}

package/lib/components/forms/components/segmented-button/directives/segmented-button-field/segmented-button-field.directive.d.ts

@@ -0,0 +1,21 @@
+import { InjectionToken } from '@angular/core';
+import { Primitive, TypedQueryList } from '@ethlete/core';
+import { InputStateService } from '../../../../services';
+import { SegmentedButtonDirective } from '../segmented-button';
+import * as i0 from "@angular/core";
+export declare const SEGMENTED_BUTTON_FIELD_TOKEN: InjectionToken<SegmentedButtonFieldDirective>;
+export declare class SegmentedButtonFieldDirective {
+    readonly inputState: InputStateService<Primitive, HTMLElement>;
+    set segmentedButton(segmentedButton: TypedQueryList<SegmentedButtonDirective>);
+    private _segmentedButton$;
+    readonly segmentedButtonQueryList$: import("rxjs").Observable<TypedQueryList<SegmentedButtonDirective> | null>;
+    readonly hostClassBindings: {
+        remove: (tokens: string) => void;
+        removeMany: (tokens: string[]) => void;
+        has: (tokens: string) => boolean;
+        push: (tokens: string, signal: import("@angular/core").Signal<unknown>) => void;
+        pushMany: (map: Record<string, import("@angular/core").Signal<unknown>>) => void;
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<SegmentedButtonFieldDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SegmentedButtonFieldDirective, never, ["etSegmentedButtonField"], {}, {}, ["segmentedButton"], never, true, never>;
+}

package/lib/components/forms/components/segmented-button/directives/segmented-button-group/segmented-button-group.directive.d.ts

@@ -0,0 +1,20 @@
+import { AfterContentInit, InjectionToken } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare const SEGMENTED_BUTTON_GROUP_TOKEN: InjectionToken<SegmentedButtonGroupDirective>;
+export declare class SegmentedButtonGroupDirective implements AfterContentInit {
+    private readonly _formGroupStateService;
+    private readonly _inputStateService;
+    private readonly _destroy$;
+    readonly name: string;
+    readonly hostAttributeBindings: {
+        remove: (tokens: string) => void;
+        removeMany: (tokens: string[]) => void;
+        has: (tokens: string) => boolean;
+        push: (tokens: string, signal: import("@angular/core").Signal<unknown>) => void;
+        pushMany: (map: Record<string, import("@angular/core").Signal<unknown>>) => void;
+    };
+    private _segmentedButtons?;
+    ngAfterContentInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SegmentedButtonGroupDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SegmentedButtonGroupDirective, never, ["etSegmentedButtonGroup"], {}, {}, ["_segmentedButtons"], never, true, never>;
+}

package/lib/components/forms/components/segmented-button/segmented-button.imports.d.ts

@@ -0,0 +1,4 @@
+import { SegmentedButtonComponent } from './components/segmented-button';
+import { SegmentedButtonFieldComponent } from './components/segmented-button-field';
+import { SegmentedButtonGroupComponent } from './components/segmented-button-group';
+export declare const SegmentedButtonImports: readonly [typeof SegmentedButtonComponent, typeof SegmentedButtonFieldComponent, typeof SegmentedButtonGroupComponent];

package/lib/components/forms/components/select/components/combobox/combobox.imports.d.ts

@@ -0,0 +1,11 @@
+import { InputPrefixDirective } from '../../../../directives/input-prefix';
+import { InputSuffixDirective } from '../../../../directives/input-suffix';
+import { LabelComponent } from '../../../label/components/label';
+import { SelectFieldComponent } from '../select-field';
+import { ComboboxComponent } from './components/combobox';
+import { ComboboxBodyEmptyTemplateDirective } from './directives/combobox-body-empty-template';
+import { ComboboxBodyErrorTemplateDirective } from './directives/combobox-body-error-template';
+import { ComboboxBodyLoadingTemplateDirective } from './directives/combobox-body-loading-template';
+import { ComboboxOptionTemplateDirective } from './directives/combobox-option-template';
+import { ComboboxSelectedOptionTemplateDirective } from './directives/combobox-selected-option-template';
+export declare const ComboboxImports: readonly [typeof ComboboxComponent, typeof SelectFieldComponent, typeof InputPrefixDirective, typeof InputSuffixDirective, typeof LabelComponent, typeof ComboboxOptionTemplateDirective, typeof ComboboxSelectedOptionTemplateDirective, typeof ComboboxBodyErrorTemplateDirective, typeof ComboboxBodyLoadingTemplateDirective, typeof ComboboxBodyEmptyTemplateDirective];

package/lib/components/forms/components/select/components/combobox/components/combobox/combobox.component.d.ts

@@ -0,0 +1,13 @@
+import { DecoratedInputBase } from '../../../../../../utils';
+import { ComboboxDirective } from '../../directives/combobox';
+import * as i0 from "@angular/core";
+import * as i1 from "@ethlete/core";
+import * as i2 from "../../../../../../../overlay/directives/overlay-close-auto-blocker/overlay-close-auto-blocker.directive";
+import * as i3 from "../../../../../../directives/input/input.directive";
+import * as i4 from "../../directives/combobox/combobox.directive";
+export declare class ComboboxComponent extends DecoratedInputBase {
+    protected readonly combobox: ComboboxDirective;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<ComboboxComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ComboboxComponent, "et-combobox", never, {}, {}, never, ["[etInputPrefix]", "[etInputSuffix]", "*"], true, [{ directive: typeof i1.AnimatedOverlayDirective; inputs: {}; outputs: {}; }, { directive: typeof i2.OverlayCloseBlockerDirective; inputs: {}; outputs: {}; }, { directive: typeof i3.InputDirective; inputs: { "placeholder": "placeholder"; }; outputs: {}; }, { directive: typeof i4.ComboboxDirective; inputs: { "options": "options"; "initialValue": "initialValue"; "filterInternal": "filterInternal"; "loading": "loading"; "error": "error"; "emptyText": "emptyText"; "placeholder": "placeholder"; "multiple": "multiple"; "bindLabel": "bindLabel"; "bindValue": "bindValue"; "bindDisabled": "bindDisabled"; "allowCustomValues": "allowCustomValues"; "selectedOptionComponent": "selectedOptionComponent"; "optionComponent": "optionComponent"; "bodyErrorComponent": "bodyErrorComponent"; "bodyLoadingComponent": "bodyLoadingComponent"; "bodyEmptyComponent": "bodyEmptyComponent"; "bodyMoreItemsHintComponent": "bodyMoreItemsHintComponent"; "showBodyMoreItemsHint": "showBodyMoreItemsHint"; "bodyEmptyText": "bodyEmptyText"; "bodyMoreItemsHintText": "bodyMoreItemsHintText"; "optionComponentInputs": "optionComponentInputs"; "selectedOptionComponentInputs": "selectedOptionComponentInputs"; "bodyErrorComponentInputs": "bodyErrorComponentInputs"; "bodyLoadingComponentInputs": "bodyLoadingComponentInputs"; "bodyEmptyComponentInputs": "bodyEmptyComponentInputs"; "bodyMoreItemsHintComponentInputs": "bodyMoreItemsHintComponentInputs"; }; outputs: { "filterChange": "filterChange"; }; }]>;
+}

package/lib/components/forms/components/select/components/combobox/constants/combobox.constants.d.ts

@@ -0,0 +1,6 @@
+import { InjectionToken } from '@angular/core';
+import { ComboboxConfig } from '../types';
+export declare const COMBOBOX_CONFIG_TOKEN: InjectionToken<ComboboxConfig>;
+export declare const COMBOBOX_DEFAULT_CONFIG: {
+    bodyEmptyText: string;
+};

package/lib/components/forms/components/select/components/combobox/directives/combobox/combobox.directive.d.ts

@@ -0,0 +1,161 @@
+import { ComponentType } from '@angular/cdk/overlay';
+import { ElementRef, EventEmitter, InjectionToken, InputSignal, OnInit, TemplateRef, TrackByFunction } from '@angular/core';
+import { ActiveSelectionModel, AnimatedOverlayComponentBase, SelectionModel, SelectionModelBinding, TypedQueryList } from '@ethlete/core';
+import { BehaviorSubject } from 'rxjs';
+import { InputDirective } from '../../../../../../directives/input';
+import { ComboboxKeyHandlerResult, ComponentWithError, ComponentWithOption, TemplateRefWithError, TemplateRefWithOption } from '../../private';
+import * as i0 from "@angular/core";
+export declare const COMBOBOX_TOKEN: InjectionToken<ComboboxDirective>;
+export type AbstractComboboxBody = AnimatedOverlayComponentBase & {
+    _options$: BehaviorSubject<TypedQueryList<AbstractComboboxOption> | null>;
+    _containerElementRef: ElementRef<HTMLElement> | undefined;
+    id: string;
+};
+export type AbstractComboboxOption = {
+    option: InputSignal<unknown>;
+    elementRef: ElementRef<HTMLElement>;
+    id: string;
+};
+export declare class ComboboxDirective implements OnInit {
+    private readonly _destroy$;
+    readonly _input: InputDirective<unknown, HTMLInputElement>;
+    private readonly _selectField;
+    private readonly _animatedOverlay;
+    private readonly _comboboxConfig;
+    private readonly _themeProvider;
+    get options(): unknown[];
+    set options(value: unknown[]);
+    set initialValue(value: unknown);
+    private _initialValue$;
+    get filterInternal(): boolean;
+    set filterInternal(value: unknown);
+    private _filterInternal$;
+    get loading(): boolean;
+    set loading(value: unknown);
+    private _loading$;
+    readonly loading$: import("rxjs").Observable<boolean>;
+    get error(): unknown;
+    set error(value: unknown);
+    private _error$;
+    readonly error$: import("rxjs").Observable<unknown>;
+    /**
+     * @deprecated Use `bodyEmptyText` instead. Will be removed in v5.
+     */
+    emptyText?: string;
+    bodyEmptyText?: string;
+    bodyMoreItemsHintText?: string;
+    /**
+     * To be removed in v5.
+     */
+    get _tempEmptyText(): string;
+    get placeholder(): string | null;
+    set placeholder(value: string | null);
+    private _placeholder$;
+    set multiple(value: unknown);
+    set bindLabel(value: SelectionModelBinding | null);
+    set bindValue(value: SelectionModelBinding | null);
+    set bindKey(value: SelectionModelBinding | null);
+    set bindDisabled(value: SelectionModelBinding | null);
+    get allowCustomValues(): boolean;
+    set allowCustomValues(value: unknown);
+    private _allowCustomValues$;
+    get showBodyMoreItemsHint(): boolean;
+    set showBodyMoreItemsHint(value: boolean);
+    private _showBodyMoreItemsHint$;
+    optionComponent: InputSignal<ComponentWithOption | null | undefined>;
+    optionComponentInputs: InputSignal<Record<string, unknown> | null | undefined>;
+    selectedOptionComponent: InputSignal<ComponentWithOption | null | undefined>;
+    bodyErrorComponentInputs: InputSignal<Record<string, unknown> | null | undefined>;
+    bodyErrorComponent: InputSignal<ComponentWithError | null | undefined>;
+    selectedOptionComponentInputs: InputSignal<Record<string, unknown> | null | undefined>;
+    bodyLoadingComponent: InputSignal<ComponentType<unknown> | null | undefined>;
+    bodyLoadingComponentInputs: InputSignal<Record<string, unknown> | null | undefined>;
+    bodyEmptyComponent: InputSignal<ComponentType<unknown> | null | undefined>;
+    bodyEmptyComponentInputs: InputSignal<Record<string, unknown> | null | undefined>;
+    bodyMoreItemsHintComponent: InputSignal<ComponentType<unknown> | null | undefined>;
+    bodyMoreItemsHintComponentInputs: InputSignal<Record<string, unknown> | null | undefined>;
+    protected readonly filterChange: EventEmitter<string>;
+    private _shouldIgnoreNextBlurEvent;
+    private _deletedSearchWithKeyPress;
+    readonly selectBodyId$: BehaviorSubject<string | null>;
+    readonly activeOptionId$: BehaviorSubject<string | null>;
+    get currentFilter(): string;
+    private readonly _currentFilter$;
+    private get _isOpen();
+    readonly isOpen$: import("rxjs").Observable<boolean>;
+    readonly isOpen: import("@angular/core").Signal<boolean | undefined>;
+    readonly _selectionModel: SelectionModel<unknown>;
+    readonly _activeSelectionModel: ActiveSelectionModel<unknown>;
+    private readonly _backspaceKeyPressManager;
+    readonly selectedOptions$: import("rxjs").Observable<unknown[]>;
+    readonly multiple$: import("rxjs").Observable<boolean>;
+    readonly multipleSignal: import("@angular/core").Signal<boolean>;
+    readonly options$: import("rxjs").Observable<unknown[]>;
+    readonly rawOptions$: import("rxjs").Observable<unknown[]>;
+    set optionTemplate(value: TemplateRefWithOption | undefined);
+    private readonly _optionTemplate$;
+    set selectedOptionTemplate(value: TemplateRefWithOption | undefined);
+    private readonly _selectedOptionTemplate$;
+    set bodyLoadingTemplate(value: TemplateRef<unknown> | undefined);
+    private readonly _bodyLoadingTemplate$;
+    set bodyErrorTemplate(value: TemplateRefWithError | undefined);
+    private readonly _bodyErrorTemplate$;
+    set bodyEmptyTemplate(value: TemplateRef<unknown> | undefined);
+    private readonly _bodyEmptyTemplate$;
+    set bodyMoreItemsHintTemplate(value: TemplateRef<unknown> | undefined);
+    private readonly _bodyMoreItemsHintTemplate$;
+    readonly hostClassBindings: {
+        remove: (tokens: string) => void;
+        removeMany: (tokens: string[]) => void;
+        has: (tokens: string) => boolean;
+        push: (tokens: string, signal: import("@angular/core").Signal<unknown>) => void;
+        pushMany: (map: Record<string, import("@angular/core").Signal<unknown>>) => void;
+    };
+    readonly fieldHostClassBindings: {
+        remove: (tokens: string) => void;
+        removeMany: (tokens: string[]) => void;
+        has: (tokens: string) => boolean;
+        push: (tokens: string, signal: import("@angular/core").Signal<unknown>) => void;
+        pushMany: (map: Record<string, import("@angular/core").Signal<unknown>>) => void;
+    };
+    private _comboboxBodyComponent;
+    readonly customOptionTpl$: import("rxjs").Observable<TemplateRefWithOption | null>;
+    readonly customSelectedOptionTpl$: import("rxjs").Observable<TemplateRefWithOption | null>;
+    readonly customBodyLoadingTpl$: import("rxjs").Observable<TemplateRef<unknown> | null>;
+    readonly customBodyErrorTpl$: import("rxjs").Observable<TemplateRefWithError | null>;
+    readonly customBodyEmptyTpl$: import("rxjs").Observable<TemplateRef<unknown> | null>;
+    readonly customBodyMoreItemsHintTpl$: import("rxjs").Observable<TemplateRef<unknown> | null>;
+    constructor();
+    ngOnInit(): void;
+    setBodyComponent(component: ComponentType<AbstractComboboxBody>): void;
+    getOptionLabel(option: unknown): import("rxjs").Observable<unknown>;
+    getOptionValue(option: unknown): import("rxjs").Observable<unknown>;
+    combineSelectedOptionWithComponentInputs(option: unknown): {
+        option: unknown;
+    };
+    removeSelectedOption(option: unknown): void;
+    open(): void;
+    close(): void;
+    focus(): void;
+    selectInputAndOpen(): void;
+    writeValueFromOption(option: unknown): void;
+    isOptionSelected(option: unknown): import("rxjs").Observable<boolean>;
+    isOptionActive(option: unknown): import("rxjs").Observable<boolean>;
+    isOptionDisabled(option: unknown): import("rxjs").Observable<boolean>;
+    trackByOptionKeyFn: TrackByFunction<unknown>;
+    _ignoreNextBlurEvent(): void;
+    _processKeydownEvent(event: KeyboardEvent): void;
+    _processKeyupEvent(): void;
+    _processInputEvent(event: Event): void;
+    _handleBlurEvent(): void;
+    _updateFilter(value: string): void;
+    _setFilterFromInputValue(): void;
+    _interpretKeyHandlerResult(result: ComboboxKeyHandlerResult): void;
+    private _initDispatchFilterChanges;
+    private _closeBodyOnDisable;
+    private _debugValidateComboboxConfig;
+    private _debugValidateOptionAndInitialValueSchema;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ComboboxDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ComboboxDirective, never, never, { "options": { "alias": "options"; "required": true; }; "initialValue": { "alias": "initialValue"; "required": false; }; "filterInternal": { "alias": "filterInternal"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; "error": { "alias": "error"; "required": false; }; "emptyText": { "alias": "emptyText"; "required": false; }; "bodyEmptyText": { "alias": "bodyEmptyText"; "required": false; }; "bodyMoreItemsHintText": { "alias": "bodyMoreItemsHintText"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "multiple": { "alias": "multiple"; "required": false; }; "bindLabel": { "alias": "bindLabel"; "required": false; }; "bindValue": { "alias": "bindValue"; "required": false; }; "bindKey": { "alias": "bindKey"; "required": false; }; "bindDisabled": { "alias": "bindDisabled"; "required": false; }; "allowCustomValues": { "alias": "allowCustomValues"; "required": false; }; "showBodyMoreItemsHint": { "alias": "showBodyMoreItemsHint"; "required": false; }; "optionComponent": { "alias": "optionComponent"; "required": false; "isSignal": true; }; "optionComponentInputs": { "alias": "optionComponentInputs"; "required": false; "isSignal": true; }; "selectedOptionComponent": { "alias": "selectedOptionComponent"; "required": false; "isSignal": true; }; "bodyErrorComponentInputs": { "alias": "bodyErrorComponentInputs"; "required": false; "isSignal": true; }; "bodyErrorComponent": { "alias": "bodyErrorComponent"; "required": false; "isSignal": true; }; "selectedOptionComponentInputs": { "alias": "selectedOptionComponentInputs"; "required": false; "isSignal": true; }; "bodyLoadingComponent": { "alias": "bodyLoadingComponent"; "required": false; "isSignal": true; }; "bodyLoadingComponentInputs": { "alias": "bodyLoadingComponentInputs"; "required": false; "isSignal": true; }; "bodyEmptyComponent": { "alias": "bodyEmptyComponent"; "required": false; "isSignal": true; }; "bodyEmptyComponentInputs": { "alias": "bodyEmptyComponentInputs"; "required": false; "isSignal": true; }; "bodyMoreItemsHintComponent": { "alias": "bodyMoreItemsHintComponent"; "required": false; "isSignal": true; }; "bodyMoreItemsHintComponentInputs": { "alias": "bodyMoreItemsHintComponentInputs"; "required": false; "isSignal": true; }; }, { "filterChange": "filterChange"; }, ["optionTemplate", "selectedOptionTemplate", "bodyLoadingTemplate", "bodyErrorTemplate", "bodyEmptyTemplate", "bodyMoreItemsHintTemplate"], never, true, never>;
+    static ngAcceptInputType_showBodyMoreItemsHint: unknown;
+}

package/lib/components/forms/components/select/components/combobox/directives/combobox-body-empty-template/combobox-body-empty-template.directive.d.ts

@@ -0,0 +1,8 @@
+import { InjectionToken, TemplateRef } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare const COMBOBOX_BODY_EMPTY_TEMPLATE_TOKEN: InjectionToken<ComboboxBodyEmptyTemplateDirective>;
+export declare class ComboboxBodyEmptyTemplateDirective {
+    readonly template: TemplateRef<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ComboboxBodyEmptyTemplateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ComboboxBodyEmptyTemplateDirective, "ng-template[etComboboxBodyEmptyTemplate]", ["etComboboxBodyEmptyTemplate"], {}, {}, never, never, true, never>;
+}

package/lib/components/forms/components/select/components/combobox/directives/combobox-body-error-template/combobox-body-error-template.directive.d.ts

@@ -0,0 +1,8 @@
+import { InjectionToken, TemplateRef } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare const COMBOBOX_BODY_ERROR_TEMPLATE_TOKEN: InjectionToken<ComboboxBodyErrorTemplateDirective>;
+export declare class ComboboxBodyErrorTemplateDirective {
+    readonly template: TemplateRef<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ComboboxBodyErrorTemplateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ComboboxBodyErrorTemplateDirective, "ng-template[etComboboxBodyErrorTemplate]", ["etComboboxBodyErrorTemplate"], {}, {}, never, never, true, never>;
+}

package/lib/components/forms/components/select/components/combobox/directives/combobox-body-loading-template/combobox-body-loading-template.directive.d.ts

@@ -0,0 +1,8 @@
+import { InjectionToken, TemplateRef } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare const COMBOBOX_BODY_LOADING_TEMPLATE_TOKEN: InjectionToken<ComboboxBodyLoadingTemplateDirective>;
+export declare class ComboboxBodyLoadingTemplateDirective {
+    readonly template: TemplateRef<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ComboboxBodyLoadingTemplateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ComboboxBodyLoadingTemplateDirective, "ng-template[etComboboxBodyLoadingTemplate]", ["etComboboxBodyLoadingTemplate"], {}, {}, never, never, true, never>;
+}

package/lib/components/forms/components/select/components/combobox/directives/combobox-body-more-items-hint-template/combobox-body-more-items-hint-template.directive.d.ts

@@ -0,0 +1,8 @@
+import { InjectionToken, TemplateRef } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare const COMBOBOX_BODY_MORE_ITEMS_HINT_TEMPLATE_TOKEN: InjectionToken<ComboboxBodyMoreItemsHintTemplateDirective>;
+export declare class ComboboxBodyMoreItemsHintTemplateDirective {
+    readonly template: TemplateRef<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ComboboxBodyMoreItemsHintTemplateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ComboboxBodyMoreItemsHintTemplateDirective, "ng-template[etComboboxBodyMoreItemsHintTemplate]", ["etComboboxBodyMoreItemsHintTemplate"], {}, {}, never, never, true, never>;
+}

package/lib/components/forms/components/select/components/combobox/directives/combobox-option-template/combobox-option-template.directive.d.ts

@@ -0,0 +1,8 @@
+import { InjectionToken, TemplateRef } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare const COMBOBOX_OPTION_TEMPLATE_TOKEN: InjectionToken<ComboboxOptionTemplateDirective>;
+export declare class ComboboxOptionTemplateDirective {
+    readonly template: TemplateRef<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ComboboxOptionTemplateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ComboboxOptionTemplateDirective, "ng-template[etComboboxOptionTemplate]", ["etComboboxOptionTemplate"], {}, {}, never, never, true, never>;
+}

package/lib/components/forms/components/select/components/combobox/directives/combobox-selected-option-template/combobox-selected-option-template.directive.d.ts

@@ -0,0 +1,8 @@
+import { InjectionToken, TemplateRef } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare const COMBOBOX_SELECTED_OPTION_TEMPLATE_TOKEN: InjectionToken<ComboboxSelectedOptionTemplateDirective>;
+export declare class ComboboxSelectedOptionTemplateDirective {
+    readonly template: TemplateRef<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ComboboxSelectedOptionTemplateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ComboboxSelectedOptionTemplateDirective, "ng-template[etComboboxSelectedOptionTemplate]", ["etComboboxSelectedOptionTemplate"], {}, {}, never, never, true, never>;
+}