@ethlete/cdk 4.28.0 → 4.28.2

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

@@ -0,0 +1,80 @@
+import { OnInit } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../../directives/input/input.directive";
+export declare class SliderComponent implements OnInit {
+    private readonly _elementRef;
+    private readonly _dirService;
+    private readonly _document;
+    private readonly _destroy$;
+    private readonly _mouseDown$;
+    private readonly _touchStart$;
+    private readonly _keyDown$;
+    private readonly _keyUp$;
+    private readonly _input;
+    private readonly _formFieldStateService;
+    get min(): number;
+    set min(value: unknown);
+    private _min$;
+    get max(): number;
+    set max(value: unknown);
+    private _max$;
+    get step(): number;
+    set step(value: unknown);
+    private _step$;
+    get vertical(): boolean;
+    set vertical(value: unknown);
+    private _vertical$;
+    get inverted(): boolean;
+    set inverted(value: unknown);
+    private _inverted$;
+    get renderValueTooltip(): boolean;
+    set renderValueTooltip(value: boolean);
+    private _renderValueTooltip$;
+    private readonly _dir$;
+    private readonly _value$;
+    private readonly _roundToDecimal$;
+    private readonly _percent$;
+    private readonly _shouldInvertAxis$;
+    private readonly _shouldInvertMouseCoords$;
+    private readonly _sliderDimensions$;
+    protected readonly valueText$: import("rxjs").Observable<string>;
+    protected readonly trackBackgroundStyles$: import("rxjs").Observable<{
+        transform: string;
+    }>;
+    protected readonly trackFillStyles$: import("rxjs").Observable<{
+        transform: string;
+        display: string;
+    }>;
+    protected readonly thumbContainerStyles$: import("rxjs").Observable<{
+        transform: string;
+    }>;
+    protected readonly isSlidingVia$: BehaviorSubject<"keyboard" | "pointer" | null>;
+    protected readonly disableAnimations$: BehaviorSubject<boolean>;
+    protected readonly touchId$: BehaviorSubject<number | null>;
+    protected readonly lastPointerEvent$: BehaviorSubject<TouchEvent | MouseEvent | 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;
+    };
+    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;
+    };
+    ngOnInit(): void;
+    private _initializeSlide;
+    private _bindGlobalEvents;
+    private _updateValueFromPosition;
+    private _updateSliderViaKeyboard;
+    private _updateSliderValueBy;
+    private _freshSliderDimensions;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SliderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SliderComponent, "et-slider", never, { "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; "step": { "alias": "step"; "required": false; }; "vertical": { "alias": "vertical"; "required": false; }; "inverted": { "alias": "inverted"; "required": false; }; "renderValueTooltip": { "alias": "renderValueTooltip"; "required": false; }; }, {}, never, never, true, [{ directive: typeof i1.InputDirective; inputs: { "autocomplete": "autocomplete"; }; outputs: {}; }]>;
+    static ngAcceptInputType_renderValueTooltip: unknown;
+}

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

@@ -0,0 +1,10 @@
+import { InputStateService } from '../../../../services';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../../directives/static-form-field/static-form-field.directive";
+import * as i2 from "../../../../directives/writeable-input/writeable-input.directive";
+import * as i3 from "../../../../directives/dynamic-form-field/dynamic-form-field.directive";
+export declare class SliderFieldComponent {
+    protected readonly inputState: InputStateService<unknown, HTMLElement>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SliderFieldComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SliderFieldComponent, "et-slider-field", never, {}, {}, never, ["et-label", "et-slider"], true, [{ directive: typeof i1.StaticFormFieldDirective; inputs: {}; outputs: {}; }, { directive: typeof i2.WriteableInputDirective; inputs: {}; outputs: {}; }, { directive: typeof i3.DynamicFormFieldDirective; inputs: { "hideErrorMessage": "hideErrorMessage"; }; outputs: {}; }]>;
+}

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

@@ -0,0 +1,4 @@
+import { LabelComponent } from '../label/components/label';
+import { SliderComponent } from './components/slider';
+import { SliderFieldComponent } from './components/slider-field';
+export declare const SliderImports: readonly [typeof SliderComponent, typeof SliderFieldComponent, typeof LabelComponent];

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

