@ardium-pl/ui 5.0.0-alpha.106

package/lib/grid/index.d.ts

@@ -0,0 +1,4 @@
+export * from './grid.component';
+export * from './grid.defaults';
+export * from './grid.module';
+export * from './grid.types';

package/lib/icon/icon.component.d.ts

@@ -0,0 +1,28 @@
+import { AfterViewInit, ElementRef } from '@angular/core';
+import { BooleanLike } from '@ardium-ui/devkit';
+import { Nullable } from '../types/utility.types';
+import * as i0 from "@angular/core";
+type WeightNumber = 100 | 200 | 300 | 400 | 500 | 600 | 700 | 800 | 900;
+type WeightString = '100' | '200' | '300' | '400' | '500' | '600' | '700' | '800' | '900';
+export type Weight = WeightNumber | WeightString;
+type GradeNumber = -25 | 0 | 200;
+type GradeString = '-25' | '0' | '200';
+export type Grade = GradeNumber | GradeString;
+type OpticalSizeNumber = 20 | 24 | 40 | 48;
+type OpticalSizeString = '20' | '24' | '40' | '48';
+export type OpticalSize = OpticalSizeNumber | OpticalSizeString;
+export declare class ArdiumIconComponent implements AfterViewInit {
+    protected readonly _DEFAULTS: import("./icon.defaults").ArdIconDefaults;
+    readonly ariaLabel: import("@angular/core").InputSignal<string>;
+    readonly icon: import("@angular/core").InputSignal<Nullable<string>>;
+    readonly filled: import("@angular/core").InputSignalWithTransform<boolean, BooleanLike>;
+    readonly weight: import("@angular/core").InputSignalWithTransform<WeightNumber | undefined, Nullable<Weight>>;
+    readonly grade: import("@angular/core").InputSignalWithTransform<GradeNumber | undefined, Nullable<GradeNumber>>;
+    readonly opticalSize: import("@angular/core").InputSignalWithTransform<OpticalSizeNumber | undefined, Nullable<OpticalSize>>;
+    readonly fontVariationSettings: import("@angular/core").Signal<string>;
+    readonly contentWrapper: import("@angular/core").Signal<ElementRef<HTMLElement> | undefined>;
+    ngAfterViewInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArdiumIconComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ArdiumIconComponent, "ard-icon", never, { "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "filled": { "alias": "filled"; "required": false; "isSignal": true; }; "weight": { "alias": "weight"; "required": false; "isSignal": true; }; "grade": { "alias": "grade"; "required": false; "isSignal": true; }; "opticalSize": { "alias": "opticalSize"; "required": false; "isSignal": true; }; }, {}, never, ["*"], false, never>;
+}
+export {};

package/lib/icon/icon.defaults.d.ts

@@ -0,0 +1,11 @@
+import { InjectionToken, Provider } from '@angular/core';
+import { Grade, OpticalSize, Weight } from './icon.component';
+export interface ArdIconDefaults {
+    filled: boolean;
+    weight: Weight;
+    grade: Grade;
+    opticalSize: OpticalSize;
+    ariaLabel: string;
+}
+export declare const ARD_ICON_DEFAULTS: InjectionToken<ArdIconDefaults>;
+export declare function provideIconDefaults(config: Partial<ArdIconDefaults>): Provider;

package/lib/icon/icon.module.d.ts

@@ -0,0 +1,9 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./icon.component";
+import * as i2 from "./icon.pipe";
+import * as i3 from "@angular/common";
+export declare class ArdiumIconModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArdiumIconModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ArdiumIconModule, [typeof i1.ArdiumIconComponent, typeof i2.ArdiumIconPipe], [typeof i3.CommonModule], [typeof i1.ArdiumIconComponent, typeof i2.ArdiumIconPipe]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ArdiumIconModule>;
+}

package/lib/icon/icon.pipe.d.ts