@@ -0,0 +1,11 @@
+import { InjectionToken } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare const DYNAMIC_FORM_FIELD_TOKEN: InjectionToken<DynamicFormFieldDirective>;
+export declare class DynamicFormFieldDirective {
+    get hideErrorMessage(): boolean;
+    set hideErrorMessage(value: unknown);
+    get hideErrorMessage$(): import("rxjs").Observable<boolean>;
+    private readonly _explicitlyHideErrorMessage$;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DynamicFormFieldDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DynamicFormFieldDirective, never, ["etDynamicFormField"], { "hideErrorMessage": { "alias": "hideErrorMessage"; "required": false; }; }, {}, never, never, true, never>;
+}

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

@@ -0,0 +1,11 @@
+import { InjectionToken } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare const DYNAMIC_FORM_GROUP_TOKEN: InjectionToken<DynamicFormGroupDirective>;
+export declare class DynamicFormGroupDirective {
+    get hideErrorMessage(): boolean;
+    set hideErrorMessage(value: unknown);
+    get hideErrorMessage$(): import("rxjs").Observable<boolean>;
+    private readonly _explicitlyHideErrorMessage$;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DynamicFormGroupDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DynamicFormGroupDirective, never, ["etDynamicFormGroup"], { "hideErrorMessage": { "alias": "hideErrorMessage"; "required": false; }; }, {}, never, never, true, never>;
+}

package/lib/components/forms/directives/expose-input-vars/expose-input-vars.directive.d.ts

@@ -0,0 +1,30 @@
+import { FocusOrigin } from '@angular/cdk/a11y';
+import { InjectionToken } from '@angular/core';
+import { InputValueUpdateType } from '../../types';
+import { InputDirective } from '../input/input.directive';
+import * as i0 from "@angular/core";
+export interface ExposeInputVarsContext {
+    shouldDisplayError: boolean;
+    autofilled: boolean;
+    disabled: boolean;
+    isFocusedVia: FocusOrigin;
+    lastUpdateType: InputValueUpdateType | null;
+    value: unknown;
+}
+export declare const EXPOSE_INPUT_VARS_TOKEN: InjectionToken<ExposeInputVarsDirective>;
+export declare class ExposeInputVarsDirective {
+    private readonly _cdr;
+    private readonly _destroy$;
+    private readonly _monitorStop$;
+    private readonly _templateRef;
+    private readonly _viewContainerRef;
+    private _viewContext;
+    set explicitInput(input: InputDirective | null | undefined);
+    constructor();
+    static ngTemplateContextGuard(dir: ExposeInputVarsDirective, ctx: unknown): ctx is ExposeInputVarsContext;
+    _monitorInput(input: InputDirective): void;
+    private _monitorObservable;
+    private _updateView;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ExposeInputVarsDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ExposeInputVarsDirective, "[etExposeInputVars]", never, { "explicitInput": { "alias": "etExposeInputVars"; "required": false; }; }, {}, never, never, true, never>;
+}

package/lib/components/forms/directives/if-input-empty/if-input-empty.directive.d.ts

@@ -0,0 +1,12 @@
+import { OnInit } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class IfInputEmptyDirective implements OnInit {
+    private readonly _destroy$;
+    private readonly _input;
+    private readonly _templateRef;
+    private readonly _viewContainerRef;
+    private _didCreateView;
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IfInputEmptyDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<IfInputEmptyDirective, "[etIfInputEmpty]", never, {}, {}, never, never, true, never>;
+}

package/lib/components/forms/directives/if-input-filled/if-input-filled.directive.d.ts

@@ -0,0 +1,12 @@
+import { OnInit } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class IfInputFilledDirective implements OnInit {
+    private readonly _destroy$;
+    private readonly _input;
+    private readonly _templateRef;
+    private readonly _viewContainerRef;
+    private _didCreateView;
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IfInputFilledDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<IfInputFilledDirective, "[etIfInputFilled]", never, {}, {}, never, never, true, never>;
+}

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

@@ -0,0 +1,75 @@
+import { FocusOrigin } from '@angular/cdk/a11y';
+import { InjectionToken, OnDestroy, OnInit } from '@angular/core';
+import { Observable } from 'rxjs';
+import { NativeInputRefDirective } from '../native-input-ref';
+import * as i0 from "@angular/core";
+export declare const INPUT_TOKEN: InjectionToken<InputDirective<unknown, HTMLElement>>;
+export declare class InputDirective<T = unknown, J extends HTMLElement = HTMLElement> implements OnInit, OnDestroy {
+    private readonly _injector;
+    private readonly _inputStateService;
+    private readonly _formFieldStateService;
+    private readonly _ngControl;
+    private readonly _destroy$;
+    private readonly _autofillMonitor;
+    private readonly _focusMonitor;
+    private readonly _elementRef;
+    protected _neverEmptyInputs: string[];
+    private _implicitControl?;
+    private get control();
+    private readonly _id;
+    autocomplete: string | null;
+    placeholder: string | null;
+    get id(): string;
+    get value$(): Observable<T | null>;
+    get value(): T | null;
+    get lastUpdateType$(): Observable<import("@ethlete/cdk").InputValueUpdateType | null>;
+    get lastUpdateType(): import("@ethlete/cdk").InputValueUpdateType | null;
+    get valueChange$(): Observable<T>;
+    get disabled$(): Observable<boolean>;
+    get disabled(): boolean;
+    get disabledChange$(): Observable<boolean>;
+    get required$(): Observable<boolean>;
+    get required(): boolean;
+    get requiredChange$(): Observable<boolean>;
+    get labelId$(): Observable<string | null>;
+    get labelId(): string | null;
+    get invalid$(): Observable<boolean>;
+    get invalid(): boolean;
+    get usesImplicitControl$(): Observable<boolean>;
+    get usesImplicitControl(): boolean;
+    get nativeInputRef$(): Observable<NativeInputRefDirective<J> | null>;
+    get nativeInputElement$(): Observable<(J & Record<"value", unknown>) | null>;
+    get nativeInputRef(): NativeInputRefDirective<J> | null;
+    get autofilled$(): Observable<boolean>;
+    get autofilled(): boolean;
+    get errors$(): Observable<import("@ethlete/cdk").ValidatorErrors | null>;
+    get errors(): import("@ethlete/cdk").ValidatorErrors | null;
+    get shouldDisplayError$(): Observable<boolean>;
+    get shouldDisplayError(): boolean;
+    get isFocusedVia$(): Observable<FocusOrigin>;
+    get isFocusedVia(): "touch" | "mouse" | "keyboard" | "program" | null;
+    get errorId$(): Observable<string | null>;
+    get errorId(): string | null;
+    get isNeverEmptyInput$(): Observable<boolean>;
+    get isNeverEmptyInput(): boolean;
+    readonly describedBy$: Observable<string | null>;
+    readonly onInternalUpdate$: Observable<import("@ethlete/cdk").InputValueUpdateType | null>;
+    readonly onExternalUpdate$: Observable<import("@ethlete/cdk").InputValueUpdateType | null>;
+    constructor();
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    focusInputVia(origin?: FocusOrigin): void;
+    _updateValue(value: T, options?: {
+        emitEvent?: boolean;
+    }): void;
+    _updateDisabled(value: boolean): void;
+    _markAsTouched(): void;
+    _setNativeInputRef(ref: NativeInputRefDirective<J> | null): void;
+    _setAutofilled(value: boolean): void;
+    _setShouldDisplayError(value: boolean): void;
+    _setEmptyHelper(value: unknown | Observable<unknown>): void;
+    private _detectControlRequiredValidationChanges;
+    private _detectControlDisabledChanges;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InputDirective<any, any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<InputDirective<any, any>, "[etInput]", ["etInput"], { "autocomplete": { "alias": "autocomplete"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; }, {}, never, never, true, never>;
+}

package/lib/components/forms/directives/input-prefix/input-prefix.directive.d.ts

@@ -0,0 +1,7 @@
+import { InjectionToken } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare const INPUT_PREFIX_TOKEN: InjectionToken<InputPrefixDirective>;
+export declare class InputPrefixDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<InputPrefixDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<InputPrefixDirective, "[etInputPrefix]", ["etInputPrefix"], {}, {}, never, never, true, never>;
+}

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

@@ -0,0 +1,7 @@
+import { InjectionToken } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare const INPUT_SUFFIX_TOKEN: InjectionToken<InputSuffixDirective>;
+export declare class InputSuffixDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<InputSuffixDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<InputSuffixDirective, "[etInputSuffix]", ["etInputSuffix"], {}, {}, never, never, true, never>;
+}

package/lib/components/forms/directives/native-input-ref/native-input-ref.directive.d.ts