@@ -0,0 +1,7 @@
+import { PipeTransform } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class ArdiumIconPipe implements PipeTransform {
+    transform(value: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArdiumIconPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<ArdiumIconPipe, "icon", false>;
+}

package/lib/icon/index.d.ts

@@ -0,0 +1,4 @@
+export * from './icon.component';
+export * from './icon.defaults';
+export * from './icon.module';
+export * from './icon.pipe';

package/lib/inputs/_simple-input-base.d.ts

@@ -0,0 +1,67 @@
+import { AfterViewInit, ElementRef } from '@angular/core';
+import { BooleanLike } from '@ardium-ui/devkit';
+import { _FormFieldComponentBase, _FormFieldComponentDefaults } from '../_internal/form-field-component';
+import { SimpleOneAxisAlignment } from './../types/alignment.types';
+import { FormElementAppearance, FormElementVariant } from './../types/theming.types';
+import { Nullable } from './../types/utility.types';
+import { ArdInputType } from './input-types';
+import { InputModel } from './input-utils';
+import * as i0 from "@angular/core";
+export interface _SimpleInputComponentDefaults extends _FormFieldComponentDefaults {
+    appearance: FormElementAppearance;
+    variant: FormElementVariant;
+    compact: boolean;
+    placeholder: string;
+    alignText: SimpleOneAxisAlignment;
+    clearable: boolean;
+    clearButtonTitle: string;
+    inputAttrs: Record<string, any>;
+    maxLength: Nullable<number>;
+    autoTrim: boolean;
+    type: ArdInputType;
+}
+export declare const _simpleInputComponentDefaults: _SimpleInputComponentDefaults;
+export declare abstract class _SimpleInputComponentBase extends _FormFieldComponentBase implements AfterViewInit {
+    protected readonly _DEFAULTS: _SimpleInputComponentDefaults;
+    readonly textInputEl: import("@angular/core").Signal<ElementRef<HTMLInputElement> | undefined>;
+    protected readonly inputModel: InputModel;
+    private _wasViewInit;
+    ngAfterViewInit(): void;
+    readonly placeholder: import("@angular/core").InputSignal<string>;
+    readonly clearButtonTitle: import("@angular/core").InputSignal<string>;
+    abstract readonly prefixTemplate: any;
+    abstract readonly suffixTemplate: any;
+    abstract readonly placeholderTemplate: any;
+    readonly shouldDisplayPlaceholder: import("@angular/core").Signal<boolean>;
+    readonly appearance: import("@angular/core").InputSignal<FormElementAppearance>;
+    readonly variant: import("@angular/core").InputSignal<FormElementVariant>;
+    readonly alignText: import("@angular/core").InputSignal<SimpleOneAxisAlignment>;
+    readonly compact: import("@angular/core").InputSignalWithTransform<boolean, BooleanLike>;
+    readonly ngClasses: import("@angular/core").Signal<string>;
+    readonly type: import("@angular/core").InputSignal<ArdInputType>;
+    readonly inputAttrs: import("@angular/core").InputSignal<Record<string, any>>;
+    readonly maxLength: import("@angular/core").InputSignalWithTransform<Nullable<number>, any>;
+    readonly maxLengthAsInt: import("@angular/core").Signal<number>;
+    readonly clearable: import("@angular/core").InputSignalWithTransform<boolean, BooleanLike>;
+    readonly autoTrim: import("@angular/core").InputSignalWithTransform<boolean, BooleanLike>;
+    writeValue(v: any): void;
+    protected _valueBeforeInit?: string | null;
+    set value(v: string | null);
+    get value(): string | null;
+    readonly valueChange: import("@angular/core").OutputEmitterRef<string | null>;
+    readonly inputEvent: import("@angular/core").OutputEmitterRef<string | null>;
+    readonly changeEvent: import("@angular/core").OutputEmitterRef<string | null>;
+    readonly clearEvent: import("@angular/core").OutputEmitterRef<MouseEvent>;
+    onInput(newVal: string): void;
+    protected _emitInput(): void;
+    onFocusMaster(event: FocusEvent): void;
+    onBlurMaster(event: FocusEvent): void;
+    onChange(event: Event): void;
+    protected _emitChange(): void;
+    readonly shouldShowClearButton: import("@angular/core").Signal<boolean>;
+    onClearButtonClick(event: MouseEvent): void;
+    onCopy(event: ClipboardEvent): void;
+    protected _setInputAttributes(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<_SimpleInputComponentBase, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<_SimpleInputComponentBase, never, never, { "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "clearButtonTitle": { "alias": "clearButtonTitle"; "required": false; "isSignal": true; }; "appearance": { "alias": "appearance"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "alignText": { "alias": "alignText"; "required": false; "isSignal": true; }; "compact": { "alias": "compact"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; "inputAttrs": { "alias": "inputAttrs"; "required": false; "isSignal": true; }; "maxLength": { "alias": "maxLength"; "required": false; "isSignal": true; }; "clearable": { "alias": "clearable"; "required": false; "isSignal": true; }; "autoTrim": { "alias": "autoTrim"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; }; }, { "valueChange": "valueChange"; "inputEvent": "input"; "changeEvent": "change"; "clearEvent": "clear"; }, never, never, true, never>;
+}

package/lib/inputs/autocomplete-input/autocomplete-input.component.d.ts

@@ -0,0 +1,69 @@
+import { AfterViewInit, ElementRef, TemplateRef } from '@angular/core';
+import { BooleanLike } from '@ardium-ui/devkit';
+import { SimplestItemStorage, SimplestItemStorageHost } from '../../_internal/item-storages/simplest-item-storage';
+import { DropdownPanelAppearance, DropdownPanelVariant } from '../../dropdown-panel/dropdown-panel.types';
+import { ArdSimplestStorageItem } from '../../types/item-storage.types';
+import { Nullable } from '../../types/utility.types';
+import { _SimpleInputComponentBase } from '../_simple-input-base';
+import { OptionContext } from './../../types/item-storage.types';
+import { InputModel, InputModelHost } from './../input-utils';
+import { ArdAutocompleteInputDefaults } from './autocomplete-input.defaults';
+import { ArdAutocompleteInputLoadingTemplateDirective, ArdAutocompleteInputPlaceholderTemplateDirective, ArdAutocompleteInputPrefixTemplateDirective, ArdAutocompleteInputSuffixTemplateDirective, ArdAutocompleteInputSuggestionTemplateDirective } from './autocomplete-input.directives';
+import * as i0 from "@angular/core";
+export declare class ArdiumAutocompleteInputComponent extends _SimpleInputComponentBase implements InputModelHost, SimplestItemStorageHost, AfterViewInit {
+    private readonly overlay;
+    private readonly scrollStrategyOpts;
+    private readonly viewContainerRef;
+    protected readonly _DEFAULTS: ArdAutocompleteInputDefaults;
+    readonly DEFAULTS: ArdAutocompleteInputDefaults;
+    constructor(defaults: ArdAutocompleteInputDefaults);
+    protected readonly inputModel: InputModel;
+    readonly charlistFromInput: import("@angular/core").InputSignalWithTransform<RegExp | undefined, string>;
+    readonly charlistCaseInsensitive: import("@angular/core").InputSignalWithTransform<boolean, BooleanLike>;
+    readonly charlist: import("@angular/core").Signal<RegExp | undefined>;
+    readonly autocomplete: import("@angular/core").InputSignal<Nullable<string>>;
+    readonly shouldDisplayAutocomplete: import("@angular/core").Signal<boolean>;
+    readonly acceptAutocompleteEvent: import("@angular/core").OutputEmitterRef<void>;
+    readonly prefixTemplate: import("@angular/core").Signal<ArdAutocompleteInputPrefixTemplateDirective | undefined>;
+    readonly suffixTemplate: import("@angular/core").Signal<ArdAutocompleteInputSuffixTemplateDirective | undefined>;
+    readonly prefixComponent: import("@angular/core").Type<import("@ardium-pl/ui").ArdFormFieldFramePrefixSuffix> | undefined;
+    readonly suffixComponent: import("@angular/core").Type<import("@ardium-pl/ui").ArdFormFieldFramePrefixSuffix> | undefined;
+    readonly placeholderTemplate: import("@angular/core").Signal<ArdAutocompleteInputPlaceholderTemplateDirective | undefined>;
+    readonly suggestionStorage: SimplestItemStorage;
+    readonly valueFrom: import("@angular/core").InputSignal<Nullable<string>>;
+    readonly labelFrom: import("@angular/core").InputSignal<Nullable<string>>;
+    readonly acceptSuggestionEvent: import("@angular/core").OutputEmitterRef<any>;
+    readonly suggestionItems: import("@ardium-ui/devkit").ArraySignal<ArdSimplestStorageItem>;
+    set suggestions(value: any);
+    private readonly _suggestionDropdowOpen;
+    readonly shouldDisplaySuggestions: import("@angular/core").Signal<boolean>;
+    readonly areSuggestionsLoading: import("@angular/core").InputSignalWithTransform<boolean, BooleanLike>;
+    readonly suggestionsLoadingText: import("@angular/core").InputSignal<string>;
+    readonly suggestionTemplate: import("@angular/core").Signal<ArdAutocompleteInputSuggestionTemplateDirective | undefined>;
+    readonly suggestionLoadingTemplate: import("@angular/core").Signal<ArdAutocompleteInputLoadingTemplateDirective | undefined>;
+    readonly dropdownHost: import("@angular/core").Signal<ElementRef<HTMLDivElement> | undefined>;
+    readonly dropdownTemplate: import("@angular/core").Signal<TemplateRef<any> | undefined>;
+    private dropdownOverlay;
+    ngAfterViewInit(): void;
+    setOverlaySize(): void;
+    readonly optionContextGenerator: import("@angular/core").Signal<(item: ArdSimplestStorageItem) => OptionContext<ArdSimplestStorageItem>>;
+    private _isMouseBeingUsed;
+    onMouseMove(): void;
+    onSuggestionMouseEnter(item: ArdSimplestStorageItem, event: MouseEvent): void;
+    onSuggestionMouseLeave(item: ArdSimplestStorageItem, event: MouseEvent): void;
+    selectSuggestion(item: ArdSimplestStorageItem, event: MouseEvent): void;
+    private _selectSuggestion;
+    handleSuggestionClickOutside(event: MouseEvent): void;
+    readonly dropdownAppearance: import("@angular/core").InputSignal<Nullable<DropdownPanelAppearance>>;
+    readonly dropdownAppearanceOrDefault: import("@angular/core").Signal<DropdownPanelAppearance>;
+    readonly dropdownVariant: import("@angular/core").InputSignal<Nullable<DropdownPanelVariant>>;
+    readonly dropdownVariantOrDefault: import("@angular/core").Signal<DropdownPanelVariant>;
+    onFocus(event: FocusEvent): void;
+    onKeyPress(event: KeyboardEvent): void;
+    protected _onTabOrEnterPress(event: KeyboardEvent): void;
+    private _onEnterPress;
+    private _onArrowDownPress;
+    private _onArrowUpPress;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArdiumAutocompleteInputComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ArdiumAutocompleteInputComponent, "ard-autocomplete-input", never, { "charlistFromInput": { "alias": "charlist"; "required": false; "isSignal": true; }; "charlistCaseInsensitive": { "alias": "charlistCaseInsensitive"; "required": false; "isSignal": true; }; "autocomplete": { "alias": "autocomplete"; "required": false; "isSignal": true; }; "valueFrom": { "alias": "suggValueFrom"; "required": false; "isSignal": true; }; "labelFrom": { "alias": "suggLabelFrom"; "required": false; "isSignal": true; }; "suggestions": { "alias": "suggestions"; "required": false; }; "areSuggestionsLoading": { "alias": "areSuggestionsLoading"; "required": false; "isSignal": true; }; "suggestionsLoadingText": { "alias": "suggestionsLoadingText"; "required": false; "isSignal": true; }; "dropdownAppearance": { "alias": "dropdownAppearance"; "required": false; "isSignal": true; }; "dropdownVariant": { "alias": "dropdownVariant"; "required": false; "isSignal": true; }; }, { "acceptAutocompleteEvent": "acceptAutocomplete"; "acceptSuggestionEvent": "acceptSuggestion"; }, ["prefixTemplate", "suffixTemplate", "placeholderTemplate", "suggestionTemplate", "suggestionLoadingTemplate"], never, false, never>;
+}

package/lib/inputs/autocomplete-input/autocomplete-input.defaults.d.ts

@@ -0,0 +1,18 @@
+import { InjectionToken, Provider, Type } from '@angular/core';
+import { DropdownPanelAppearance, DropdownPanelVariant } from '../../dropdown-panel/dropdown-panel.types';
+import { ArdFormFieldFramePrefixSuffix } from '../../form-field-frame';
+import { Nullable } from '../../types/utility.types';
+import { _SimpleInputComponentDefaults } from '../_simple-input-base';
+export interface ArdAutocompleteInputDefaults extends _SimpleInputComponentDefaults {
+    suggValueFrom: string;
+    suggLabelFrom: string;
+    suggestionsLoadingText: string;
+    charlist: string | undefined;
+    charlistCaseInsensitive: boolean;
+    dropdownAppearance: Nullable<DropdownPanelAppearance>;
+    dropdownVariant: Nullable<DropdownPanelVariant>;
+    PrefixComponent?: Type<ArdFormFieldFramePrefixSuffix>;
+    SuffixComponent?: Type<ArdFormFieldFramePrefixSuffix>;
+}
+export declare const ARD_AUTOCOMPLETE_INPUT_DEFAULTS: InjectionToken<ArdAutocompleteInputDefaults>;
+export declare function provideAutocompleteInputDefaults(config: Partial<ArdAutocompleteInputDefaults>): Provider;

package/lib/inputs/autocomplete-input/autocomplete-input.directives.d.ts

@@ -0,0 +1,34 @@
+import { TemplateRef } from '@angular/core';
+import { FormFieldFrameTemplateContext } from '../../form-field-frame';
+import { ArdSimplestStorageItem, OptionContext } from '../../types/item-storage.types';
+import * as i0 from "@angular/core";
+export declare class ArdAutocompleteInputSuggestionTemplateDirective {
+    template: TemplateRef<OptionContext<ArdSimplestStorageItem>>;
+    constructor(template: TemplateRef<OptionContext<ArdSimplestStorageItem>>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArdAutocompleteInputSuggestionTemplateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ArdAutocompleteInputSuggestionTemplateDirective, "ard-autocomplete-input > ng-template[ard-suggestion-tmp]", never, {}, {}, never, never, false, never>;
+}
+export declare class ArdAutocompleteInputPlaceholderTemplateDirective {
+    template: TemplateRef<undefined>;
+    constructor(template: TemplateRef<undefined>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArdAutocompleteInputPlaceholderTemplateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ArdAutocompleteInputPlaceholderTemplateDirective, "ard-autocomplete-input > ng-template[ard-placeholder-tmp]", never, {}, {}, never, never, false, never>;
+}
+export declare class ArdAutocompleteInputLoadingTemplateDirective {
+    template: TemplateRef<undefined>;
+    constructor(template: TemplateRef<undefined>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArdAutocompleteInputLoadingTemplateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ArdAutocompleteInputLoadingTemplateDirective, "ard-autocomplete-input > ng-template[ard-loading-tmp]", never, {}, {}, never, never, false, never>;
+}
+export declare class ArdAutocompleteInputPrefixTemplateDirective {
+    template: TemplateRef<FormFieldFrameTemplateContext>;
+    constructor(template: TemplateRef<FormFieldFrameTemplateContext>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArdAutocompleteInputPrefixTemplateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ArdAutocompleteInputPrefixTemplateDirective, "ard-autocomplete-input > ng-template[ard-prefix-tmp]", never, {}, {}, never, never, false, never>;
+}
+export declare class ArdAutocompleteInputSuffixTemplateDirective {
+    template: TemplateRef<FormFieldFrameTemplateContext>;
+    constructor(template: TemplateRef<FormFieldFrameTemplateContext>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArdAutocompleteInputSuffixTemplateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ArdAutocompleteInputSuffixTemplateDirective, "ard-autocomplete-input > ng-template[ard-suffix-tmp]", never, {}, {}, never, never, false, never>;
+}

package/lib/inputs/autocomplete-input/autocomplete-input.module.d.ts

@@ -0,0 +1,13 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./autocomplete-input.component";
+import * as i2 from "./autocomplete-input.directives";
+import * as i3 from "@angular/common";
+import * as i4 from "../../form-field-frame/form-field-frame.module";
+import * as i5 from "../../_internal/clear-button/clear-button.module";
+import * as i6 from "../../dropdown-panel/dropdown-panel.module";
+import * as i7 from "@ardium-ui/devkit";
+export declare class ArdiumAutocompleteInputModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArdiumAutocompleteInputModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ArdiumAutocompleteInputModule, [typeof i1.ArdiumAutocompleteInputComponent, typeof i2.ArdAutocompleteInputSuggestionTemplateDirective, typeof i2.ArdAutocompleteInputPlaceholderTemplateDirective, typeof i2.ArdAutocompleteInputLoadingTemplateDirective, typeof i2.ArdAutocompleteInputPrefixTemplateDirective, typeof i2.ArdAutocompleteInputSuffixTemplateDirective], [typeof i3.CommonModule, typeof i4.ArdiumFormFieldFrameModule, typeof i5._ClearButtonModule, typeof i6.ArdiumDropdownPanelModule, typeof i7.ArdiumClickOutsideModule], [typeof i1.ArdiumAutocompleteInputComponent, typeof i2.ArdAutocompleteInputSuggestionTemplateDirective, typeof i2.ArdAutocompleteInputPlaceholderTemplateDirective, typeof i2.ArdAutocompleteInputLoadingTemplateDirective, typeof i2.ArdAutocompleteInputPrefixTemplateDirective, typeof i2.ArdAutocompleteInputSuffixTemplateDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ArdiumAutocompleteInputModule>;
+}

package/lib/inputs/autocomplete-input/index.d.ts

@@ -0,0 +1,4 @@
+export * from './autocomplete-input.component';
+export * from './autocomplete-input.defaults';
+export * from './autocomplete-input.directives';
+export * from './autocomplete-input.module';

package/lib/inputs/date-input/abstract-date-input.d.ts

@@ -0,0 +1,109 @@
+import { ElementRef, InputSignal, OnDestroy, Signal, SimpleChanges, TemplateRef } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+import { BooleanLike, NumberLike } from '@ardium-ui/devkit';
+import { _FormFieldComponentBase } from '../../_internal/form-field-component';
+import { ArdCalendarDaysViewHeaderTemplateDirective, ArdCalendarDayTemplateDirective, ArdCalendarFilterFn, ArdCalendarFloatingMonthTemplateDirective, ArdCalendarMonthsViewHeaderTemplateDirective, ArdCalendarMonthTemplateDirective, ArdCalendarView, ArdCalendarWeekdayTemplateDirective, ArdCalendarYearsViewHeaderTemplateDirective, ArdCalendarYearTemplateDirective } from '../../calendar';
+import { ArdiumDropdownPanelComponent, DropdownPanelAppearance, DropdownPanelVariant } from '../../dropdown-panel';
+import { ComponentColor } from '../../types/colors.types';
+import { FormElementAppearance, FormElementVariant } from '../../types/theming.types';
+import { Nullable } from '../../types/utility.types';
+import { ArdDateInputDefaults } from './date-input.defaults';
+import { ArdDateInputAcceptButtonsTemplateDirective, ArdDateInputCalendarIconTemplateDirective, ArdDateInputValueTemplateDirective } from './date-input.directives';
+import { ArdDateInputAcceptButtonsContext, ArdDateInputSerializeFn, ArdDateInputValueContext } from './date-input.types';
+import * as i0 from "@angular/core";
+export declare abstract class _AbstractDateInput<T, PT = T> extends _FormFieldComponentBase implements OnDestroy, ControlValueAccessor {
+    abstract readonly componentId: string;
+    abstract readonly componentName: string;
+    abstract readonly isRangeSelector: boolean;
+    protected readonly _DEFAULTS: ArdDateInputDefaults;
+    constructor(defaults: ArdDateInputDefaults);
+    private readonly elementRef;
+    private readonly overlay;
+    private readonly viewContainerRef;
+    private readonly scrollStrategyOpts;
+    readonly placeholder: InputSignal<string>;
+    readonly calendarDisabled: import("@angular/core").InputSignalWithTransform<boolean, BooleanLike>;
+    readonly calendarHidden: import("@angular/core").InputSignalWithTransform<boolean, BooleanLike>;
+    abstract readonly serializeFn: InputSignal<ArdDateInputSerializeFn<PT>>;
+    readonly value: import("@angular/core").ModelSignal<PT | null>;
+    abstract writeValue(value: T | null): void;
+    protected _emitChange(): void;
+    protected abstract getValueForEmit(): T | null;
+    readonly isOpen: import("@angular/core").ModelSignal<boolean>;
+    readonly openEvent: import("@angular/core").OutputEmitterRef<void>;
+    readonly closeEvent: import("@angular/core").OutputEmitterRef<void>;
+    abstract readonly shouldDisplayPlaceholder: Signal<boolean>;
+    abstract readonly shouldDisplayValue: Signal<boolean>;
+    abstract readonly shouldDisplayDateInput: Signal<boolean>;
+    readonly appearance: InputSignal<FormElementAppearance>;
+    readonly variant: InputSignal<FormElementVariant>;
+    readonly color: InputSignal<ComponentColor>;
+    readonly compact: import("@angular/core").InputSignalWithTransform<boolean, BooleanLike>;
+    readonly ngClasses: Signal<string>;
+    readonly dropdownAppearance: InputSignal<Nullable<DropdownPanelAppearance>>;
+    readonly dropdownAppearanceOrDefault: Signal<DropdownPanelAppearance>;
+    readonly dropdownVariant: InputSignal<Nullable<DropdownPanelVariant>>;
+    readonly dropdownVariantOrDefault: Signal<DropdownPanelVariant>;
+    readonly activeView: import("@angular/core").ModelSignal<ArdCalendarView>;
+    readonly startView: InputSignal<Nullable<ArdCalendarView>>;
+    readonly activeYear: import("@angular/core").ModelSignal<number>;
+    readonly activeMonth: import("@angular/core").ModelSignal<number>;
+    readonly firstWeekday: import("@angular/core").InputSignalWithTransform<number, NumberLike>;
+    readonly multipleYearPageChangeModifier: import("@angular/core").InputSignalWithTransform<number, NumberLike>;
+    readonly min: import("@angular/core").InputSignalWithTransform<Date | null, any>;
+    readonly max: import("@angular/core").InputSignalWithTransform<Date | null, any>;
+    readonly UTC: import("@angular/core").InputSignalWithTransform<boolean, BooleanLike>;
+    readonly _UTCAfterInit: import("@angular/core").WritableSignal<boolean>;
+    readonly filter: InputSignal<ArdCalendarFilterFn | null>;
+    readonly hideFloatingMonth: import("@angular/core").InputSignalWithTransform<boolean, BooleanLike>;
+    ngOnChanges(changes: SimpleChanges): void;
+    readonly yearSelect: import("@angular/core").OutputEmitterRef<number>;
+    readonly monthSelect: import("@angular/core").OutputEmitterRef<number>;
+    readonly useAcceptButtonToSelect: import("@angular/core").InputSignalWithTransform<boolean, BooleanLike>;
+    private _valueToAccept;
+    onCalendarSelectedChange(value: PT | null): void;
+    private _acceptSelectedDate;
+    private _cancelCalendarSelection;
+    protected abstract _isFullValue(value: PT | T | null): value is T;
+    onAcceptButtonClick(): void;
+    onCancelButtonClick(): void;
+    readonly dropdownHost: Signal<ElementRef<HTMLElement>>;
+    readonly dropdownTemplate: Signal<TemplateRef<any>>;
+    readonly dropdownPanel: Signal<ArdiumDropdownPanelComponent>;
+    private dropdownOverlay?;
+    private _createOverlay;
+    private _destroyOverlay;
+    onGeneralClick(event: MouseEvent): void;
+    onOutsideClick(event: MouseEvent): void;
+    onCalendarButtonClick(event: MouseEvent): void;
+    toggle(): void;
+    open(): void;
+    close(): void;
+    readonly valueTemplate: Signal<ArdDateInputValueTemplateDirective | undefined>;
+    readonly calendarIconTemplate: Signal<ArdDateInputCalendarIconTemplateDirective | undefined>;
+    readonly acceptButtonsTemplate: Signal<ArdDateInputAcceptButtonsTemplateDirective | undefined>;
+    abstract readonly calendarYearsViewHeaderTemplate: Signal<ArdCalendarYearsViewHeaderTemplateDirective | undefined>;
+    abstract readonly calendarMonthsViewHeaderTemplate: Signal<ArdCalendarMonthsViewHeaderTemplateDirective | undefined>;
+    abstract readonly calendarDaysViewHeaderTemplate: Signal<ArdCalendarDaysViewHeaderTemplateDirective | undefined>;
+    abstract readonly calendarWeekdayTemplate: Signal<ArdCalendarWeekdayTemplateDirective | undefined>;
+    abstract readonly calendarFloatingMonthTemplate: Signal<ArdCalendarFloatingMonthTemplateDirective | undefined>;
+    abstract readonly calendarYearTemplate: Signal<ArdCalendarYearTemplateDirective | undefined>;
+    abstract readonly calendarMonthTemplate: Signal<ArdCalendarMonthTemplateDirective | undefined>;
+    abstract readonly calendarDayTemplate: Signal<ArdCalendarDayTemplateDirective | undefined>;
+    readonly calendarDaysViewHeaderDateFormat: InputSignal<string>;
+    readonly calendarYearsViewHeaderDateFormat: InputSignal<string>;
+    readonly calendarMonthsViewHeaderDateFormat: InputSignal<string>;
+    readonly calendarWeekdayDateFormat: InputSignal<string>;
+    readonly calendarWeekdayTitleDateFormat: InputSignal<string>;
+    readonly calendarFloatingMonthDateFormat: InputSignal<string>;
+    readonly calendarFloatingMonthTitleDateFormat: InputSignal<string>;
+    readonly calendarYearDateFormat: InputSignal<string>;
+    readonly calendarMonthDateFormat: InputSignal<string>;
+    readonly calendarDayDateFormat: InputSignal<string>;
+    readonly acceptButtonText: InputSignal<string>;
+    readonly cancelButtonText: InputSignal<string>;
+    readonly valueContext: Signal<ArdDateInputValueContext<PT>>;
+    readonly acceptButtonsContext: Signal<ArdDateInputAcceptButtonsContext>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<_AbstractDateInput<any, any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<_AbstractDateInput<any, any>, never, never, { "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "calendarDisabled": { "alias": "calendarDisabled"; "required": false; "isSignal": true; }; "calendarHidden": { "alias": "calendarHidden"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "isOpen": { "alias": "isOpen"; "required": false; "isSignal": true; }; "appearance": { "alias": "appearance"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "compact": { "alias": "compact"; "required": false; "isSignal": true; }; "dropdownAppearance": { "alias": "dropdownAppearance"; "required": false; "isSignal": true; }; "dropdownVariant": { "alias": "dropdownVariant"; "required": false; "isSignal": true; }; "activeView": { "alias": "activeView"; "required": false; "isSignal": true; }; "startView": { "alias": "startView"; "required": false; "isSignal": true; }; "activeYear": { "alias": "activeYear"; "required": false; "isSignal": true; }; "activeMonth": { "alias": "activeMonth"; "required": false; "isSignal": true; }; "firstWeekday": { "alias": "firstWeekday"; "required": false; "isSignal": true; }; "multipleYearPageChangeModifier": { "alias": "multipleYearPageChangeModifier"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "UTC": { "alias": "UTC"; "required": false; "isSignal": true; }; "filter": { "alias": "filter"; "required": false; "isSignal": true; }; "hideFloatingMonth": { "alias": "hideFloatingMonth"; "required": false; "isSignal": true; }; "useAcceptButtonToSelect": { "alias": "useAcceptButtonToSelect"; "required": false; "isSignal": true; }; "calendarDaysViewHeaderDateFormat": { "alias": "calendarDaysViewHeaderDateFormat"; "required": false; "isSignal": true; }; "calendarYearsViewHeaderDateFormat": { "alias": "calendarYearsViewHeaderDateFormat"; "required": false; "isSignal": true; }; "calendarMonthsViewHeaderDateFormat": { "alias": "calendarMonthsViewHeaderDateFormat"; "required": false; "isSignal": true; }; "calendarWeekdayDateFormat": { "alias": "calendarWeekdayDateFormat"; "required": false; "isSignal": true; }; "calendarWeekdayTitleDateFormat": { "alias": "calendarWeekdayTitleDateFormat"; "required": false; "isSignal": true; }; "calendarFloatingMonthDateFormat": { "alias": "calendarFloatingMonthDateFormat"; "required": false; "isSignal": true; }; "calendarFloatingMonthTitleDateFormat": { "alias": "calendarFloatingMonthTitleDateFormat"; "required": false; "isSignal": true; }; "calendarYearDateFormat": { "alias": "calendarYearDateFormat"; "required": false; "isSignal": true; }; "calendarMonthDateFormat": { "alias": "calendarMonthDateFormat"; "required": false; "isSignal": true; }; "calendarDayDateFormat": { "alias": "calendarDayDateFormat"; "required": false; "isSignal": true; }; "acceptButtonText": { "alias": "acceptButtonText"; "required": false; "isSignal": true; }; "cancelButtonText": { "alias": "cancelButtonText"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "isOpen": "isOpenChange"; "openEvent": "open"; "closeEvent": "close"; "activeView": "activeViewChange"; "activeYear": "activeYearChange"; "activeMonth": "activeMonthChange"; "yearSelect": "yearSelect"; "monthSelect": "monthSelect"; }, ["valueTemplate", "calendarIconTemplate", "acceptButtonsTemplate"], never, true, never>;
+}

package/lib/inputs/date-input/date-input.component.d.ts

@@ -0,0 +1,52 @@
+import { AfterViewInit, ElementRef } from '@angular/core';
+import { BooleanLike } from '@ardium-ui/devkit';
+import { _AbstractDateInput } from './abstract-date-input';
+import { ArdDateInputDefaults } from './date-input.defaults';
+import { ArdDateInputDaysViewHeaderTemplateDirective, ArdDateInputDayTemplateDirective, ArdDateInputFloatingMonthTemplateDirective, ArdDateInputMonthsViewHeaderTemplateDirective, ArdDateInputMonthTemplateDirective, ArdDateInputPrefixTemplateDirective, ArdDateInputSuffixTemplateDirective, ArdDateInputWeekdayTemplateDirective, ArdDateInputYearsViewHeaderTemplateDirective, ArdDateInputYearTemplateDirective } from './date-input.directives';
+import { ArdDateInputDeserializeFn, ArdDateInputMinMaxStrategy, ArdDateInputSerializeFn } from './date-input.types';
+import * as i0 from "@angular/core";
+export declare class ArdiumDateInputComponent extends _AbstractDateInput<Date> implements AfterViewInit {
+    readonly componentId = "008";
+    readonly componentName = "date-input";
+    readonly isRangeSelector = false;
+    protected readonly _DEFAULTS: ArdDateInputDefaults;
+    constructor(defaults: ArdDateInputDefaults);
+    readonly dateInputValue: import("@angular/core").ModelSignal<string>;
+    writeValue(v: Date | null): void;
+    protected _isFullValue(_: Date | null): _ is Date;
+    protected getValueForEmit(): Date | null;
+    readonly dateInput: import("@angular/core").Signal<ElementRef<HTMLInputElement> | undefined>;
+    readonly inputAttrs: import("@angular/core").InputSignal<Record<string, any>>;
+    readonly inputReadOnly: import("@angular/core").InputSignalWithTransform<boolean, BooleanLike>;
+    readonly minMaxStrategy: import("@angular/core").InputSignal<ArdDateInputMinMaxStrategy>;
+    readonly serializeFn: import("@angular/core").InputSignal<ArdDateInputSerializeFn<Date>>;
+    readonly deserializeFn: import("@angular/core").InputSignal<ArdDateInputDeserializeFn<Date>>;
+    readonly isDateInputFocused: import("@angular/core").WritableSignal<boolean>;
+    private readonly _wasDateInputChanged;
+    onDateInputFocus(event: FocusEvent): void;
+    onDateInputBlur(event: FocusEvent): void;
+    onDateInputEnter(event: KeyboardEvent): void;
+    private _processDateInputText;
+    private _setDateInputAttributes;
+    onDateInputInput(event: Event): void;
+    private _serializeValueIntoDateInput;
+    readonly shouldDisplayPlaceholder: import("@angular/core").Signal<boolean>;
+    readonly shouldDisplayValue: import("@angular/core").Signal<boolean>;
+    readonly shouldDisplayDateInput: import("@angular/core").Signal<boolean>;
+    ngAfterViewInit(): void;
+    onGeneralClick(event: MouseEvent): void;
+    readonly prefixTemplate: import("@angular/core").Signal<ArdDateInputPrefixTemplateDirective | undefined>;
+    readonly suffixTemplate: import("@angular/core").Signal<ArdDateInputSuffixTemplateDirective | undefined>;
+    readonly prefixComponent: import("@angular/core").Type<import("@ardium-pl/ui").ArdFormFieldFramePrefixSuffix> | undefined;
+    readonly suffixComponent: import("@angular/core").Type<import("@ardium-pl/ui").ArdFormFieldFramePrefixSuffix> | undefined;
+    readonly calendarDaysViewHeaderTemplate: import("@angular/core").Signal<ArdDateInputDaysViewHeaderTemplateDirective | undefined>;
+    readonly calendarYearsViewHeaderTemplate: import("@angular/core").Signal<ArdDateInputYearsViewHeaderTemplateDirective | undefined>;
+    readonly calendarMonthsViewHeaderTemplate: import("@angular/core").Signal<ArdDateInputMonthsViewHeaderTemplateDirective | undefined>;
+    readonly calendarWeekdayTemplate: import("@angular/core").Signal<ArdDateInputWeekdayTemplateDirective | undefined>;
+    readonly calendarFloatingMonthTemplate: import("@angular/core").Signal<ArdDateInputFloatingMonthTemplateDirective | undefined>;
+    readonly calendarYearTemplate: import("@angular/core").Signal<ArdDateInputYearTemplateDirective | undefined>;
+    readonly calendarMonthTemplate: import("@angular/core").Signal<ArdDateInputMonthTemplateDirective | undefined>;
+    readonly calendarDayTemplate: import("@angular/core").Signal<ArdDateInputDayTemplateDirective | undefined>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArdiumDateInputComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ArdiumDateInputComponent, "ard-date-input", never, { "dateInputValue": { "alias": "dateInputValue"; "required": false; "isSignal": true; }; "inputAttrs": { "alias": "inputAttrs"; "required": false; "isSignal": true; }; "inputReadOnly": { "alias": "inputReadOnly"; "required": false; "isSignal": true; }; "minMaxStrategy": { "alias": "minMaxStrategy"; "required": false; "isSignal": true; }; "serializeFn": { "alias": "serializeFn"; "required": false; "isSignal": true; }; "deserializeFn": { "alias": "deserializeFn"; "required": false; "isSignal": true; }; }, { "dateInputValue": "dateInputValueChange"; }, ["prefixTemplate", "suffixTemplate", "calendarDaysViewHeaderTemplate", "calendarYearsViewHeaderTemplate", "calendarMonthsViewHeaderTemplate", "calendarWeekdayTemplate", "calendarFloatingMonthTemplate", "calendarYearTemplate", "calendarMonthTemplate", "calendarDayTemplate"], never, false, never>;
+}

package/lib/inputs/date-input/date-input.defaults.d.ts

@@ -0,0 +1,54 @@
+import { InjectionToken, Provider, Type } from '@angular/core';
+import { _FormFieldComponentDefaults } from '../../_internal/form-field-component';
+import { ArdCalendarFilterFn, ArdCalendarView, PartialDateRange } from '../../calendar/calendar.types';
+import { DropdownPanelAppearance, DropdownPanelVariant } from '../../dropdown-panel';
+import { ArdFormFieldFramePrefixSuffix } from '../../form-field-frame';
+import { ComponentColor } from '../../types/colors.types';
+import { FormElementAppearance, FormElementVariant } from '../../types/theming.types';
+import { Nullable } from '../../types/utility.types';
+import { ArdDateInputDeserializeFn, ArdDateInputMinMaxStrategy, ArdDateInputSerializeFn } from './date-input.types';
+export interface ArdDateInputDefaults extends _FormFieldComponentDefaults {
+    inputAttrs: Record<string, any>;
+    placeholder: string;
+    serializeFn: ArdDateInputSerializeFn<Date>;
+    rangeSerializeFn: ArdDateInputSerializeFn<PartialDateRange>;
+    deserializeFn: ArdDateInputDeserializeFn<Date>;
+    appearance: FormElementAppearance;
+    variant: FormElementVariant;
+    color: ComponentColor;
+    compact: boolean;
+    dropdownAppearance: DropdownPanelAppearance;
+    dropdownVariant: DropdownPanelVariant;
+    minMaxStrategy: ArdDateInputMinMaxStrategy;
+    startView: Nullable<ArdCalendarView>;
+    inputReadOnly: boolean;
+    calendarDisabled: boolean;
+    calendarHidden: boolean;
+    activeView: ArdCalendarView;
+    activeYear: number;
+    activeMonth: number;
+    firstWeekday: number;
+    multipleYearPageChangeModifier: number;
+    numberOfCalendars: number;
+    min: Date | null;
+    max: Date | null;
+    filter: ArdCalendarFilterFn | null;
+    UTC: boolean;
+    hideFloatingMonth: boolean;
+    calendarDaysViewHeaderDateFormat: string;
+    calendarYearsViewHeaderDateFormat: string;
+    calendarMonthsViewHeaderDateFormat: string;
+    calendarWeekdayDateFormat: string;
+    calendarWeekdayTitleDateFormat: string;
+    calendarFloatingMonthDateFormat: string;
+    calendarFloatingMonthTitleDateFormat: string;
+    calendarYearDateFormat: string;
+    calendarMonthDateFormat: string;
+    calendarDayDateFormat: string;
+    acceptButtonText: string;
+    cancelButtonText: string;
+    PrefixComponent?: Type<ArdFormFieldFramePrefixSuffix>;
+    SuffixComponent?: Type<ArdFormFieldFramePrefixSuffix>;
+}
+export declare const ARD_DATE_INPUT_DEFAULTS: InjectionToken<ArdDateInputDefaults>;
+export declare function provideDateInputDefaults(config: Partial<ArdDateInputDefaults>): Provider;

package/lib/inputs/date-input/date-input.directives.d.ts

@@ -0,0 +1,83 @@
+import { TemplateRef } from '@angular/core';
+import { CalendarDayContext, CalendarDaysViewHeaderContext, CalendarFloatingMonthContext, CalendarMonthContext, CalendarMonthsViewHeaderContext, CalendarWeekdayContext, CalendarYearContext, CalendarYearsViewHeaderContext } from '../../calendar';
+import { FormFieldFrameTemplateContext } from '../../form-field-frame';
+import { ArdDateInputAcceptButtonsContext, ArdDateInputValueContext } from './date-input.types';
+import * as i0 from "@angular/core";
+export declare class ArdDateInputPrefixTemplateDirective {
+    template: TemplateRef<FormFieldFrameTemplateContext>;
+    constructor(template: TemplateRef<FormFieldFrameTemplateContext>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArdDateInputPrefixTemplateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ArdDateInputPrefixTemplateDirective, "ard-date-input > ng-template[ard-prefix-tmp]", never, {}, {}, never, never, false, never>;
+}
+export declare class ArdDateInputSuffixTemplateDirective {
+    template: TemplateRef<FormFieldFrameTemplateContext>;
+    constructor(template: TemplateRef<FormFieldFrameTemplateContext>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArdDateInputSuffixTemplateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ArdDateInputSuffixTemplateDirective, "ard-date-input > ng-template[ard-suffix-tmp]", never, {}, {}, never, never, false, never>;
+}
+export declare class ArdDateInputValueTemplateDirective {
+    template: TemplateRef<ArdDateInputValueContext<Date>>;
+    constructor(template: TemplateRef<ArdDateInputValueContext<Date>>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArdDateInputValueTemplateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ArdDateInputValueTemplateDirective, "ard-date-input > ng-template[ard-value-tmp]", never, {}, {}, never, never, false, never>;
+}
+export declare class ArdDateInputCalendarIconTemplateDirective {
+    template: TemplateRef<undefined>;
+    constructor(template: TemplateRef<undefined>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArdDateInputCalendarIconTemplateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ArdDateInputCalendarIconTemplateDirective, "ard-date-input > ng-template[ard-date-input-icon-tmp]", never, {}, {}, never, never, false, never>;
+}
+export declare class ArdDateInputAcceptButtonsTemplateDirective {
+    template: TemplateRef<ArdDateInputAcceptButtonsContext>;
+    constructor(template: TemplateRef<ArdDateInputAcceptButtonsContext>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArdDateInputAcceptButtonsTemplateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ArdDateInputAcceptButtonsTemplateDirective, "ard-date-input > ng-template[ard-accept-buttons-tmp]", never, {}, {}, never, never, false, never>;
+}
+export declare class ArdDateInputDaysViewHeaderTemplateDirective {
+    template: TemplateRef<CalendarDaysViewHeaderContext>;
+    constructor(template: TemplateRef<CalendarDaysViewHeaderContext>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArdDateInputDaysViewHeaderTemplateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ArdDateInputDaysViewHeaderTemplateDirective, "ard-date-input > ng-template[ard-header-tmp]", never, {}, {}, never, never, false, never>;
+}
+export declare class ArdDateInputYearsViewHeaderTemplateDirective {
+    template: TemplateRef<CalendarYearsViewHeaderContext>;
+    constructor(template: TemplateRef<CalendarYearsViewHeaderContext>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArdDateInputYearsViewHeaderTemplateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ArdDateInputYearsViewHeaderTemplateDirective, "ard-date-input > ng-template[ard-year-picker-header-tmp]", never, {}, {}, never, never, false, never>;
+}
+export declare class ArdDateInputMonthsViewHeaderTemplateDirective {
+    template: TemplateRef<CalendarMonthsViewHeaderContext>;
+    constructor(template: TemplateRef<CalendarMonthsViewHeaderContext>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArdDateInputMonthsViewHeaderTemplateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ArdDateInputMonthsViewHeaderTemplateDirective, "ard-date-input > ng-template[ard-month-picker-header-tmp]", never, {}, {}, never, never, false, never>;
+}
+export declare class ArdDateInputWeekdayTemplateDirective {
+    template: TemplateRef<CalendarWeekdayContext>;
+    constructor(template: TemplateRef<CalendarWeekdayContext>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArdDateInputWeekdayTemplateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ArdDateInputWeekdayTemplateDirective, "ard-date-input > ng-template[ard-weekday-tmp]", never, {}, {}, never, never, false, never>;
+}
+export declare class ArdDateInputFloatingMonthTemplateDirective {
+    template: TemplateRef<CalendarFloatingMonthContext>;
+    constructor(template: TemplateRef<CalendarFloatingMonthContext>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArdDateInputFloatingMonthTemplateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ArdDateInputFloatingMonthTemplateDirective, "ard-date-input > ng-template[ard-floating-month-tmp]", never, {}, {}, never, never, false, never>;
+}
+export declare class ArdDateInputYearTemplateDirective {
+    template: TemplateRef<CalendarYearContext>;
+    constructor(template: TemplateRef<CalendarYearContext>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArdDateInputYearTemplateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ArdDateInputYearTemplateDirective, "ard-date-input > ng-template[ard-year-tmp]", never, {}, {}, never, never, false, never>;
+}
+export declare class ArdDateInputMonthTemplateDirective {
+    template: TemplateRef<CalendarMonthContext>;
+    constructor(template: TemplateRef<CalendarMonthContext>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArdDateInputMonthTemplateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ArdDateInputMonthTemplateDirective, "ard-date-input > ng-template[ard-month-tmp]", never, {}, {}, never, never, false, never>;
+}
+export declare class ArdDateInputDayTemplateDirective {
+    template: TemplateRef<CalendarDayContext>;
+    constructor(template: TemplateRef<CalendarDayContext>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArdDateInputDayTemplateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ArdDateInputDayTemplateDirective, "ard-date-input > ng-template[ard-day-tmp]", never, {}, {}, never, never, false, never>;
+}