@@ -0,0 +1,8 @@
+import { ElementRef, InjectionToken } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare const NATIVE_INPUT_REF_TOKEN: InjectionToken<NativeInputRefDirective<HTMLElement>>;
+export declare class NativeInputRefDirective<T extends HTMLElement = HTMLElement> {
+    readonly element: ElementRef<T>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NativeInputRefDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NativeInputRefDirective<any>, "input[etNativeInputRef], textarea[etNativeInputRef], select[etNativeInputRef], button[etNativeInputRef]", never, {}, {}, never, never, true, never>;
+}

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

@@ -0,0 +1,15 @@
+import { AfterContentInit, InjectionToken, OnInit } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare const STATIC_FORM_FIELD_TOKEN: InjectionToken<StaticFormFieldDirective>;
+export declare class StaticFormFieldDirective implements OnInit, AfterContentInit {
+    private readonly _formFieldStateService;
+    private readonly _destroy$;
+    private readonly _elementRef;
+    private readonly _focusMonitor;
+    private readonly _input?;
+    private readonly _label?;
+    ngOnInit(): void;
+    ngAfterContentInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StaticFormFieldDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<StaticFormFieldDirective, never, ["etStaticFormField"], {}, {}, ["_input", "_label"], never, true, never>;
+}

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

@@ -0,0 +1,7 @@
+import { InjectionToken } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare const STATIC_FORM_GROUP_TOKEN: InjectionToken<StaticFormGroupDirective>;
+export declare class StaticFormGroupDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<StaticFormGroupDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<StaticFormGroupDirective, never, ["etStaticFormGroup"], {}, {}, never, never, true, never>;
+}

package/lib/components/forms/directives/writeable-input/writeable-input.directive.d.ts

@@ -0,0 +1,27 @@
+import { InjectionToken } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+import { InputStateService } from '../../services';
+import { InputTouchedFn, InputValueChangeFn } from '../../types';
+import * as i0 from "@angular/core";
+export declare const WRITEABLE_INPUT_TOKEN: InjectionToken<WriteableInputDirective>;
+export declare const WRITEABLE_INPUT_VALUE_ACCESSOR: {
+    provide: InjectionToken<readonly ControlValueAccessor[]>;
+    useExisting: import("@angular/core").Type<any>;
+    multi: boolean;
+};
+export declare class WriteableInputDirective implements ControlValueAccessor {
+    readonly _inputStateService: InputStateService<unknown, HTMLElement>;
+    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;
+    };
+    writeValue(value: unknown): void;
+    registerOnChange(fn: InputValueChangeFn): void;
+    registerOnTouched(fn: InputTouchedFn): void;
+    setDisabledState?(isDisabled: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WriteableInputDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<WriteableInputDirective, never, ["etWriteableInput"], {}, {}, never, never, true, never>;
+}

package/lib/components/forms/public-api/index.d.ts

@@ -0,0 +1,108 @@
+export * from '../components/checkbox/checkbox.imports';
+export * from '../components/checkbox/components/checkbox';
+export * from '../components/checkbox/components/checkbox-field';
+export * from '../components/checkbox/components/checkbox-group';
+export * from '../components/checkbox/directives/checkbox';
+export * from '../components/checkbox/directives/checkbox-field';
+export * from '../components/checkbox/directives/checkbox-group';
+export * from '../components/checkbox/directives/checkbox-group-control';
+export * from '../components/error/components/error';
+export * from '../components/input/components/date-input';
+export * from '../components/input/components/date-time-input';
+export * from '../components/input/components/email-input';
+export * from '../components/input/components/input-field';
+export * from '../components/input/components/number-input';
+export * from '../components/input/components/password-input';
+export * from '../components/input/components/search-input';
+export * from '../components/input/components/text-input';
+export * from '../components/input/components/textarea-input';
+export * from '../components/input/components/time-input';
+export * from '../components/input/directives/autosize-textarea';
+export * from '../components/input/directives/date-input';
+export * from '../components/input/directives/date-time-input';
+export * from '../components/input/directives/email-input';
+export * from '../components/input/directives/if-supports-show-picker';
+export * from '../components/input/directives/number-input';
+export * from '../components/input/directives/password-input';
+export * from '../components/input/directives/search-input';
+export * from '../components/input/directives/show-picker-trigger';
+export * from '../components/input/directives/text-input';
+export * from '../components/input/directives/textarea-input';
+export * from '../components/input/directives/time-input';
+export * from '../components/input/input.imports';
+export * from '../components/input/partials/password-input-toggle';
+export * from '../components/input/partials/search-input-clear';
+export * from '../components/label/components/label';
+export * from '../components/label/directives/label-suffix';
+export * from '../components/label/label.imports';
+export * from '../components/radio/components/radio';
+export * from '../components/radio/components/radio-field';
+export * from '../components/radio/components/radio-group';
+export * from '../components/radio/directives/radio';
+export * from '../components/radio/directives/radio-field';
+export * from '../components/radio/directives/radio-group';
+export * from '../components/radio/radio.imports';
+export * from '../components/radio/types';
+export * from '../components/segmented-button/components/segmented-button';
+export * from '../components/segmented-button/components/segmented-button-field';
+export * from '../components/segmented-button/components/segmented-button-group';
+export * from '../components/segmented-button/directives/segmented-button';
+export * from '../components/segmented-button/directives/segmented-button-field';
+export * from '../components/segmented-button/directives/segmented-button-group';
+export * from '../components/segmented-button/segmented-button.imports';
+export * from '../components/select/components/combobox/combobox.imports';
+export * from '../components/select/components/combobox/components/combobox';
+export * from '../components/select/components/combobox/constants';
+export * from '../components/select/components/combobox/directives/combobox';
+export * from '../components/select/components/combobox/directives/combobox-body-empty-template';
+export * from '../components/select/components/combobox/directives/combobox-body-error-template';
+export * from '../components/select/components/combobox/directives/combobox-body-loading-template';
+export * from '../components/select/components/combobox/directives/combobox-body-more-items-hint-template';
+export * from '../components/select/components/combobox/directives/combobox-option-template';
+export * from '../components/select/components/combobox/directives/combobox-selected-option-template';
+export * from '../components/select/components/combobox/partials/combobox-body';
+export * from '../components/select/components/combobox/partials/combobox-option';
+export * from '../components/select/components/combobox/types';
+export * from '../components/select/components/combobox/utils';
+export * from '../components/select/components/native-select/components/native-select';
+export * from '../components/select/components/native-select/directives/native-select-input';
+export * from '../components/select/components/native-select/directives/native-select-option';
+export * from '../components/select/components/native-select/native-select.imports';
+export * from '../components/select/components/native-select/partials/native-select-option';
+export * from '../components/select/components/native-select/types';
+export * from '../components/select/components/select/components/select';
+export * from '../components/select/components/select/directives/select';
+export * from '../components/select/components/select/directives/select-body';
+export * from '../components/select/components/select/directives/select-option';
+export * from '../components/select/components/select/partials/select-body';
+export * from '../components/select/components/select/partials/select-option';
+export * from '../components/select/components/select/select.imports';
+export * from '../components/select/components/select-field';
+export * from '../components/select/directives/select-field';
+export * from '../components/selection-list/components/selection-list-field';
+export * from '../components/selection-list/components/selection-list-option';
+export * from '../components/selection-list/directives/selection-list-field';
+export * from '../components/selection-list/directives/selection-list-option';
+export * from '../components/selection-list/selection-list.imports';
+export * from '../components/slide-toggle/components/slide-toggle';
+export * from '../components/slide-toggle/components/slide-toggle-field';
+export * from '../components/slide-toggle/directives/slide-toggle';
+export * from '../components/slide-toggle/slide-toggle.imports';
+export * from '../components/slider/components/slider';
+export * from '../components/slider/components/slider-field';
+export * from '../components/slider/slider.imports';
+export * from '../directives/dynamic-form-field';
+export * from '../directives/dynamic-form-group';
+export * from '../directives/expose-input-vars';
+export * from '../directives/if-input-empty';
+export * from '../directives/if-input-filled';
+export * from '../directives/input';
+export * from '../directives/input-prefix';
+export * from '../directives/input-suffix';
+export * from '../directives/native-input-ref';
+export * from '../directives/static-form-field';
+export * from '../directives/static-form-group';
+export * from '../directives/writeable-input';
+export * from '../services';
+export * from '../types';
+export * from '../utils';

package/lib/components/forms/services/default-validator-errors.service.d.ts

@@ -0,0 +1,17 @@
+import { InjectionToken } from '@angular/core';
+import { Observable } from 'rxjs';
+import { ValidatorErrors } from '../types';
+import * as i0 from "@angular/core";
+export declare const VALIDATOR_ERROR_SERVICE_TOKEN: InjectionToken<ValidationErrorsServiceType>;
+export interface ValidationErrorsServiceType {
+    parse: (errors: ValidatorErrors) => string | Observable<string>;
+}
+export declare const provideValidatorErrorsService: (service?: new () => ValidationErrorsServiceType) => {
+    provide: InjectionToken<ValidationErrorsServiceType>;
+    useClass: new () => ValidationErrorsServiceType;
+};
+export declare class DefaultValidatorErrorsService implements ValidationErrorsServiceType {
+    parse(errors: ValidatorErrors): string | Observable<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DefaultValidatorErrorsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DefaultValidatorErrorsService>;
+}

package/lib/components/forms/services/form-field-state.service.d.ts

@@ -0,0 +1,21 @@
+import { FocusOrigin } from '@angular/cdk/a11y';
+import { BehaviorSubject } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class FormFieldStateService {
+    readonly labelId$: BehaviorSubject<string | null>;
+    readonly labelId: import("@angular/core").Signal<string | null>;
+    readonly inputId$: BehaviorSubject<string | null>;
+    readonly inputId: import("@angular/core").Signal<string | null>;
+    readonly isFocusedVia$: BehaviorSubject<FocusOrigin>;
+    readonly isFocusedVia: import("@angular/core").Signal<"touch" | "mouse" | "keyboard" | "program" | null>;
+    readonly errorId$: BehaviorSubject<string | null>;
+    readonly errorId: import("@angular/core").Signal<string | null>;
+    readonly hasPrefix$: BehaviorSubject<boolean>;
+    readonly hasPrefix: import("@angular/core").Signal<boolean>;
+    readonly hasSuffix$: BehaviorSubject<boolean>;
+    readonly hasSuffix: import("@angular/core").Signal<boolean>;
+    readonly describedBy$: import("rxjs").Observable<string | null>;
+    readonly describedBy: import("@angular/core").Signal<string | null>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormFieldStateService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FormFieldStateService>;
+}

package/lib/components/forms/services/form-group-state.service.d.ts

@@ -0,0 +1,10 @@
+import { BehaviorSubject } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class FormGroupStateService {
+    readonly labelId$: BehaviorSubject<string | null>;
+    readonly inputIds$: BehaviorSubject<string[] | null>;
+    readonly errorId$: BehaviorSubject<string | null>;
+    readonly describedBy$: import("rxjs").Observable<string | null>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormGroupStateService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FormGroupStateService>;
+}

package/lib/components/forms/services/input-state.service.d.ts

@@ -0,0 +1,51 @@
+import { FocusOrigin } from '@angular/cdk/a11y';
+import { BehaviorSubject, Observable, Subject } from 'rxjs';
+import { NativeInputRefDirective } from '../directives/native-input-ref';
+import { InputTouchedFn, InputValueChangeFn, InputValueUpdateType, ValidatorErrors } from '../types';
+import * as i0 from "@angular/core";
+export declare class InputStateService<T = unknown, J extends HTMLElement = HTMLElement> {
+    readonly lastUpdateType$: BehaviorSubject<InputValueUpdateType | null>;
+    readonly lastUpdateType: import("@angular/core").Signal<InputValueUpdateType | null>;
+    readonly onInternalUpdate$: Observable<InputValueUpdateType | null>;
+    readonly onExternalUpdate$: Observable<InputValueUpdateType | null>;
+    readonly value$: BehaviorSubject<T | null>;
+    readonly value: import("@angular/core").Signal<T | null>;
+    readonly disabled$: BehaviorSubject<boolean>;
+    readonly disabled: import("@angular/core").Signal<boolean>;
+    readonly required$: BehaviorSubject<boolean>;
+    readonly required: import("@angular/core").Signal<boolean>;
+    readonly valueChange$: Subject<T>;
+    readonly disabledChange$: Subject<boolean>;
+    readonly requiredChange$: Subject<boolean>;
+    readonly usesImplicitControl$: BehaviorSubject<boolean>;
+    readonly usesImplicitControl: import("@angular/core").Signal<boolean>;
+    readonly nativeInputRef$: BehaviorSubject<NativeInputRefDirective<J> | null>;
+    readonly nativeInputRef: import("@angular/core").Signal<NativeInputRefDirective<J> | null>;
+    readonly isNeverEmptyInput$: BehaviorSubject<boolean>;
+    readonly isNeverEmptyInput: import("@angular/core").Signal<boolean>;
+    readonly autofilled$: BehaviorSubject<boolean>;
+    readonly autofilled: import("@angular/core").Signal<boolean>;
+    readonly valueIsTruthy$: Observable<boolean>;
+    readonly valueIsTruthy: import("@angular/core").Signal<boolean>;
+    readonly valueIsFalsy$: Observable<boolean>;
+    readonly valueIsFalsy: import("@angular/core").Signal<boolean>;
+    /**
+     * Selects might have a option that is "null".
+     * This helper can be used to enhance the detection of empty values.
+     * The input is empty if the helper returns a falsy value and the value itself is falsy or an empty array.
+     */
+    readonly isEmptyHelper$: BehaviorSubject<unknown>;
+    readonly isEmptyHelper: import("@angular/core").Signal<unknown>;
+    readonly valueIsEmpty$: Observable<boolean>;
+    readonly valueIsEmpty: import("@angular/core").Signal<boolean>;
+    readonly errors$: BehaviorSubject<ValidatorErrors | null>;
+    readonly errors: import("@angular/core").Signal<ValidatorErrors | null>;
+    readonly shouldDisplayError$: BehaviorSubject<boolean>;
+    readonly shouldDisplayError: import("@angular/core").Signal<boolean>;
+    readonly isFocusedVia$: BehaviorSubject<FocusOrigin>;
+    readonly isFocusedVia: import("@angular/core").Signal<"touch" | "mouse" | "keyboard" | "program" | null>;
+    _valueChange: InputValueChangeFn<T>;
+    _touched: InputTouchedFn;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InputStateService<any, any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<InputStateService<any, any>>;
+}

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

@@ -0,0 +1,29 @@
+export interface ValidatorErrors {
+    min?: {
+        min: number;
+        actual: number;
+    };
+    max?: {
+        max: number;
+        actual: number;
+    };
+    required?: true;
+    atLeastOneRequired?: true;
+    email?: true;
+    minlength?: {
+        requiredLength: number;
+        actualLength: number;
+    };
+    maxlength?: {
+        requiredLength: number;
+        actualLength: number;
+    };
+    pattern?: {
+        requiredPattern: string;
+        actualValue: string;
+    };
+    [key: string]: unknown;
+}
+export type InputValueChangeFn<T = unknown> = (value: T) => void;
+export type InputTouchedFn = () => void;
+export type InputValueUpdateType = 'internal' | 'external';

package/lib/components/forms/utils/decorated-form-field.base.d.ts

@@ -0,0 +1,13 @@
+import * as i0 from "@angular/core";
+export declare class DecoratedFormFieldBase {
+    private readonly _formFieldStateService;
+    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<DecoratedFormFieldBase, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DecoratedFormFieldBase, never, never, {}, {}, never, never, false, never>;
+}

package/lib/components/forms/utils/decorated-input.base.d.ts

@@ -0,0 +1,26 @@
+import { TypedQueryList } from '@ethlete/core';
+import { BehaviorSubject } from 'rxjs';
+import { InputPrefixDirective } from '../directives/input-prefix';
+import { InputSuffixDirective } from '../directives/input-suffix';
+import { InputBase } from './input.base';
+import * as i0 from "@angular/core";
+export declare class DecoratedInputBase extends InputBase {
+    private readonly _formFieldStateService;
+    readonly _destroy$: import("rxjs").Observable<boolean>;
+    set inputPrefix(inputPrefix: TypedQueryList<InputPrefixDirective>);
+    protected readonly inputPrefix$: BehaviorSubject<TypedQueryList<InputPrefixDirective> | null>;
+    set inputSuffix(inputSuffix: TypedQueryList<InputSuffixDirective>);
+    protected readonly inputSuffix$: BehaviorSubject<TypedQueryList<InputSuffixDirective> | null>;
+    readonly hasPrefix$: import("rxjs").Observable<boolean>;
+    readonly hasSuffix$: 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;
+    };
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<DecoratedInputBase, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DecoratedInputBase, never, never, {}, {}, ["inputPrefix", "inputSuffix"], never, false, never>;
+}