npm - @tailng-ui/primitives - Versions diffs - 0.54.0 → 0.56.0 - Mend

@tailng-ui/primitives 0.54.0 → 0.56.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (63) hide show

package/src/lib/form/date-range-picker/tng-date-range-picker.parts.d.ts ADDED Viewed

@@ -0,0 +1,3155 @@
+import { Injector, type OnInit, type Signal } from '@angular/core';
+import type { TngDateRangePickerAttributeMap, TngDateRangePickerController, TngDateRangePickerOutputs } from './date-range-picker.types';
+import * as i0 from "@angular/core";
+type TngDateRangePickerControllerLike = TngDateRangePickerController<any>;
+export type TngBoundDateRangePicker<TDate> = Readonly<{
+    outputs: Signal<TngDateRangePickerOutputs<TDate>>;
+    periodLabel: Signal<string>;
+}>;
+export declare function resolveTngDateRangePickerPeriodLabel<TDate>(controller: TngDateRangePickerController<TDate>, outputs: TngDateRangePickerOutputs<TDate>): string;
+export declare function bindTngDateRangePicker<TDate>(controller: TngDateRangePickerController<TDate>): TngBoundDateRangePicker<TDate>;
+declare abstract class TngDateRangePickerControllerPart implements OnInit {
+    protected readonly injector: Injector;
+    protected readonly ownerDocument: any;
+    protected readonly renderVersion: import("@angular/core").WritableSignal<number>;
+    abstract readonly controller: Signal<TngDateRangePickerControllerLike>;
+    ngOnInit(): void;
+    protected syncOverlayFocus(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TngDateRangePickerControllerPart, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TngDateRangePickerControllerPart, never, never, {}, {}, never, never, true, never>;
+}
+export declare class TngDateRangePickerHost extends TngDateRangePickerControllerPart {
+    readonly controller: import("@angular/core").InputSignal<Readonly<{
+        clear: () => void;
+        close: (reason?: import("./date-range-picker.types").TngDateRangePickerCloseReason) => void;
+        commitInputText: () => boolean;
+        destroy: () => void;
+        formatDate: (date: any, format?: import("./date-range-picker.types").TngDateFormatToken | string) => string;
+        getOutputs: () => Readonly<{
+            activeDate: any;
+            cells: readonly Readonly<{
+                active: boolean;
+                colIndex: number;
+                date: any;
+                disabled: boolean;
+                focusVisible: boolean;
+                hidden: boolean;
+                id: string;
+                inMonth: boolean;
+                inRange: boolean;
+                label: string;
+                previewRange: boolean;
+                rangeEnd: boolean;
+                rangeStart: boolean;
+                rowIndex: number;
+                selected: boolean;
+                tabindex: -1 | 0;
+                today: boolean;
+            }>[];
+            endDate: any;
+            focusedDate: any;
+            focusedSection: import("./date-range-picker.types").TngDateRangePickerFocusedSection;
+            getCellAttributes: (cellOrDate: any) => TngDateRangePickerAttributeMap;
+            getGridAttributes: () => TngDateRangePickerAttributeMap;
+            getHostAttributes: () => TngDateRangePickerAttributeMap;
+            getMonthAttributes: (monthOrOption: number | Readonly<Readonly<{
+                active: boolean;
+                date: any;
+                disabled: boolean;
+                focusVisible: boolean;
+                id: string;
+                index: number;
+                label: string;
+                selected: boolean;
+                tabindex: -1 | 0;
+            }>>) => TngDateRangePickerAttributeMap;
+            getOverlayAttributes: () => TngDateRangePickerAttributeMap;
+            getTriggerAttributes: () => TngDateRangePickerAttributeMap;
+            getYearAttributes: (yearOrOption: number | Readonly<Readonly<{
+                active: boolean;
+                date: any;
+                disabled: boolean;
+                focusVisible: boolean;
+                id: string;
+                label: string;
+                selected: boolean;
+                tabindex: -1 | 0;
+                year: number;
+            }>>) => TngDateRangePickerAttributeMap;
+            inputText: string;
+            labelMonthYear: string;
+            layout: Readonly<{
+                mode: import("./date-range-picker.types").TngDateRangePickerOverlayMode;
+                offsetX: number;
+                width: number;
+            }>;
+            monthOptions: readonly Readonly<{
+                active: boolean;
+                date: any;
+                disabled: boolean;
+                focusVisible: boolean;
+                id: string;
+                index: number;
+                label: string;
+                selected: boolean;
+                tabindex: -1 | 0;
+            }>[];
+            open: boolean;
+            previewEndDate: any;
+            startDate: any;
+            validationError: string | null;
+            value: import("./date-range-picker.types").TngDateValue<any>;
+            view: import("./date-range-picker.types").TngCalendarView;
+            visibleMonth: any;
+            weekdayLabels: readonly string[];
+            yearOptions: readonly Readonly<{
+                active: boolean;
+                date: any;
+                disabled: boolean;
+                focusVisible: boolean;
+                id: string;
+                label: string;
+                selected: boolean;
+                tabindex: -1 | 0;
+                year: number;
+            }>[];
+        }>;
+        getState: () => Readonly<{
+            activeDate: any;
+            disabled: boolean;
+            endDate: any;
+            focusedDate: any;
+            focusedSection: import("./date-range-picker.types").TngDateRangePickerFocusedSection;
+            inputText: string;
+            lastCloseReason: import("./date-range-picker.types").TngDateRangePickerCloseReason | null;
+            open: boolean;
+            previewEndDate: any;
+            startDate: any;
+            validationError: string | null;
+            value: import("./date-range-picker.types").TngDateValue<any>;
+            view: import("./date-range-picker.types").TngCalendarView;
+            visibleMonth: any;
+        }>;
+        goToNextMonth: () => void;
+        goToPrevMonth: () => void;
+        handleCellClick: (date: any, options?: Readonly<{
+            shiftKey?: boolean;
+        }>) => void;
+        handleCellPointerEnter: (date: any) => void;
+        handleGridKeyDown: (event: Readonly<Pick<KeyboardEvent, "altKey" | "ctrlKey" | "key" | "metaKey" | "preventDefault" | "shiftKey">>) => void;
+        handleMonthGridKeyDown: (event: Readonly<Pick<KeyboardEvent, "altKey" | "ctrlKey" | "key" | "metaKey" | "preventDefault" | "shiftKey">>) => void;
+        handleOverlayKeyDown: (event: Readonly<Pick<KeyboardEvent, "altKey" | "ctrlKey" | "key" | "metaKey" | "preventDefault" | "shiftKey">>) => void;
+        handleTriggerKeyDown: (event: Readonly<Pick<KeyboardEvent, "key" | "preventDefault">>) => void;
+        handleYearGridKeyDown: (event: Readonly<Pick<KeyboardEvent, "altKey" | "ctrlKey" | "key" | "metaKey" | "preventDefault" | "shiftKey">>) => void;
+        nextMonth: () => void;
+        nextYear: () => void;
+        open: () => void;
+        parseInputText: (text: string) => any;
+        prevMonth: () => void;
+        prevYear: () => void;
+        registerOverlay: (element: HTMLElement | null) => void;
+        registerTrigger: (element: HTMLElement | null) => void;
+        selectDate: (date: any, options?: Readonly<{
+            shiftKey?: boolean;
+            trigger?: import("./date-range-picker.types").TngDateRangePickerTrigger;
+        }>) => void;
+        selectMonth: (monthIndex: number) => void;
+        selectYear: (year: number) => void;
+        setActiveDate: (date: any, trigger?: import("./date-range-picker.types").TngDateRangePickerTrigger) => void;
+        setConfig: (config: Partial<Readonly<{
+            adapter?: Readonly<{
+                addDays: (date: any, amount: number) => any;
+                addMonths: (date: any, amount: number) => any;
+                addYears: (date: any, amount: number) => any;
+                compare: (left: any, right: any) => -1 | 0 | 1;
+                createDate: (year: number, month: number, day: number) => any;
+                deserialize?: ((value: unknown, locale?: string) => any) | undefined;
+                endOfMonth: (date: any) => any;
+                format: (date: any, format: import("./date-range-picker.types").TngDateFormatToken | string, locale?: string) => string;
+                getDate: (date: any) => number;
+                getDay: (date: any) => number;
+                getMonth: (date: any) => number;
+                getYear: (date: any) => number;
+                isValid: (date: any) => boolean;
+                parse: (text: string, locale?: string) => any;
+                startOfMonth: (date: any) => any;
+                startOfWeek: (date: any, weekStartsOn: import("./date-range-picker.types").TngWeekdayIndex) => any;
+                today: () => any;
+            }> | undefined;
+            allowManualInput?: boolean;
+            ariaDescribedBy?: string | null;
+            ariaLabel?: string | null;
+            ariaLabelledBy?: string | null;
+            autoCommitView?: boolean;
+            closeOnEscape?: boolean;
+            closeOnOutsideClick?: boolean;
+            closeOnSelect?: boolean;
+            closeOthersOnOpen?: boolean;
+            defaultOpen?: boolean;
+            direction?: import("./date-range-picker.types").TngDateRangePickerDirection;
+            disableDate?: ((date: any) => boolean) | undefined;
+            disabled?: boolean;
+            enableRangeSelection?: boolean;
+            enableTypeahead?: boolean;
+            fixedWeeks?: boolean;
+            focusStrategy?: import("./date-range-picker.types").TngDateRangePickerFocusStrategy;
+            id?: string;
+            initialView?: import("./date-range-picker.types").TngCalendarView;
+            locale?: string;
+            max?: any;
+            maxDate?: any;
+            min?: any;
+            minDate?: any;
+            onPartialInputCommit?: boolean;
+            overlayMode?: import("./date-range-picker.types").TngDateRangePickerOverlayMode;
+            overlayRuntime?: Readonly<{
+                clearLayers: () => void;
+                dispatchKeydown: (event: Readonly<Readonly<{
+                    defaultPrevented?: boolean;
+                    key: string;
+                    preventDefault?: () => void;
+                }>>) => void;
+                dispatchPointerDown: (event: Readonly<Readonly<{
+                    composedPath?: () => readonly unknown[];
+                    defaultPrevented?: boolean;
+                    preventDefault?: () => void;
+                    target: unknown;
+                }>>) => void;
+                dismissById: (id: string, reason: import("@tailng-ui/cdk").TngOverlayDismissReason) => void;
+                getLayerIds: () => readonly string[];
+                isTopLayer: (id: string) => boolean;
+                registerLayer: (layer: Readonly<{
+                    containsTarget?: (target: unknown, path: readonly unknown[]) => boolean;
+                    dismissOnEscape?: boolean;
+                    dismissOnOutsidePointer?: boolean;
+                    id: string;
+                    modal?: boolean;
+                    onDismiss: (reason: import("@tailng-ui/cdk").TngOverlayDismissReason) => void;
+                    priority?: number;
+                }>) => void;
+                unregisterLayer: (id: string) => void;
+            }> | null | undefined;
+            overlaySize?: number;
+            ownerDocument?: Document | null;
+            position?: import("./date-range-picker.types").TngDateRangePickerPosition;
+            preserveViewOnOpenClose?: boolean;
+            restoreFocus?: boolean;
+            showOutsideDays?: boolean;
+            skipDisabled?: boolean;
+            today?: any;
+            trapFocus?: boolean;
+            value?: any;
+            weekStartsOn?: import("./date-range-picker.types").TngWeekdayIndex;
+            yearPageSize?: number;
+        }>>) => void;
+        setDisabled: (disabled: boolean) => void;
+        setFocusedSection: (section: import("./date-range-picker.types").TngDateRangePickerFocusedSection) => void;
+        setInputText: (text: string) => void;
+        setOpen: (open: boolean) => void;
+        setState: (patch: Readonly<{
+            activeDate?: any;
+            disabled?: boolean;
+            inputText?: string;
+            value?: any;
+            view?: import("./date-range-picker.types").TngCalendarView;
+            visibleMonth?: any;
+        }>) => void;
+        setValue: (value: any) => void;
+        setView: (view: import("./date-range-picker.types").TngCalendarView) => void;
+        setVisibleMonth: (valueOrYear: any, month?: number) => void;
+        setVisibleYear: (year: number) => void;
+        showDaysPanel: () => void;
+        showMonthsPanel: () => void;
+        showYearsPanel: () => void;
+        subscribe: (listener: import("./date-range-picker.types").TngDateRangePickerListener<any>) => () => void;
+        toggleOpen: () => void;
+    }>>;
+    private readonly attributes;
+    protected get ariaDescribedby(): string | null;
+    protected get ariaLabel(): string | null;
+    protected get ariaLabelledby(): string | null;
+    protected get dataDisabled(): string | null;
+    protected get dataOpen(): string | null;
+    protected get dataSlot(): string | null;
+    protected get dataView(): string | null;
+    protected get dir(): string | null;
+    protected get role(): string | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TngDateRangePickerHost, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TngDateRangePickerHost, "[tngDateRangePickerHost]", ["tngDateRangePickerHost"], { "controller": { "alias": "tngDateRangePickerHost"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+export declare class TngDateRangePickerInput extends TngDateRangePickerControllerPart {
+    private readonly inputElement;
+    readonly controller: import("@angular/core").InputSignal<Readonly<{
+        clear: () => void;
+        close: (reason?: import("./date-range-picker.types").TngDateRangePickerCloseReason) => void;
+        commitInputText: () => boolean;
+        destroy: () => void;
+        formatDate: (date: any, format?: import("./date-range-picker.types").TngDateFormatToken | string) => string;
+        getOutputs: () => Readonly<{
+            activeDate: any;
+            cells: readonly Readonly<{
+                active: boolean;
+                colIndex: number;
+                date: any;
+                disabled: boolean;
+                focusVisible: boolean;
+                hidden: boolean;
+                id: string;
+                inMonth: boolean;
+                inRange: boolean;
+                label: string;
+                previewRange: boolean;
+                rangeEnd: boolean;
+                rangeStart: boolean;
+                rowIndex: number;
+                selected: boolean;
+                tabindex: -1 | 0;
+                today: boolean;
+            }>[];
+            endDate: any;
+            focusedDate: any;
+            focusedSection: import("./date-range-picker.types").TngDateRangePickerFocusedSection;
+            getCellAttributes: (cellOrDate: any) => TngDateRangePickerAttributeMap;
+            getGridAttributes: () => TngDateRangePickerAttributeMap;
+            getHostAttributes: () => TngDateRangePickerAttributeMap;
+            getMonthAttributes: (monthOrOption: number | Readonly<Readonly<{
+                active: boolean;
+                date: any;
+                disabled: boolean;
+                focusVisible: boolean;
+                id: string;
+                index: number;
+                label: string;
+                selected: boolean;
+                tabindex: -1 | 0;
+            }>>) => TngDateRangePickerAttributeMap;
+            getOverlayAttributes: () => TngDateRangePickerAttributeMap;
+            getTriggerAttributes: () => TngDateRangePickerAttributeMap;
+            getYearAttributes: (yearOrOption: number | Readonly<Readonly<{
+                active: boolean;
+                date: any;
+                disabled: boolean;
+                focusVisible: boolean;
+                id: string;
+                label: string;
+                selected: boolean;
+                tabindex: -1 | 0;
+                year: number;
+            }>>) => TngDateRangePickerAttributeMap;
+            inputText: string;
+            labelMonthYear: string;
+            layout: Readonly<{
+                mode: import("./date-range-picker.types").TngDateRangePickerOverlayMode;
+                offsetX: number;
+                width: number;
+            }>;
+            monthOptions: readonly Readonly<{
+                active: boolean;
+                date: any;
+                disabled: boolean;
+                focusVisible: boolean;
+                id: string;
+                index: number;
+                label: string;
+                selected: boolean;
+                tabindex: -1 | 0;
+            }>[];
+            open: boolean;
+            previewEndDate: any;
+            startDate: any;
+            validationError: string | null;
+            value: import("./date-range-picker.types").TngDateValue<any>;
+            view: import("./date-range-picker.types").TngCalendarView;
+            visibleMonth: any;
+            weekdayLabels: readonly string[];
+            yearOptions: readonly Readonly<{
+                active: boolean;
+                date: any;
+                disabled: boolean;
+                focusVisible: boolean;
+                id: string;
+                label: string;
+                selected: boolean;
+                tabindex: -1 | 0;
+                year: number;
+            }>[];
+        }>;
+        getState: () => Readonly<{
+            activeDate: any;
+            disabled: boolean;
+            endDate: any;
+            focusedDate: any;
+            focusedSection: import("./date-range-picker.types").TngDateRangePickerFocusedSection;
+            inputText: string;
+            lastCloseReason: import("./date-range-picker.types").TngDateRangePickerCloseReason | null;
+            open: boolean;
+            previewEndDate: any;
+            startDate: any;
+            validationError: string | null;
+            value: import("./date-range-picker.types").TngDateValue<any>;
+            view: import("./date-range-picker.types").TngCalendarView;
+            visibleMonth: any;
+        }>;
+        goToNextMonth: () => void;
+        goToPrevMonth: () => void;
+        handleCellClick: (date: any, options?: Readonly<{
+            shiftKey?: boolean;
+        }>) => void;
+        handleCellPointerEnter: (date: any) => void;
+        handleGridKeyDown: (event: Readonly<Pick<KeyboardEvent, "altKey" | "ctrlKey" | "key" | "metaKey" | "preventDefault" | "shiftKey">>) => void;
+        handleMonthGridKeyDown: (event: Readonly<Pick<KeyboardEvent, "altKey" | "ctrlKey" | "key" | "metaKey" | "preventDefault" | "shiftKey">>) => void;
+        handleOverlayKeyDown: (event: Readonly<Pick<KeyboardEvent, "altKey" | "ctrlKey" | "key" | "metaKey" | "preventDefault" | "shiftKey">>) => void;
+        handleTriggerKeyDown: (event: Readonly<Pick<KeyboardEvent, "key" | "preventDefault">>) => void;
+        handleYearGridKeyDown: (event: Readonly<Pick<KeyboardEvent, "altKey" | "ctrlKey" | "key" | "metaKey" | "preventDefault" | "shiftKey">>) => void;
+        nextMonth: () => void;
+        nextYear: () => void;
+        open: () => void;
+        parseInputText: (text: string) => any;
+        prevMonth: () => void;
+        prevYear: () => void;
+        registerOverlay: (element: HTMLElement | null) => void;
+        registerTrigger: (element: HTMLElement | null) => void;
+        selectDate: (date: any, options?: Readonly<{
+            shiftKey?: boolean;
+            trigger?: import("./date-range-picker.types").TngDateRangePickerTrigger;
+        }>) => void;
+        selectMonth: (monthIndex: number) => void;
+        selectYear: (year: number) => void;
+        setActiveDate: (date: any, trigger?: import("./date-range-picker.types").TngDateRangePickerTrigger) => void;
+        setConfig: (config: Partial<Readonly<{
+            adapter?: Readonly<{
+                addDays: (date: any, amount: number) => any;
+                addMonths: (date: any, amount: number) => any;
+                addYears: (date: any, amount: number) => any;
+                compare: (left: any, right: any) => -1 | 0 | 1;
+                createDate: (year: number, month: number, day: number) => any;
+                deserialize?: ((value: unknown, locale?: string) => any) | undefined;
+                endOfMonth: (date: any) => any;
+                format: (date: any, format: import("./date-range-picker.types").TngDateFormatToken | string, locale?: string) => string;
+                getDate: (date: any) => number;
+                getDay: (date: any) => number;
+                getMonth: (date: any) => number;
+                getYear: (date: any) => number;
+                isValid: (date: any) => boolean;
+                parse: (text: string, locale?: string) => any;
+                startOfMonth: (date: any) => any;
+                startOfWeek: (date: any, weekStartsOn: import("./date-range-picker.types").TngWeekdayIndex) => any;
+                today: () => any;
+            }> | undefined;
+            allowManualInput?: boolean;
+            ariaDescribedBy?: string | null;
+            ariaLabel?: string | null;
+            ariaLabelledBy?: string | null;
+            autoCommitView?: boolean;
+            closeOnEscape?: boolean;
+            closeOnOutsideClick?: boolean;
+            closeOnSelect?: boolean;
+            closeOthersOnOpen?: boolean;
+            defaultOpen?: boolean;
+            direction?: import("./date-range-picker.types").TngDateRangePickerDirection;
+            disableDate?: ((date: any) => boolean) | undefined;
+            disabled?: boolean;
+            enableRangeSelection?: boolean;
+            enableTypeahead?: boolean;
+            fixedWeeks?: boolean;
+            focusStrategy?: import("./date-range-picker.types").TngDateRangePickerFocusStrategy;
+            id?: string;
+            initialView?: import("./date-range-picker.types").TngCalendarView;
+            locale?: string;
+            max?: any;
+            maxDate?: any;
+            min?: any;
+            minDate?: any;
+            onPartialInputCommit?: boolean;
+            overlayMode?: import("./date-range-picker.types").TngDateRangePickerOverlayMode;
+            overlayRuntime?: Readonly<{
+                clearLayers: () => void;
+                dispatchKeydown: (event: Readonly<Readonly<{
+                    defaultPrevented?: boolean;
+                    key: string;
+                    preventDefault?: () => void;
+                }>>) => void;
+                dispatchPointerDown: (event: Readonly<Readonly<{
+                    composedPath?: () => readonly unknown[];
+                    defaultPrevented?: boolean;
+                    preventDefault?: () => void;
+                    target: unknown;
+                }>>) => void;
+                dismissById: (id: string, reason: import("@tailng-ui/cdk").TngOverlayDismissReason) => void;
+                getLayerIds: () => readonly string[];
+                isTopLayer: (id: string) => boolean;
+                registerLayer: (layer: Readonly<{
+                    containsTarget?: (target: unknown, path: readonly unknown[]) => boolean;
+                    dismissOnEscape?: boolean;
+                    dismissOnOutsidePointer?: boolean;
+                    id: string;
+                    modal?: boolean;
+                    onDismiss: (reason: import("@tailng-ui/cdk").TngOverlayDismissReason) => void;
+                    priority?: number;
+                }>) => void;
+                unregisterLayer: (id: string) => void;
+            }> | null | undefined;
+            overlaySize?: number;
+            ownerDocument?: Document | null;
+            position?: import("./date-range-picker.types").TngDateRangePickerPosition;
+            preserveViewOnOpenClose?: boolean;
+            restoreFocus?: boolean;
+            showOutsideDays?: boolean;
+            skipDisabled?: boolean;
+            today?: any;
+            trapFocus?: boolean;
+            value?: any;
+            weekStartsOn?: import("./date-range-picker.types").TngWeekdayIndex;
+            yearPageSize?: number;
+        }>>) => void;
+        setDisabled: (disabled: boolean) => void;
+        setFocusedSection: (section: import("./date-range-picker.types").TngDateRangePickerFocusedSection) => void;
+        setInputText: (text: string) => void;
+        setOpen: (open: boolean) => void;
+        setState: (patch: Readonly<{
+            activeDate?: any;
+            disabled?: boolean;
+            inputText?: string;
+            value?: any;
+            view?: import("./date-range-picker.types").TngCalendarView;
+            visibleMonth?: any;
+        }>) => void;
+        setValue: (value: any) => void;
+        setView: (view: import("./date-range-picker.types").TngCalendarView) => void;
+        setVisibleMonth: (valueOrYear: any, month?: number) => void;
+        setVisibleYear: (year: number) => void;
+        showDaysPanel: () => void;
+        showMonthsPanel: () => void;
+        showYearsPanel: () => void;
+        subscribe: (listener: import("./date-range-picker.types").TngDateRangePickerListener<any>) => () => void;
+        toggleOpen: () => void;
+    }>>;
+    protected readonly dataSlot: "date-range-picker-input";
+    protected get valueProp(): string;
+    protected get ariaInvalid(): 'true' | null;
+    protected onBlur(): void;
+    protected onInput(): void;
+    protected onClick(): void;
+    protected onKeydown(event: KeyboardEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TngDateRangePickerInput, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TngDateRangePickerInput, "input[tngDateRangePickerInput]", ["tngDateRangePickerInput"], { "controller": { "alias": "tngDateRangePickerInput"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+export declare class TngDateRangePickerTrigger extends TngDateRangePickerControllerPart {
+    private readonly elementRef;
+    readonly controller: import("@angular/core").InputSignal<Readonly<{
+        clear: () => void;
+        close: (reason?: import("./date-range-picker.types").TngDateRangePickerCloseReason) => void;
+        commitInputText: () => boolean;
+        destroy: () => void;
+        formatDate: (date: any, format?: import("./date-range-picker.types").TngDateFormatToken | string) => string;
+        getOutputs: () => Readonly<{
+            activeDate: any;
+            cells: readonly Readonly<{
+                active: boolean;
+                colIndex: number;
+                date: any;
+                disabled: boolean;
+                focusVisible: boolean;
+                hidden: boolean;
+                id: string;
+                inMonth: boolean;
+                inRange: boolean;
+                label: string;
+                previewRange: boolean;
+                rangeEnd: boolean;
+                rangeStart: boolean;
+                rowIndex: number;
+                selected: boolean;
+                tabindex: -1 | 0;
+                today: boolean;
+            }>[];
+            endDate: any;
+            focusedDate: any;
+            focusedSection: import("./date-range-picker.types").TngDateRangePickerFocusedSection;
+            getCellAttributes: (cellOrDate: any) => TngDateRangePickerAttributeMap;
+            getGridAttributes: () => TngDateRangePickerAttributeMap;
+            getHostAttributes: () => TngDateRangePickerAttributeMap;
+            getMonthAttributes: (monthOrOption: number | Readonly<Readonly<{
+                active: boolean;
+                date: any;
+                disabled: boolean;
+                focusVisible: boolean;
+                id: string;
+                index: number;
+                label: string;
+                selected: boolean;
+                tabindex: -1 | 0;
+            }>>) => TngDateRangePickerAttributeMap;
+            getOverlayAttributes: () => TngDateRangePickerAttributeMap;
+            getTriggerAttributes: () => TngDateRangePickerAttributeMap;
+            getYearAttributes: (yearOrOption: number | Readonly<Readonly<{
+                active: boolean;
+                date: any;
+                disabled: boolean;
+                focusVisible: boolean;
+                id: string;
+                label: string;
+                selected: boolean;
+                tabindex: -1 | 0;
+                year: number;
+            }>>) => TngDateRangePickerAttributeMap;
+            inputText: string;
+            labelMonthYear: string;
+            layout: Readonly<{
+                mode: import("./date-range-picker.types").TngDateRangePickerOverlayMode;
+                offsetX: number;
+                width: number;
+            }>;
+            monthOptions: readonly Readonly<{
+                active: boolean;
+                date: any;
+                disabled: boolean;
+                focusVisible: boolean;
+                id: string;
+                index: number;
+                label: string;
+                selected: boolean;
+                tabindex: -1 | 0;
+            }>[];
+            open: boolean;
+            previewEndDate: any;
+            startDate: any;
+            validationError: string | null;
+            value: import("./date-range-picker.types").TngDateValue<any>;
+            view: import("./date-range-picker.types").TngCalendarView;
+            visibleMonth: any;
+            weekdayLabels: readonly string[];
+            yearOptions: readonly Readonly<{
+                active: boolean;
+                date: any;
+                disabled: boolean;
+                focusVisible: boolean;
+                id: string;
+                label: string;
+                selected: boolean;
+                tabindex: -1 | 0;
+                year: number;
+            }>[];
+        }>;
+        getState: () => Readonly<{
+            activeDate: any;
+            disabled: boolean;
+            endDate: any;
+            focusedDate: any;
+            focusedSection: import("./date-range-picker.types").TngDateRangePickerFocusedSection;
+            inputText: string;
+            lastCloseReason: import("./date-range-picker.types").TngDateRangePickerCloseReason | null;
+            open: boolean;
+            previewEndDate: any;
+            startDate: any;
+            validationError: string | null;
+            value: import("./date-range-picker.types").TngDateValue<any>;
+            view: import("./date-range-picker.types").TngCalendarView;
+            visibleMonth: any;
+        }>;
+        goToNextMonth: () => void;
+        goToPrevMonth: () => void;
+        handleCellClick: (date: any, options?: Readonly<{
+            shiftKey?: boolean;
+        }>) => void;
+        handleCellPointerEnter: (date: any) => void;
+        handleGridKeyDown: (event: Readonly<Pick<KeyboardEvent, "altKey" | "ctrlKey" | "key" | "metaKey" | "preventDefault" | "shiftKey">>) => void;
+        handleMonthGridKeyDown: (event: Readonly<Pick<KeyboardEvent, "altKey" | "ctrlKey" | "key" | "metaKey" | "preventDefault" | "shiftKey">>) => void;
+        handleOverlayKeyDown: (event: Readonly<Pick<KeyboardEvent, "altKey" | "ctrlKey" | "key" | "metaKey" | "preventDefault" | "shiftKey">>) => void;
+        handleTriggerKeyDown: (event: Readonly<Pick<KeyboardEvent, "key" | "preventDefault">>) => void;
+        handleYearGridKeyDown: (event: Readonly<Pick<KeyboardEvent, "altKey" | "ctrlKey" | "key" | "metaKey" | "preventDefault" | "shiftKey">>) => void;
+        nextMonth: () => void;
+        nextYear: () => void;
+        open: () => void;
+        parseInputText: (text: string) => any;
+        prevMonth: () => void;
+        prevYear: () => void;
+        registerOverlay: (element: HTMLElement | null) => void;
+        registerTrigger: (element: HTMLElement | null) => void;
+        selectDate: (date: any, options?: Readonly<{
+            shiftKey?: boolean;
+            trigger?: import("./date-range-picker.types").TngDateRangePickerTrigger;
+        }>) => void;
+        selectMonth: (monthIndex: number) => void;
+        selectYear: (year: number) => void;
+        setActiveDate: (date: any, trigger?: import("./date-range-picker.types").TngDateRangePickerTrigger) => void;
+        setConfig: (config: Partial<Readonly<{
+            adapter?: Readonly<{
+                addDays: (date: any, amount: number) => any;
+                addMonths: (date: any, amount: number) => any;
+                addYears: (date: any, amount: number) => any;
+                compare: (left: any, right: any) => -1 | 0 | 1;
+                createDate: (year: number, month: number, day: number) => any;
+                deserialize?: ((value: unknown, locale?: string) => any) | undefined;
+                endOfMonth: (date: any) => any;
+                format: (date: any, format: import("./date-range-picker.types").TngDateFormatToken | string, locale?: string) => string;
+                getDate: (date: any) => number;
+                getDay: (date: any) => number;
+                getMonth: (date: any) => number;
+                getYear: (date: any) => number;
+                isValid: (date: any) => boolean;
+                parse: (text: string, locale?: string) => any;
+                startOfMonth: (date: any) => any;
+                startOfWeek: (date: any, weekStartsOn: import("./date-range-picker.types").TngWeekdayIndex) => any;
+                today: () => any;
+            }> | undefined;
+            allowManualInput?: boolean;
+            ariaDescribedBy?: string | null;
+            ariaLabel?: string | null;
+            ariaLabelledBy?: string | null;
+            autoCommitView?: boolean;
+            closeOnEscape?: boolean;
+            closeOnOutsideClick?: boolean;
+            closeOnSelect?: boolean;
+            closeOthersOnOpen?: boolean;
+            defaultOpen?: boolean;
+            direction?: import("./date-range-picker.types").TngDateRangePickerDirection;
+            disableDate?: ((date: any) => boolean) | undefined;
+            disabled?: boolean;
+            enableRangeSelection?: boolean;
+            enableTypeahead?: boolean;
+            fixedWeeks?: boolean;
+            focusStrategy?: import("./date-range-picker.types").TngDateRangePickerFocusStrategy;
+            id?: string;
+            initialView?: import("./date-range-picker.types").TngCalendarView;
+            locale?: string;
+            max?: any;
+            maxDate?: any;
+            min?: any;
+            minDate?: any;
+            onPartialInputCommit?: boolean;
+            overlayMode?: import("./date-range-picker.types").TngDateRangePickerOverlayMode;
+            overlayRuntime?: Readonly<{
+                clearLayers: () => void;
+                dispatchKeydown: (event: Readonly<Readonly<{
+                    defaultPrevented?: boolean;
+                    key: string;
+                    preventDefault?: () => void;
+                }>>) => void;
+                dispatchPointerDown: (event: Readonly<Readonly<{
+                    composedPath?: () => readonly unknown[];
+                    defaultPrevented?: boolean;
+                    preventDefault?: () => void;
+                    target: unknown;
+                }>>) => void;
+                dismissById: (id: string, reason: import("@tailng-ui/cdk").TngOverlayDismissReason) => void;
+                getLayerIds: () => readonly string[];
+                isTopLayer: (id: string) => boolean;
+                registerLayer: (layer: Readonly<{
+                    containsTarget?: (target: unknown, path: readonly unknown[]) => boolean;
+                    dismissOnEscape?: boolean;
+                    dismissOnOutsidePointer?: boolean;
+                    id: string;
+                    modal?: boolean;
+                    onDismiss: (reason: import("@tailng-ui/cdk").TngOverlayDismissReason) => void;
+                    priority?: number;
+                }>) => void;
+                unregisterLayer: (id: string) => void;
+            }> | null | undefined;
+            overlaySize?: number;
+            ownerDocument?: Document | null;
+            position?: import("./date-range-picker.types").TngDateRangePickerPosition;
+            preserveViewOnOpenClose?: boolean;
+            restoreFocus?: boolean;
+            showOutsideDays?: boolean;
+            skipDisabled?: boolean;
+            today?: any;
+            trapFocus?: boolean;
+            value?: any;
+            weekStartsOn?: import("./date-range-picker.types").TngWeekdayIndex;
+            yearPageSize?: number;
+        }>>) => void;
+        setDisabled: (disabled: boolean) => void;
+        setFocusedSection: (section: import("./date-range-picker.types").TngDateRangePickerFocusedSection) => void;
+        setInputText: (text: string) => void;
+        setOpen: (open: boolean) => void;
+        setState: (patch: Readonly<{
+            activeDate?: any;
+            disabled?: boolean;
+            inputText?: string;
+            value?: any;
+            view?: import("./date-range-picker.types").TngCalendarView;
+            visibleMonth?: any;
+        }>) => void;
+        setValue: (value: any) => void;
+        setView: (view: import("./date-range-picker.types").TngCalendarView) => void;
+        setVisibleMonth: (valueOrYear: any, month?: number) => void;
+        setVisibleYear: (year: number) => void;
+        showDaysPanel: () => void;
+        showMonthsPanel: () => void;
+        showYearsPanel: () => void;
+        subscribe: (listener: import("./date-range-picker.types").TngDateRangePickerListener<any>) => () => void;
+        toggleOpen: () => void;
+    }>>;
+    ngOnInit(): void;
+    protected readonly dataSlot: "date-range-picker-trigger";
+    protected get ariaHaspopup(): string | null;
+    protected get ariaExpanded(): string | null;
+    protected get ariaControls(): string | null;
+    protected get ariaDisabled(): string | null;
+    protected get dataDisabled(): string | null;
+    protected get disabled(): boolean;
+    protected get dataOpen(): string | null;
+    protected onClick(): void;
+    protected onKeydown(event: KeyboardEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TngDateRangePickerTrigger, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TngDateRangePickerTrigger, "button[tngDateRangePickerTrigger]", ["tngDateRangePickerTrigger"], { "controller": { "alias": "tngDateRangePickerTrigger"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+export declare class TngDateRangePickerPrevButton extends TngDateRangePickerControllerPart {
+    readonly controller: import("@angular/core").InputSignal<Readonly<{
+        clear: () => void;
+        close: (reason?: import("./date-range-picker.types").TngDateRangePickerCloseReason) => void;
+        commitInputText: () => boolean;
+        destroy: () => void;
+        formatDate: (date: any, format?: import("./date-range-picker.types").TngDateFormatToken | string) => string;
+        getOutputs: () => Readonly<{
+            activeDate: any;
+            cells: readonly Readonly<{
+                active: boolean;
+                colIndex: number;
+                date: any;
+                disabled: boolean;
+                focusVisible: boolean;
+                hidden: boolean;
+                id: string;
+                inMonth: boolean;
+                inRange: boolean;
+                label: string;
+                previewRange: boolean;
+                rangeEnd: boolean;
+                rangeStart: boolean;
+                rowIndex: number;
+                selected: boolean;
+                tabindex: -1 | 0;
+                today: boolean;
+            }>[];
+            endDate: any;
+            focusedDate: any;
+            focusedSection: import("./date-range-picker.types").TngDateRangePickerFocusedSection;
+            getCellAttributes: (cellOrDate: any) => TngDateRangePickerAttributeMap;
+            getGridAttributes: () => TngDateRangePickerAttributeMap;
+            getHostAttributes: () => TngDateRangePickerAttributeMap;
+            getMonthAttributes: (monthOrOption: number | Readonly<Readonly<{
+                active: boolean;
+                date: any;
+                disabled: boolean;
+                focusVisible: boolean;
+                id: string;
+                index: number;
+                label: string;
+                selected: boolean;
+                tabindex: -1 | 0;
+            }>>) => TngDateRangePickerAttributeMap;
+            getOverlayAttributes: () => TngDateRangePickerAttributeMap;
+            getTriggerAttributes: () => TngDateRangePickerAttributeMap;
+            getYearAttributes: (yearOrOption: number | Readonly<Readonly<{
+                active: boolean;
+                date: any;
+                disabled: boolean;
+                focusVisible: boolean;
+                id: string;
+                label: string;
+                selected: boolean;
+                tabindex: -1 | 0;
+                year: number;
+            }>>) => TngDateRangePickerAttributeMap;
+            inputText: string;
+            labelMonthYear: string;
+            layout: Readonly<{
+                mode: import("./date-range-picker.types").TngDateRangePickerOverlayMode;
+                offsetX: number;
+                width: number;
+            }>;
+            monthOptions: readonly Readonly<{
+                active: boolean;
+                date: any;
+                disabled: boolean;
+                focusVisible: boolean;
+                id: string;
+                index: number;
+                label: string;
+                selected: boolean;
+                tabindex: -1 | 0;
+            }>[];
+            open: boolean;
+            previewEndDate: any;
+            startDate: any;
+            validationError: string | null;
+            value: import("./date-range-picker.types").TngDateValue<any>;
+            view: import("./date-range-picker.types").TngCalendarView;
+            visibleMonth: any;
+            weekdayLabels: readonly string[];
+            yearOptions: readonly Readonly<{
+                active: boolean;
+                date: any;
+                disabled: boolean;
+                focusVisible: boolean;
+                id: string;
+                label: string;
+                selected: boolean;
+                tabindex: -1 | 0;
+                year: number;
+            }>[];
+        }>;
+        getState: () => Readonly<{
+            activeDate: any;
+            disabled: boolean;
+            endDate: any;
+            focusedDate: any;
+            focusedSection: import("./date-range-picker.types").TngDateRangePickerFocusedSection;
+            inputText: string;
+            lastCloseReason: import("./date-range-picker.types").TngDateRangePickerCloseReason | null;
+            open: boolean;
+            previewEndDate: any;
+            startDate: any;
+            validationError: string | null;
+            value: import("./date-range-picker.types").TngDateValue<any>;
+            view: import("./date-range-picker.types").TngCalendarView;
+            visibleMonth: any;
+        }>;
+        goToNextMonth: () => void;
+        goToPrevMonth: () => void;
+        handleCellClick: (date: any, options?: Readonly<{
+            shiftKey?: boolean;
+        }>) => void;
+        handleCellPointerEnter: (date: any) => void;
+        handleGridKeyDown: (event: Readonly<Pick<KeyboardEvent, "altKey" | "ctrlKey" | "key" | "metaKey" | "preventDefault" | "shiftKey">>) => void;
+        handleMonthGridKeyDown: (event: Readonly<Pick<KeyboardEvent, "altKey" | "ctrlKey" | "key" | "metaKey" | "preventDefault" | "shiftKey">>) => void;
+        handleOverlayKeyDown: (event: Readonly<Pick<KeyboardEvent, "altKey" | "ctrlKey" | "key" | "metaKey" | "preventDefault" | "shiftKey">>) => void;
+        handleTriggerKeyDown: (event: Readonly<Pick<KeyboardEvent, "key" | "preventDefault">>) => void;
+        handleYearGridKeyDown: (event: Readonly<Pick<KeyboardEvent, "altKey" | "ctrlKey" | "key" | "metaKey" | "preventDefault" | "shiftKey">>) => void;
+        nextMonth: () => void;
+        nextYear: () => void;
+        open: () => void;
+        parseInputText: (text: string) => any;
+        prevMonth: () => void;
+        prevYear: () => void;
+        registerOverlay: (element: HTMLElement | null) => void;
+        registerTrigger: (element: HTMLElement | null) => void;
+        selectDate: (date: any, options?: Readonly<{
+            shiftKey?: boolean;
+            trigger?: import("./date-range-picker.types").TngDateRangePickerTrigger;
+        }>) => void;
+        selectMonth: (monthIndex: number) => void;
+        selectYear: (year: number) => void;
+        setActiveDate: (date: any, trigger?: import("./date-range-picker.types").TngDateRangePickerTrigger) => void;
+        setConfig: (config: Partial<Readonly<{
+            adapter?: Readonly<{
+                addDays: (date: any, amount: number) => any;
+                addMonths: (date: any, amount: number) => any;
+                addYears: (date: any, amount: number) => any;
+                compare: (left: any, right: any) => -1 | 0 | 1;
+                createDate: (year: number, month: number, day: number) => any;
+                deserialize?: ((value: unknown, locale?: string) => any) | undefined;
+                endOfMonth: (date: any) => any;
+                format: (date: any, format: import("./date-range-picker.types").TngDateFormatToken | string, locale?: string) => string;
+                getDate: (date: any) => number;
+                getDay: (date: any) => number;
+                getMonth: (date: any) => number;
+                getYear: (date: any) => number;
+                isValid: (date: any) => boolean;
+                parse: (text: string, locale?: string) => any;
+                startOfMonth: (date: any) => any;
+                startOfWeek: (date: any, weekStartsOn: import("./date-range-picker.types").TngWeekdayIndex) => any;
+                today: () => any;
+            }> | undefined;
+            allowManualInput?: boolean;
+            ariaDescribedBy?: string | null;
+            ariaLabel?: string | null;
+            ariaLabelledBy?: string | null;
+            autoCommitView?: boolean;
+            closeOnEscape?: boolean;
+            closeOnOutsideClick?: boolean;
+            closeOnSelect?: boolean;
+            closeOthersOnOpen?: boolean;
+            defaultOpen?: boolean;
+            direction?: import("./date-range-picker.types").TngDateRangePickerDirection;
+            disableDate?: ((date: any) => boolean) | undefined;
+            disabled?: boolean;
+            enableRangeSelection?: boolean;
+            enableTypeahead?: boolean;
+            fixedWeeks?: boolean;
+            focusStrategy?: import("./date-range-picker.types").TngDateRangePickerFocusStrategy;
+            id?: string;
+            initialView?: import("./date-range-picker.types").TngCalendarView;
+            locale?: string;
+            max?: any;
+            maxDate?: any;
+            min?: any;
+            minDate?: any;
+            onPartialInputCommit?: boolean;
+            overlayMode?: import("./date-range-picker.types").TngDateRangePickerOverlayMode;
+            overlayRuntime?: Readonly<{
+                clearLayers: () => void;
+                dispatchKeydown: (event: Readonly<Readonly<{
+                    defaultPrevented?: boolean;
+                    key: string;
+                    preventDefault?: () => void;
+                }>>) => void;
+                dispatchPointerDown: (event: Readonly<Readonly<{
+                    composedPath?: () => readonly unknown[];
+                    defaultPrevented?: boolean;
+                    preventDefault?: () => void;
+                    target: unknown;
+                }>>) => void;
+                dismissById: (id: string, reason: import("@tailng-ui/cdk").TngOverlayDismissReason) => void;
+                getLayerIds: () => readonly string[];
+                isTopLayer: (id: string) => boolean;
+                registerLayer: (layer: Readonly<{
+                    containsTarget?: (target: unknown, path: readonly unknown[]) => boolean;
+                    dismissOnEscape?: boolean;
+                    dismissOnOutsidePointer?: boolean;
+                    id: string;
+                    modal?: boolean;
+                    onDismiss: (reason: import("@tailng-ui/cdk").TngOverlayDismissReason) => void;
+                    priority?: number;
+                }>) => void;
+                unregisterLayer: (id: string) => void;
+            }> | null | undefined;
+            overlaySize?: number;
+            ownerDocument?: Document | null;
+            position?: import("./date-range-picker.types").TngDateRangePickerPosition;
+            preserveViewOnOpenClose?: boolean;
+            restoreFocus?: boolean;
+            showOutsideDays?: boolean;
+            skipDisabled?: boolean;
+            today?: any;
+            trapFocus?: boolean;
+            value?: any;
+            weekStartsOn?: import("./date-range-picker.types").TngWeekdayIndex;
+            yearPageSize?: number;
+        }>>) => void;
+        setDisabled: (disabled: boolean) => void;
+        setFocusedSection: (section: import("./date-range-picker.types").TngDateRangePickerFocusedSection) => void;
+        setInputText: (text: string) => void;
+        setOpen: (open: boolean) => void;
+        setState: (patch: Readonly<{
+            activeDate?: any;
+            disabled?: boolean;
+            inputText?: string;
+            value?: any;
+            view?: import("./date-range-picker.types").TngCalendarView;
+            visibleMonth?: any;
+        }>) => void;
+        setValue: (value: any) => void;
+        setView: (view: import("./date-range-picker.types").TngCalendarView) => void;
+        setVisibleMonth: (valueOrYear: any, month?: number) => void;
+        setVisibleYear: (year: number) => void;
+        showDaysPanel: () => void;
+        showMonthsPanel: () => void;
+        showYearsPanel: () => void;
+        subscribe: (listener: import("./date-range-picker.types").TngDateRangePickerListener<any>) => () => void;
+        toggleOpen: () => void;
+    }>>;
+    protected readonly dataSlot: "date-range-picker-nav-button";
+    protected onClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TngDateRangePickerPrevButton, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TngDateRangePickerPrevButton, "button[tngDateRangePickerPrevButton]", ["tngDateRangePickerPrevButton"], { "controller": { "alias": "tngDateRangePickerPrevButton"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+export declare class TngDateRangePickerNextButton extends TngDateRangePickerControllerPart {
+    readonly controller: import("@angular/core").InputSignal<Readonly<{
+        clear: () => void;
+        close: (reason?: import("./date-range-picker.types").TngDateRangePickerCloseReason) => void;
+        commitInputText: () => boolean;
+        destroy: () => void;
+        formatDate: (date: any, format?: import("./date-range-picker.types").TngDateFormatToken | string) => string;
+        getOutputs: () => Readonly<{
+            activeDate: any;
+            cells: readonly Readonly<{
+                active: boolean;
+                colIndex: number;
+                date: any;
+                disabled: boolean;
+                focusVisible: boolean;
+                hidden: boolean;
+                id: string;
+                inMonth: boolean;
+                inRange: boolean;
+                label: string;
+                previewRange: boolean;
+                rangeEnd: boolean;
+                rangeStart: boolean;
+                rowIndex: number;
+                selected: boolean;
+                tabindex: -1 | 0;
+                today: boolean;
+            }>[];
+            endDate: any;
+            focusedDate: any;
+            focusedSection: import("./date-range-picker.types").TngDateRangePickerFocusedSection;
+            getCellAttributes: (cellOrDate: any) => TngDateRangePickerAttributeMap;
+            getGridAttributes: () => TngDateRangePickerAttributeMap;
+            getHostAttributes: () => TngDateRangePickerAttributeMap;
+            getMonthAttributes: (monthOrOption: number | Readonly<Readonly<{
+                active: boolean;
+                date: any;
+                disabled: boolean;
+                focusVisible: boolean;
+                id: string;
+                index: number;
+                label: string;
+                selected: boolean;
+                tabindex: -1 | 0;
+            }>>) => TngDateRangePickerAttributeMap;
+            getOverlayAttributes: () => TngDateRangePickerAttributeMap;
+            getTriggerAttributes: () => TngDateRangePickerAttributeMap;
+            getYearAttributes: (yearOrOption: number | Readonly<Readonly<{
+                active: boolean;
+                date: any;
+                disabled: boolean;
+                focusVisible: boolean;
+                id: string;
+                label: string;
+                selected: boolean;
+                tabindex: -1 | 0;
+                year: number;
+            }>>) => TngDateRangePickerAttributeMap;
+            inputText: string;
+            labelMonthYear: string;
+            layout: Readonly<{
+                mode: import("./date-range-picker.types").TngDateRangePickerOverlayMode;
+                offsetX: number;
+                width: number;
+            }>;
+            monthOptions: readonly Readonly<{
+                active: boolean;
+                date: any;
+                disabled: boolean;
+                focusVisible: boolean;
+                id: string;
+                index: number;
+                label: string;
+                selected: boolean;
+                tabindex: -1 | 0;
+            }>[];
+            open: boolean;
+            previewEndDate: any;
+            startDate: any;
+            validationError: string | null;
+            value: import("./date-range-picker.types").TngDateValue<any>;
+            view: import("./date-range-picker.types").TngCalendarView;
+            visibleMonth: any;
+            weekdayLabels: readonly string[];
+            yearOptions: readonly Readonly<{
+                active: boolean;
+                date: any;
+                disabled: boolean;
+                focusVisible: boolean;
+                id: string;
+                label: string;
+                selected: boolean;
+                tabindex: -1 | 0;
+                year: number;
+            }>[];
+        }>;
+        getState: () => Readonly<{
+            activeDate: any;
+            disabled: boolean;
+            endDate: any;
+            focusedDate: any;
+            focusedSection: import("./date-range-picker.types").TngDateRangePickerFocusedSection;
+            inputText: string;
+            lastCloseReason: import("./date-range-picker.types").TngDateRangePickerCloseReason | null;
+            open: boolean;
+            previewEndDate: any;
+            startDate: any;
+            validationError: string | null;
+            value: import("./date-range-picker.types").TngDateValue<any>;
+            view: import("./date-range-picker.types").TngCalendarView;
+            visibleMonth: any;
+        }>;
+        goToNextMonth: () => void;
+        goToPrevMonth: () => void;
+        handleCellClick: (date: any, options?: Readonly<{
+            shiftKey?: boolean;
+        }>) => void;
+        handleCellPointerEnter: (date: any) => void;
+        handleGridKeyDown: (event: Readonly<Pick<KeyboardEvent, "altKey" | "ctrlKey" | "key" | "metaKey" | "preventDefault" | "shiftKey">>) => void;
+        handleMonthGridKeyDown: (event: Readonly<Pick<KeyboardEvent, "altKey" | "ctrlKey" | "key" | "metaKey" | "preventDefault" | "shiftKey">>) => void;
+        handleOverlayKeyDown: (event: Readonly<Pick<KeyboardEvent, "altKey" | "ctrlKey" | "key" | "metaKey" | "preventDefault" | "shiftKey">>) => void;
+        handleTriggerKeyDown: (event: Readonly<Pick<KeyboardEvent, "key" | "preventDefault">>) => void;
+        handleYearGridKeyDown: (event: Readonly<Pick<KeyboardEvent, "altKey" | "ctrlKey" | "key" | "metaKey" | "preventDefault" | "shiftKey">>) => void;
+        nextMonth: () => void;
+        nextYear: () => void;
+        open: () => void;
+        parseInputText: (text: string) => any;
+        prevMonth: () => void;
+        prevYear: () => void;
+        registerOverlay: (element: HTMLElement | null) => void;
+        registerTrigger: (element: HTMLElement | null) => void;
+        selectDate: (date: any, options?: Readonly<{
+            shiftKey?: boolean;
+            trigger?: import("./date-range-picker.types").TngDateRangePickerTrigger;
+        }>) => void;
+        selectMonth: (monthIndex: number) => void;
+        selectYear: (year: number) => void;
+        setActiveDate: (date: any, trigger?: import("./date-range-picker.types").TngDateRangePickerTrigger) => void;
+        setConfig: (config: Partial<Readonly<{
+            adapter?: Readonly<{
+                addDays: (date: any, amount: number) => any;
+                addMonths: (date: any, amount: number) => any;
+                addYears: (date: any, amount: number) => any;
+                compare: (left: any, right: any) => -1 | 0 | 1;
+                createDate: (year: number, month: number, day: number) => any;
+                deserialize?: ((value: unknown, locale?: string) => any) | undefined;
+                endOfMonth: (date: any) => any;
+                format: (date: any, format: import("./date-range-picker.types").TngDateFormatToken | string, locale?: string) => string;
+                getDate: (date: any) => number;
+                getDay: (date: any) => number;
+                getMonth: (date: any) => number;
+                getYear: (date: any) => number;
+                isValid: (date: any) => boolean;
+                parse: (text: string, locale?: string) => any;
+                startOfMonth: (date: any) => any;
+                startOfWeek: (date: any, weekStartsOn: import("./date-range-picker.types").TngWeekdayIndex) => any;
+                today: () => any;
+            }> | undefined;
+            allowManualInput?: boolean;
+            ariaDescribedBy?: string | null;
+            ariaLabel?: string | null;
+            ariaLabelledBy?: string | null;
+            autoCommitView?: boolean;
+            closeOnEscape?: boolean;
+            closeOnOutsideClick?: boolean;
+            closeOnSelect?: boolean;
+            closeOthersOnOpen?: boolean;
+            defaultOpen?: boolean;
+            direction?: import("./date-range-picker.types").TngDateRangePickerDirection;
+            disableDate?: ((date: any) => boolean) | undefined;
+            disabled?: boolean;
+            enableRangeSelection?: boolean;
+            enableTypeahead?: boolean;
+            fixedWeeks?: boolean;
+            focusStrategy?: import("./date-range-picker.types").TngDateRangePickerFocusStrategy;
+            id?: string;
+            initialView?: import("./date-range-picker.types").TngCalendarView;
+            locale?: string;
+            max?: any;
+            maxDate?: any;
+            min?: any;
+            minDate?: any;
+            onPartialInputCommit?: boolean;
+            overlayMode?: import("./date-range-picker.types").TngDateRangePickerOverlayMode;
+            overlayRuntime?: Readonly<{
+                clearLayers: () => void;
+                dispatchKeydown: (event: Readonly<Readonly<{
+                    defaultPrevented?: boolean;
+                    key: string;
+                    preventDefault?: () => void;
+                }>>) => void;
+                dispatchPointerDown: (event: Readonly<Readonly<{
+                    composedPath?: () => readonly unknown[];
+                    defaultPrevented?: boolean;
+                    preventDefault?: () => void;
+                    target: unknown;
+                }>>) => void;
+                dismissById: (id: string, reason: import("@tailng-ui/cdk").TngOverlayDismissReason) => void;
+                getLayerIds: () => readonly string[];
+                isTopLayer: (id: string) => boolean;
+                registerLayer: (layer: Readonly<{
+                    containsTarget?: (target: unknown, path: readonly unknown[]) => boolean;
+                    dismissOnEscape?: boolean;
+                    dismissOnOutsidePointer?: boolean;
+                    id: string;
+                    modal?: boolean;
+                    onDismiss: (reason: import("@tailng-ui/cdk").TngOverlayDismissReason) => void;
+                    priority?: number;
+                }>) => void;
+                unregisterLayer: (id: string) => void;
+            }> | null | undefined;
+            overlaySize?: number;
+            ownerDocument?: Document | null;
+            position?: import("./date-range-picker.types").TngDateRangePickerPosition;
+            preserveViewOnOpenClose?: boolean;
+            restoreFocus?: boolean;
+            showOutsideDays?: boolean;
+            skipDisabled?: boolean;
+            today?: any;
+            trapFocus?: boolean;
+            value?: any;
+            weekStartsOn?: import("./date-range-picker.types").TngWeekdayIndex;
+            yearPageSize?: number;
+        }>>) => void;
+        setDisabled: (disabled: boolean) => void;
+        setFocusedSection: (section: import("./date-range-picker.types").TngDateRangePickerFocusedSection) => void;
+        setInputText: (text: string) => void;
+        setOpen: (open: boolean) => void;
+        setState: (patch: Readonly<{
+            activeDate?: any;
+            disabled?: boolean;
+            inputText?: string;
+            value?: any;
+            view?: import("./date-range-picker.types").TngCalendarView;
+            visibleMonth?: any;
+        }>) => void;
+        setValue: (value: any) => void;
+        setView: (view: import("./date-range-picker.types").TngCalendarView) => void;
+        setVisibleMonth: (valueOrYear: any, month?: number) => void;
+        setVisibleYear: (year: number) => void;
+        showDaysPanel: () => void;
+        showMonthsPanel: () => void;
+        showYearsPanel: () => void;
+        subscribe: (listener: import("./date-range-picker.types").TngDateRangePickerListener<any>) => () => void;
+        toggleOpen: () => void;
+    }>>;
+    protected readonly dataSlot: "date-range-picker-nav-button";
+    protected onClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TngDateRangePickerNextButton, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TngDateRangePickerNextButton, "button[tngDateRangePickerNextButton]", ["tngDateRangePickerNextButton"], { "controller": { "alias": "tngDateRangePickerNextButton"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+export declare class TngDateRangePickerPeriodButton extends TngDateRangePickerControllerPart {
+    readonly controller: import("@angular/core").InputSignal<Readonly<{
+        clear: () => void;
+        close: (reason?: import("./date-range-picker.types").TngDateRangePickerCloseReason) => void;
+        commitInputText: () => boolean;
+        destroy: () => void;
+        formatDate: (date: any, format?: import("./date-range-picker.types").TngDateFormatToken | string) => string;
+        getOutputs: () => Readonly<{
+            activeDate: any;
+            cells: readonly Readonly<{
+                active: boolean;
+                colIndex: number;
+                date: any;
+                disabled: boolean;
+                focusVisible: boolean;
+                hidden: boolean;
+                id: string;
+                inMonth: boolean;
+                inRange: boolean;
+                label: string;
+                previewRange: boolean;
+                rangeEnd: boolean;
+                rangeStart: boolean;
+                rowIndex: number;
+                selected: boolean;
+                tabindex: -1 | 0;
+                today: boolean;
+            }>[];
+            endDate: any;
+            focusedDate: any;
+            focusedSection: import("./date-range-picker.types").TngDateRangePickerFocusedSection;
+            getCellAttributes: (cellOrDate: any) => TngDateRangePickerAttributeMap;
+            getGridAttributes: () => TngDateRangePickerAttributeMap;
+            getHostAttributes: () => TngDateRangePickerAttributeMap;
+            getMonthAttributes: (monthOrOption: number | Readonly<Readonly<{
+                active: boolean;
+                date: any;
+                disabled: boolean;
+                focusVisible: boolean;
+                id: string;
+                index: number;
+                label: string;
+                selected: boolean;
+                tabindex: -1 | 0;
+            }>>) => TngDateRangePickerAttributeMap;
+            getOverlayAttributes: () => TngDateRangePickerAttributeMap;
+            getTriggerAttributes: () => TngDateRangePickerAttributeMap;
+            getYearAttributes: (yearOrOption: number | Readonly<Readonly<{
+                active: boolean;
+                date: any;
+                disabled: boolean;
+                focusVisible: boolean;
+                id: string;
+                label: string;
+                selected: boolean;
+                tabindex: -1 | 0;
+                year: number;
+            }>>) => TngDateRangePickerAttributeMap;
+            inputText: string;
+            labelMonthYear: string;
+            layout: Readonly<{
+                mode: import("./date-range-picker.types").TngDateRangePickerOverlayMode;
+                offsetX: number;
+                width: number;
+            }>;
+            monthOptions: readonly Readonly<{
+                active: boolean;
+                date: any;
+                disabled: boolean;
+                focusVisible: boolean;
+                id: string;
+                index: number;
+                label: string;
+                selected: boolean;
+                tabindex: -1 | 0;
+            }>[];
+            open: boolean;
+            previewEndDate: any;
+            startDate: any;
+            validationError: string | null;
+            value: import("./date-range-picker.types").TngDateValue<any>;
+            view: import("./date-range-picker.types").TngCalendarView;
+            visibleMonth: any;
+            weekdayLabels: readonly string[];
+            yearOptions: readonly Readonly<{
+                active: boolean;
+                date: any;
+                disabled: boolean;
+                focusVisible: boolean;
+                id: string;
+                label: string;
+                selected: boolean;
+                tabindex: -1 | 0;
+                year: number;
+            }>[];
+        }>;
+        getState: () => Readonly<{
+            activeDate: any;
+            disabled: boolean;
+            endDate: any;
+            focusedDate: any;
+            focusedSection: import("./date-range-picker.types").TngDateRangePickerFocusedSection;
+            inputText: string;
+            lastCloseReason: import("./date-range-picker.types").TngDateRangePickerCloseReason | null;
+            open: boolean;
+            previewEndDate: any;
+            startDate: any;
+            validationError: string | null;
+            value: import("./date-range-picker.types").TngDateValue<any>;
+            view: import("./date-range-picker.types").TngCalendarView;
+            visibleMonth: any;
+        }>;
+        goToNextMonth: () => void;
+        goToPrevMonth: () => void;
+        handleCellClick: (date: any, options?: Readonly<{
+            shiftKey?: boolean;
+        }>) => void;
+        handleCellPointerEnter: (date: any) => void;
+        handleGridKeyDown: (event: Readonly<Pick<KeyboardEvent, "altKey" | "ctrlKey" | "key" | "metaKey" | "preventDefault" | "shiftKey">>) => void;
+        handleMonthGridKeyDown: (event: Readonly<Pick<KeyboardEvent, "altKey" | "ctrlKey" | "key" | "metaKey" | "preventDefault" | "shiftKey">>) => void;
+        handleOverlayKeyDown: (event: Readonly<Pick<KeyboardEvent, "altKey" | "ctrlKey" | "key" | "metaKey" | "preventDefault" | "shiftKey">>) => void;
+        handleTriggerKeyDown: (event: Readonly<Pick<KeyboardEvent, "key" | "preventDefault">>) => void;
+        handleYearGridKeyDown: (event: Readonly<Pick<KeyboardEvent, "altKey" | "ctrlKey" | "key" | "metaKey" | "preventDefault" | "shiftKey">>) => void;
+        nextMonth: () => void;
+        nextYear: () => void;
+        open: () => void;
+        parseInputText: (text: string) => any;
+        prevMonth: () => void;
+        prevYear: () => void;
+        registerOverlay: (element: HTMLElement | null) => void;
+        registerTrigger: (element: HTMLElement | null) => void;
+        selectDate: (date: any, options?: Readonly<{
+            shiftKey?: boolean;
+            trigger?: import("./date-range-picker.types").TngDateRangePickerTrigger;
+        }>) => void;
+        selectMonth: (monthIndex: number) => void;
+        selectYear: (year: number) => void;
+        setActiveDate: (date: any, trigger?: import("./date-range-picker.types").TngDateRangePickerTrigger) => void;
+        setConfig: (config: Partial<Readonly<{
+            adapter?: Readonly<{
+                addDays: (date: any, amount: number) => any;
+                addMonths: (date: any, amount: number) => any;
+                addYears: (date: any, amount: number) => any;
+                compare: (left: any, right: any) => -1 | 0 | 1;
+                createDate: (year: number, month: number, day: number) => any;
+                deserialize?: ((value: unknown, locale?: string) => any) | undefined;
+                endOfMonth: (date: any) => any;
+                format: (date: any, format: import("./date-range-picker.types").TngDateFormatToken | string, locale?: string) => string;
+                getDate: (date: any) => number;
+                getDay: (date: any) => number;
+                getMonth: (date: any) => number;
+                getYear: (date: any) => number;
+                isValid: (date: any) => boolean;
+                parse: (text: string, locale?: string) => any;
+                startOfMonth: (date: any) => any;
+                startOfWeek: (date: any, weekStartsOn: import("./date-range-picker.types").TngWeekdayIndex) => any;
+                today: () => any;
+            }> | undefined;
+            allowManualInput?: boolean;
+            ariaDescribedBy?: string | null;
+            ariaLabel?: string | null;
+            ariaLabelledBy?: string | null;
+            autoCommitView?: boolean;
+            closeOnEscape?: boolean;
+            closeOnOutsideClick?: boolean;
+            closeOnSelect?: boolean;
+            closeOthersOnOpen?: boolean;
+            defaultOpen?: boolean;
+            direction?: import("./date-range-picker.types").TngDateRangePickerDirection;
+            disableDate?: ((date: any) => boolean) | undefined;
+            disabled?: boolean;
+            enableRangeSelection?: boolean;
+            enableTypeahead?: boolean;
+            fixedWeeks?: boolean;
+            focusStrategy?: import("./date-range-picker.types").TngDateRangePickerFocusStrategy;
+            id?: string;
+            initialView?: import("./date-range-picker.types").TngCalendarView;
+            locale?: string;
+            max?: any;
+            maxDate?: any;
+            min?: any;
+            minDate?: any;
+            onPartialInputCommit?: boolean;
+            overlayMode?: import("./date-range-picker.types").TngDateRangePickerOverlayMode;
+            overlayRuntime?: Readonly<{
+                clearLayers: () => void;
+                dispatchKeydown: (event: Readonly<Readonly<{
+                    defaultPrevented?: boolean;
+                    key: string;
+                    preventDefault?: () => void;
+                }>>) => void;
+                dispatchPointerDown: (event: Readonly<Readonly<{
+                    composedPath?: () => readonly unknown[];
+                    defaultPrevented?: boolean;
+                    preventDefault?: () => void;
+                    target: unknown;
+                }>>) => void;
+                dismissById: (id: string, reason: import("@tailng-ui/cdk").TngOverlayDismissReason) => void;
+                getLayerIds: () => readonly string[];
+                isTopLayer: (id: string) => boolean;
+                registerLayer: (layer: Readonly<{
+                    containsTarget?: (target: unknown, path: readonly unknown[]) => boolean;
+                    dismissOnEscape?: boolean;
+                    dismissOnOutsidePointer?: boolean;
+                    id: string;
+                    modal?: boolean;
+                    onDismiss: (reason: import("@tailng-ui/cdk").TngOverlayDismissReason) => void;
+                    priority?: number;
+                }>) => void;
+                unregisterLayer: (id: string) => void;
+            }> | null | undefined;
+            overlaySize?: number;
+            ownerDocument?: Document | null;
+            position?: import("./date-range-picker.types").TngDateRangePickerPosition;
+            preserveViewOnOpenClose?: boolean;
+            restoreFocus?: boolean;
+            showOutsideDays?: boolean;
+            skipDisabled?: boolean;
+            today?: any;
+            trapFocus?: boolean;
+            value?: any;
+            weekStartsOn?: import("./date-range-picker.types").TngWeekdayIndex;
+            yearPageSize?: number;
+        }>>) => void;
+        setDisabled: (disabled: boolean) => void;
+        setFocusedSection: (section: import("./date-range-picker.types").TngDateRangePickerFocusedSection) => void;
+        setInputText: (text: string) => void;
+        setOpen: (open: boolean) => void;
+        setState: (patch: Readonly<{
+            activeDate?: any;
+            disabled?: boolean;
+            inputText?: string;
+            value?: any;
+            view?: import("./date-range-picker.types").TngCalendarView;
+            visibleMonth?: any;
+        }>) => void;
+        setValue: (value: any) => void;
+        setView: (view: import("./date-range-picker.types").TngCalendarView) => void;
+        setVisibleMonth: (valueOrYear: any, month?: number) => void;
+        setVisibleYear: (year: number) => void;
+        showDaysPanel: () => void;
+        showMonthsPanel: () => void;
+        showYearsPanel: () => void;
+        subscribe: (listener: import("./date-range-picker.types").TngDateRangePickerListener<any>) => () => void;
+        toggleOpen: () => void;
+    }>>;
+    protected readonly dataSlot: "date-range-picker-period-button";
+    protected get dataInteractive(): string | null;
+    protected onClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TngDateRangePickerPeriodButton, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TngDateRangePickerPeriodButton, "button[tngDateRangePickerPeriodButton]", ["tngDateRangePickerPeriodButton"], { "controller": { "alias": "tngDateRangePickerPeriodButton"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+export declare class TngDateRangePickerDayGrid extends TngDateRangePickerControllerPart {
+    readonly controller: import("@angular/core").InputSignal<Readonly<{
+        clear: () => void;
+        close: (reason?: import("./date-range-picker.types").TngDateRangePickerCloseReason) => void;
+        commitInputText: () => boolean;
+        destroy: () => void;
+        formatDate: (date: any, format?: import("./date-range-picker.types").TngDateFormatToken | string) => string;
+        getOutputs: () => Readonly<{
+            activeDate: any;
+            cells: readonly Readonly<{
+                active: boolean;
+                colIndex: number;
+                date: any;
+                disabled: boolean;
+                focusVisible: boolean;
+                hidden: boolean;
+                id: string;
+                inMonth: boolean;
+                inRange: boolean;
+                label: string;
+                previewRange: boolean;
+                rangeEnd: boolean;
+                rangeStart: boolean;
+                rowIndex: number;
+                selected: boolean;
+                tabindex: -1 | 0;
+                today: boolean;
+            }>[];
+            endDate: any;
+            focusedDate: any;
+            focusedSection: import("./date-range-picker.types").TngDateRangePickerFocusedSection;
+            getCellAttributes: (cellOrDate: any) => TngDateRangePickerAttributeMap;
+            getGridAttributes: () => TngDateRangePickerAttributeMap;
+            getHostAttributes: () => TngDateRangePickerAttributeMap;
+            getMonthAttributes: (monthOrOption: number | Readonly<Readonly<{
+                active: boolean;
+                date: any;
+                disabled: boolean;
+                focusVisible: boolean;
+                id: string;
+                index: number;
+                label: string;
+                selected: boolean;
+                tabindex: -1 | 0;
+            }>>) => TngDateRangePickerAttributeMap;
+            getOverlayAttributes: () => TngDateRangePickerAttributeMap;
+            getTriggerAttributes: () => TngDateRangePickerAttributeMap;
+            getYearAttributes: (yearOrOption: number | Readonly<Readonly<{
+                active: boolean;
+                date: any;
+                disabled: boolean;
+                focusVisible: boolean;
+                id: string;
+                label: string;
+                selected: boolean;
+                tabindex: -1 | 0;
+                year: number;
+            }>>) => TngDateRangePickerAttributeMap;
+            inputText: string;
+            labelMonthYear: string;
+            layout: Readonly<{
+                mode: import("./date-range-picker.types").TngDateRangePickerOverlayMode;
+                offsetX: number;
+                width: number;
+            }>;
+            monthOptions: readonly Readonly<{
+                active: boolean;
+                date: any;
+                disabled: boolean;
+                focusVisible: boolean;
+                id: string;
+                index: number;
+                label: string;
+                selected: boolean;
+                tabindex: -1 | 0;
+            }>[];
+            open: boolean;
+            previewEndDate: any;
+            startDate: any;
+            validationError: string | null;
+            value: import("./date-range-picker.types").TngDateValue<any>;
+            view: import("./date-range-picker.types").TngCalendarView;
+            visibleMonth: any;
+            weekdayLabels: readonly string[];
+            yearOptions: readonly Readonly<{
+                active: boolean;
+                date: any;
+                disabled: boolean;
+                focusVisible: boolean;
+                id: string;
+                label: string;
+                selected: boolean;
+                tabindex: -1 | 0;
+                year: number;
+            }>[];
+        }>;
+        getState: () => Readonly<{
+            activeDate: any;
+            disabled: boolean;
+            endDate: any;
+            focusedDate: any;
+            focusedSection: import("./date-range-picker.types").TngDateRangePickerFocusedSection;
+            inputText: string;
+            lastCloseReason: import("./date-range-picker.types").TngDateRangePickerCloseReason | null;
+            open: boolean;
+            previewEndDate: any;
+            startDate: any;
+            validationError: string | null;
+            value: import("./date-range-picker.types").TngDateValue<any>;
+            view: import("./date-range-picker.types").TngCalendarView;
+            visibleMonth: any;
+        }>;
+        goToNextMonth: () => void;
+        goToPrevMonth: () => void;
+        handleCellClick: (date: any, options?: Readonly<{
+            shiftKey?: boolean;
+        }>) => void;
+        handleCellPointerEnter: (date: any) => void;
+        handleGridKeyDown: (event: Readonly<Pick<KeyboardEvent, "altKey" | "ctrlKey" | "key" | "metaKey" | "preventDefault" | "shiftKey">>) => void;
+        handleMonthGridKeyDown: (event: Readonly<Pick<KeyboardEvent, "altKey" | "ctrlKey" | "key" | "metaKey" | "preventDefault" | "shiftKey">>) => void;
+        handleOverlayKeyDown: (event: Readonly<Pick<KeyboardEvent, "altKey" | "ctrlKey" | "key" | "metaKey" | "preventDefault" | "shiftKey">>) => void;
+        handleTriggerKeyDown: (event: Readonly<Pick<KeyboardEvent, "key" | "preventDefault">>) => void;
+        handleYearGridKeyDown: (event: Readonly<Pick<KeyboardEvent, "altKey" | "ctrlKey" | "key" | "metaKey" | "preventDefault" | "shiftKey">>) => void;
+        nextMonth: () => void;
+        nextYear: () => void;
+        open: () => void;
+        parseInputText: (text: string) => any;
+        prevMonth: () => void;
+        prevYear: () => void;
+        registerOverlay: (element: HTMLElement | null) => void;
+        registerTrigger: (element: HTMLElement | null) => void;
+        selectDate: (date: any, options?: Readonly<{
+            shiftKey?: boolean;
+            trigger?: import("./date-range-picker.types").TngDateRangePickerTrigger;
+        }>) => void;
+        selectMonth: (monthIndex: number) => void;
+        selectYear: (year: number) => void;
+        setActiveDate: (date: any, trigger?: import("./date-range-picker.types").TngDateRangePickerTrigger) => void;
+        setConfig: (config: Partial<Readonly<{
+            adapter?: Readonly<{
+                addDays: (date: any, amount: number) => any;
+                addMonths: (date: any, amount: number) => any;
+                addYears: (date: any, amount: number) => any;
+                compare: (left: any, right: any) => -1 | 0 | 1;
+                createDate: (year: number, month: number, day: number) => any;
+                deserialize?: ((value: unknown, locale?: string) => any) | undefined;
+                endOfMonth: (date: any) => any;
+                format: (date: any, format: import("./date-range-picker.types").TngDateFormatToken | string, locale?: string) => string;
+                getDate: (date: any) => number;
+                getDay: (date: any) => number;
+                getMonth: (date: any) => number;
+                getYear: (date: any) => number;
+                isValid: (date: any) => boolean;
+                parse: (text: string, locale?: string) => any;
+                startOfMonth: (date: any) => any;
+                startOfWeek: (date: any, weekStartsOn: import("./date-range-picker.types").TngWeekdayIndex) => any;
+                today: () => any;
+            }> | undefined;
+            allowManualInput?: boolean;
+            ariaDescribedBy?: string | null;
+            ariaLabel?: string | null;
+            ariaLabelledBy?: string | null;
+            autoCommitView?: boolean;
+            closeOnEscape?: boolean;
+            closeOnOutsideClick?: boolean;
+            closeOnSelect?: boolean;
+            closeOthersOnOpen?: boolean;
+            defaultOpen?: boolean;
+            direction?: import("./date-range-picker.types").TngDateRangePickerDirection;
+            disableDate?: ((date: any) => boolean) | undefined;
+            disabled?: boolean;
+            enableRangeSelection?: boolean;
+            enableTypeahead?: boolean;
+            fixedWeeks?: boolean;
+            focusStrategy?: import("./date-range-picker.types").TngDateRangePickerFocusStrategy;
+            id?: string;
+            initialView?: import("./date-range-picker.types").TngCalendarView;
+            locale?: string;
+            max?: any;
+            maxDate?: any;
+            min?: any;
+            minDate?: any;
+            onPartialInputCommit?: boolean;
+            overlayMode?: import("./date-range-picker.types").TngDateRangePickerOverlayMode;
+            overlayRuntime?: Readonly<{
+                clearLayers: () => void;
+                dispatchKeydown: (event: Readonly<Readonly<{
+                    defaultPrevented?: boolean;
+                    key: string;
+                    preventDefault?: () => void;
+                }>>) => void;
+                dispatchPointerDown: (event: Readonly<Readonly<{
+                    composedPath?: () => readonly unknown[];
+                    defaultPrevented?: boolean;
+                    preventDefault?: () => void;
+                    target: unknown;
+                }>>) => void;
+                dismissById: (id: string, reason: import("@tailng-ui/cdk").TngOverlayDismissReason) => void;
+                getLayerIds: () => readonly string[];
+                isTopLayer: (id: string) => boolean;
+                registerLayer: (layer: Readonly<{
+                    containsTarget?: (target: unknown, path: readonly unknown[]) => boolean;
+                    dismissOnEscape?: boolean;
+                    dismissOnOutsidePointer?: boolean;
+                    id: string;
+                    modal?: boolean;
+                    onDismiss: (reason: import("@tailng-ui/cdk").TngOverlayDismissReason) => void;
+                    priority?: number;
+                }>) => void;
+                unregisterLayer: (id: string) => void;
+            }> | null | undefined;
+            overlaySize?: number;
+            ownerDocument?: Document | null;
+            position?: import("./date-range-picker.types").TngDateRangePickerPosition;
+            preserveViewOnOpenClose?: boolean;
+            restoreFocus?: boolean;
+            showOutsideDays?: boolean;
+            skipDisabled?: boolean;
+            today?: any;
+            trapFocus?: boolean;
+            value?: any;
+            weekStartsOn?: import("./date-range-picker.types").TngWeekdayIndex;
+            yearPageSize?: number;
+        }>>) => void;
+        setDisabled: (disabled: boolean) => void;
+        setFocusedSection: (section: import("./date-range-picker.types").TngDateRangePickerFocusedSection) => void;
+        setInputText: (text: string) => void;
+        setOpen: (open: boolean) => void;
+        setState: (patch: Readonly<{
+            activeDate?: any;
+            disabled?: boolean;
+            inputText?: string;
+            value?: any;
+            view?: import("./date-range-picker.types").TngCalendarView;
+            visibleMonth?: any;
+        }>) => void;
+        setValue: (value: any) => void;
+        setView: (view: import("./date-range-picker.types").TngCalendarView) => void;
+        setVisibleMonth: (valueOrYear: any, month?: number) => void;
+        setVisibleYear: (year: number) => void;
+        showDaysPanel: () => void;
+        showMonthsPanel: () => void;
+        showYearsPanel: () => void;
+        subscribe: (listener: import("./date-range-picker.types").TngDateRangePickerListener<any>) => () => void;
+        toggleOpen: () => void;
+    }>>;
+    protected get dataSlot(): string | null;
+    protected get id(): string | null;
+    protected get role(): string | null;
+    protected get ariaActiveDescendant(): string | null;
+    protected get ariaLabelledby(): string | null;
+    protected onKeydown(event: KeyboardEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TngDateRangePickerDayGrid, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TngDateRangePickerDayGrid, "[tngDateRangePickerDayGrid]", ["tngDateRangePickerDayGrid"], { "controller": { "alias": "tngDateRangePickerDayGrid"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+export declare class TngDateRangePickerDayCell extends TngDateRangePickerControllerPart {
+    private readonly dayGrid;
+    readonly controller: Signal<Readonly<{
+        clear: () => void;
+        close: (reason?: import("./date-range-picker.types").TngDateRangePickerCloseReason) => void;
+        commitInputText: () => boolean;
+        destroy: () => void;
+        formatDate: (date: any, format?: import("./date-range-picker.types").TngDateFormatToken | string) => string;
+        getOutputs: () => Readonly<{
+            activeDate: any;
+            cells: readonly Readonly<{
+                active: boolean;
+                colIndex: number;
+                date: any;
+                disabled: boolean;
+                focusVisible: boolean;
+                hidden: boolean;
+                id: string;
+                inMonth: boolean;
+                inRange: boolean;
+                label: string;
+                previewRange: boolean;
+                rangeEnd: boolean;
+                rangeStart: boolean;
+                rowIndex: number;
+                selected: boolean;
+                tabindex: -1 | 0;
+                today: boolean;
+            }>[];
+            endDate: any;
+            focusedDate: any;
+            focusedSection: import("./date-range-picker.types").TngDateRangePickerFocusedSection;
+            getCellAttributes: (cellOrDate: any) => TngDateRangePickerAttributeMap;
+            getGridAttributes: () => TngDateRangePickerAttributeMap;
+            getHostAttributes: () => TngDateRangePickerAttributeMap;
+            getMonthAttributes: (monthOrOption: number | Readonly<Readonly<{
+                active: boolean;
+                date: any;
+                disabled: boolean;
+                focusVisible: boolean;
+                id: string;
+                index: number;
+                label: string;
+                selected: boolean;
+                tabindex: -1 | 0;
+            }>>) => TngDateRangePickerAttributeMap;
+            getOverlayAttributes: () => TngDateRangePickerAttributeMap;
+            getTriggerAttributes: () => TngDateRangePickerAttributeMap;
+            getYearAttributes: (yearOrOption: number | Readonly<Readonly<{
+                active: boolean;
+                date: any;
+                disabled: boolean;
+                focusVisible: boolean;
+                id: string;
+                label: string;
+                selected: boolean;
+                tabindex: -1 | 0;
+                year: number;
+            }>>) => TngDateRangePickerAttributeMap;
+            inputText: string;
+            labelMonthYear: string;
+            layout: Readonly<{
+                mode: import("./date-range-picker.types").TngDateRangePickerOverlayMode;
+                offsetX: number;
+                width: number;
+            }>;
+            monthOptions: readonly Readonly<{
+                active: boolean;
+                date: any;
+                disabled: boolean;
+                focusVisible: boolean;
+                id: string;
+                index: number;
+                label: string;
+                selected: boolean;
+                tabindex: -1 | 0;
+            }>[];
+            open: boolean;
+            previewEndDate: any;
+            startDate: any;
+            validationError: string | null;
+            value: import("./date-range-picker.types").TngDateValue<any>;
+            view: import("./date-range-picker.types").TngCalendarView;
+            visibleMonth: any;
+            weekdayLabels: readonly string[];
+            yearOptions: readonly Readonly<{
+                active: boolean;
+                date: any;
+                disabled: boolean;
+                focusVisible: boolean;
+                id: string;
+                label: string;
+                selected: boolean;
+                tabindex: -1 | 0;
+                year: number;
+            }>[];
+        }>;
+        getState: () => Readonly<{
+            activeDate: any;
+            disabled: boolean;
+            endDate: any;
+            focusedDate: any;
+            focusedSection: import("./date-range-picker.types").TngDateRangePickerFocusedSection;
+            inputText: string;
+            lastCloseReason: import("./date-range-picker.types").TngDateRangePickerCloseReason | null;
+            open: boolean;
+            previewEndDate: any;
+            startDate: any;
+            validationError: string | null;
+            value: import("./date-range-picker.types").TngDateValue<any>;
+            view: import("./date-range-picker.types").TngCalendarView;
+            visibleMonth: any;
+        }>;
+        goToNextMonth: () => void;
+        goToPrevMonth: () => void;
+        handleCellClick: (date: any, options?: Readonly<{
+            shiftKey?: boolean;
+        }>) => void;
+        handleCellPointerEnter: (date: any) => void;
+        handleGridKeyDown: (event: Readonly<Pick<KeyboardEvent, "altKey" | "ctrlKey" | "key" | "metaKey" | "preventDefault" | "shiftKey">>) => void;
+        handleMonthGridKeyDown: (event: Readonly<Pick<KeyboardEvent, "altKey" | "ctrlKey" | "key" | "metaKey" | "preventDefault" | "shiftKey">>) => void;
+        handleOverlayKeyDown: (event: Readonly<Pick<KeyboardEvent, "altKey" | "ctrlKey" | "key" | "metaKey" | "preventDefault" | "shiftKey">>) => void;
+        handleTriggerKeyDown: (event: Readonly<Pick<KeyboardEvent, "key" | "preventDefault">>) => void;
+        handleYearGridKeyDown: (event: Readonly<Pick<KeyboardEvent, "altKey" | "ctrlKey" | "key" | "metaKey" | "preventDefault" | "shiftKey">>) => void;
+        nextMonth: () => void;
+        nextYear: () => void;
+        open: () => void;
+        parseInputText: (text: string) => any;
+        prevMonth: () => void;
+        prevYear: () => void;
+        registerOverlay: (element: HTMLElement | null) => void;
+        registerTrigger: (element: HTMLElement | null) => void;
+        selectDate: (date: any, options?: Readonly<{
+            shiftKey?: boolean;
+            trigger?: import("./date-range-picker.types").TngDateRangePickerTrigger;
+        }>) => void;
+        selectMonth: (monthIndex: number) => void;
+        selectYear: (year: number) => void;
+        setActiveDate: (date: any, trigger?: import("./date-range-picker.types").TngDateRangePickerTrigger) => void;
+        setConfig: (config: Partial<Readonly<{
+            adapter?: Readonly<{
+                addDays: (date: any, amount: number) => any;
+                addMonths: (date: any, amount: number) => any;
+                addYears: (date: any, amount: number) => any;
+                compare: (left: any, right: any) => -1 | 0 | 1;
+                createDate: (year: number, month: number, day: number) => any;
+                deserialize?: ((value: unknown, locale?: string) => any) | undefined;
+                endOfMonth: (date: any) => any;
+                format: (date: any, format: import("./date-range-picker.types").TngDateFormatToken | string, locale?: string) => string;
+                getDate: (date: any) => number;
+                getDay: (date: any) => number;
+                getMonth: (date: any) => number;
+                getYear: (date: any) => number;
+                isValid: (date: any) => boolean;
+                parse: (text: string, locale?: string) => any;
+                startOfMonth: (date: any) => any;
+                startOfWeek: (date: any, weekStartsOn: import("./date-range-picker.types").TngWeekdayIndex) => any;
+                today: () => any;
+            }> | undefined;
+            allowManualInput?: boolean;
+            ariaDescribedBy?: string | null;
+            ariaLabel?: string | null;
+            ariaLabelledBy?: string | null;
+            autoCommitView?: boolean;
+            closeOnEscape?: boolean;
+            closeOnOutsideClick?: boolean;
+            closeOnSelect?: boolean;
+            closeOthersOnOpen?: boolean;
+            defaultOpen?: boolean;
+            direction?: import("./date-range-picker.types").TngDateRangePickerDirection;
+            disableDate?: ((date: any) => boolean) | undefined;
+            disabled?: boolean;
+            enableRangeSelection?: boolean;
+            enableTypeahead?: boolean;
+            fixedWeeks?: boolean;
+            focusStrategy?: import("./date-range-picker.types").TngDateRangePickerFocusStrategy;
+            id?: string;
+            initialView?: import("./date-range-picker.types").TngCalendarView;
+            locale?: string;
+            max?: any;
+            maxDate?: any;
+            min?: any;
+            minDate?: any;
+            onPartialInputCommit?: boolean;
+            overlayMode?: import("./date-range-picker.types").TngDateRangePickerOverlayMode;
+            overlayRuntime?: Readonly<{
+                clearLayers: () => void;
+                dispatchKeydown: (event: Readonly<Readonly<{
+                    defaultPrevented?: boolean;
+                    key: string;
+                    preventDefault?: () => void;
+                }>>) => void;
+                dispatchPointerDown: (event: Readonly<Readonly<{
+                    composedPath?: () => readonly unknown[];
+                    defaultPrevented?: boolean;
+                    preventDefault?: () => void;
+                    target: unknown;
+                }>>) => void;
+                dismissById: (id: string, reason: import("@tailng-ui/cdk").TngOverlayDismissReason) => void;
+                getLayerIds: () => readonly string[];
+                isTopLayer: (id: string) => boolean;
+                registerLayer: (layer: Readonly<{
+                    containsTarget?: (target: unknown, path: readonly unknown[]) => boolean;
+                    dismissOnEscape?: boolean;
+                    dismissOnOutsidePointer?: boolean;
+                    id: string;
+                    modal?: boolean;
+                    onDismiss: (reason: import("@tailng-ui/cdk").TngOverlayDismissReason) => void;
+                    priority?: number;
+                }>) => void;
+                unregisterLayer: (id: string) => void;
+            }> | null | undefined;
+            overlaySize?: number;
+            ownerDocument?: Document | null;
+            position?: import("./date-range-picker.types").TngDateRangePickerPosition;
+            preserveViewOnOpenClose?: boolean;
+            restoreFocus?: boolean;
+            showOutsideDays?: boolean;
+            skipDisabled?: boolean;
+            today?: any;
+            trapFocus?: boolean;
+            value?: any;
+            weekStartsOn?: import("./date-range-picker.types").TngWeekdayIndex;
+            yearPageSize?: number;
+        }>>) => void;
+        setDisabled: (disabled: boolean) => void;
+        setFocusedSection: (section: import("./date-range-picker.types").TngDateRangePickerFocusedSection) => void;
+        setInputText: (text: string) => void;
+        setOpen: (open: boolean) => void;
+        setState: (patch: Readonly<{
+            activeDate?: any;
+            disabled?: boolean;
+            inputText?: string;
+            value?: any;
+            view?: import("./date-range-picker.types").TngCalendarView;
+            visibleMonth?: any;
+        }>) => void;
+        setValue: (value: any) => void;
+        setView: (view: import("./date-range-picker.types").TngCalendarView) => void;
+        setVisibleMonth: (valueOrYear: any, month?: number) => void;
+        setVisibleYear: (year: number) => void;
+        showDaysPanel: () => void;
+        showMonthsPanel: () => void;
+        showYearsPanel: () => void;
+        subscribe: (listener: import("./date-range-picker.types").TngDateRangePickerListener<any>) => () => void;
+        toggleOpen: () => void;
+    }>>;
+    readonly cell: import("@angular/core").InputSignal<Readonly<Readonly<{
+        active: boolean;
+        colIndex: number;
+        date: any;
+        disabled: boolean;
+        focusVisible: boolean;
+        hidden: boolean;
+        id: string;
+        inMonth: boolean;
+        inRange: boolean;
+        label: string;
+        previewRange: boolean;
+        rangeEnd: boolean;
+        rangeStart: boolean;
+        rowIndex: number;
+        selected: boolean;
+        tabindex: -1 | 0;
+        today: boolean;
+    }>>>;
+    private readonly attributes;
+    protected get id(): string | null;
+    protected get role(): string | null;
+    protected get tabindex(): string | null;
+    protected get disabled(): boolean;
+    protected get ariaCurrent(): string | null;
+    protected get ariaDisabled(): string | null;
+    protected get ariaLabel(): string | null;
+    protected get ariaSelected(): string | null;
+    protected get dataActive(): string | null;
+    protected get dataDisabled(): string | null;
+    protected get dataFocused(): string | null;
+    protected get dataFocusVisible(): string | null;
+    protected get dataHidden(): string | null;
+    protected get dataInMonth(): string | null;
+    protected get dataInRange(): string | null;
+    protected get dataOutsideMonth(): string | null;
+    protected get dataPreviewEnd(): string | null;
+    protected get dataPreviewRange(): string | null;
+    protected get dataRangeEnd(): string | null;
+    protected get dataRangeStart(): string | null;
+    protected get dataSelected(): string | null;
+    protected get dataSlot(): string | null;
+    protected get dataToday(): string | null;
+    protected onClick(event: MouseEvent): void;
+    protected onPointerEnter(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TngDateRangePickerDayCell, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TngDateRangePickerDayCell, "button[tngDateRangePickerDayCell]", ["tngDateRangePickerDayCell"], { "cell": { "alias": "tngDateRangePickerDayCell"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+export declare class TngDateRangePickerMonthGrid extends TngDateRangePickerControllerPart {
+    readonly controller: import("@angular/core").InputSignal<Readonly<{
+        clear: () => void;
+        close: (reason?: import("./date-range-picker.types").TngDateRangePickerCloseReason) => void;
+        commitInputText: () => boolean;
+        destroy: () => void;
+        formatDate: (date: any, format?: import("./date-range-picker.types").TngDateFormatToken | string) => string;
+        getOutputs: () => Readonly<{
+            activeDate: any;
+            cells: readonly Readonly<{
+                active: boolean;
+                colIndex: number;
+                date: any;
+                disabled: boolean;
+                focusVisible: boolean;
+                hidden: boolean;
+                id: string;
+                inMonth: boolean;
+                inRange: boolean;
+                label: string;
+                previewRange: boolean;
+                rangeEnd: boolean;
+                rangeStart: boolean;
+                rowIndex: number;
+                selected: boolean;
+                tabindex: -1 | 0;
+                today: boolean;
+            }>[];
+            endDate: any;
+            focusedDate: any;
+            focusedSection: import("./date-range-picker.types").TngDateRangePickerFocusedSection;
+            getCellAttributes: (cellOrDate: any) => TngDateRangePickerAttributeMap;
+            getGridAttributes: () => TngDateRangePickerAttributeMap;
+            getHostAttributes: () => TngDateRangePickerAttributeMap;
+            getMonthAttributes: (monthOrOption: number | Readonly<Readonly<{
+                active: boolean;
+                date: any;
+                disabled: boolean;
+                focusVisible: boolean;
+                id: string;
+                index: number;
+                label: string;
+                selected: boolean;
+                tabindex: -1 | 0;
+            }>>) => TngDateRangePickerAttributeMap;
+            getOverlayAttributes: () => TngDateRangePickerAttributeMap;
+            getTriggerAttributes: () => TngDateRangePickerAttributeMap;
+            getYearAttributes: (yearOrOption: number | Readonly<Readonly<{
+                active: boolean;
+                date: any;
+                disabled: boolean;
+                focusVisible: boolean;
+                id: string;
+                label: string;
+                selected: boolean;
+                tabindex: -1 | 0;
+                year: number;
+            }>>) => TngDateRangePickerAttributeMap;
+            inputText: string;
+            labelMonthYear: string;
+            layout: Readonly<{
+                mode: import("./date-range-picker.types").TngDateRangePickerOverlayMode;
+                offsetX: number;
+                width: number;
+            }>;
+            monthOptions: readonly Readonly<{
+                active: boolean;
+                date: any;
+                disabled: boolean;
+                focusVisible: boolean;
+                id: string;
+                index: number;
+                label: string;
+                selected: boolean;
+                tabindex: -1 | 0;
+            }>[];
+            open: boolean;
+            previewEndDate: any;
+            startDate: any;
+            validationError: string | null;
+            value: import("./date-range-picker.types").TngDateValue<any>;
+            view: import("./date-range-picker.types").TngCalendarView;
+            visibleMonth: any;
+            weekdayLabels: readonly string[];
+            yearOptions: readonly Readonly<{
+                active: boolean;
+                date: any;
+                disabled: boolean;
+                focusVisible: boolean;
+                id: string;
+                label: string;
+                selected: boolean;
+                tabindex: -1 | 0;
+                year: number;
+            }>[];
+        }>;
+        getState: () => Readonly<{
+            activeDate: any;
+            disabled: boolean;
+            endDate: any;
+            focusedDate: any;
+            focusedSection: import("./date-range-picker.types").TngDateRangePickerFocusedSection;
+            inputText: string;
+            lastCloseReason: import("./date-range-picker.types").TngDateRangePickerCloseReason | null;
+            open: boolean;
+            previewEndDate: any;
+            startDate: any;
+            validationError: string | null;
+            value: import("./date-range-picker.types").TngDateValue<any>;
+            view: import("./date-range-picker.types").TngCalendarView;
+            visibleMonth: any;
+        }>;
+        goToNextMonth: () => void;
+        goToPrevMonth: () => void;
+        handleCellClick: (date: any, options?: Readonly<{
+            shiftKey?: boolean;
+        }>) => void;
+        handleCellPointerEnter: (date: any) => void;
+        handleGridKeyDown: (event: Readonly<Pick<KeyboardEvent, "altKey" | "ctrlKey" | "key" | "metaKey" | "preventDefault" | "shiftKey">>) => void;
+        handleMonthGridKeyDown: (event: Readonly<Pick<KeyboardEvent, "altKey" | "ctrlKey" | "key" | "metaKey" | "preventDefault" | "shiftKey">>) => void;
+        handleOverlayKeyDown: (event: Readonly<Pick<KeyboardEvent, "altKey" | "ctrlKey" | "key" | "metaKey" | "preventDefault" | "shiftKey">>) => void;
+        handleTriggerKeyDown: (event: Readonly<Pick<KeyboardEvent, "key" | "preventDefault">>) => void;
+        handleYearGridKeyDown: (event: Readonly<Pick<KeyboardEvent, "altKey" | "ctrlKey" | "key" | "metaKey" | "preventDefault" | "shiftKey">>) => void;
+        nextMonth: () => void;
+        nextYear: () => void;
+        open: () => void;
+        parseInputText: (text: string) => any;
+        prevMonth: () => void;
+        prevYear: () => void;
+        registerOverlay: (element: HTMLElement | null) => void;
+        registerTrigger: (element: HTMLElement | null) => void;
+        selectDate: (date: any, options?: Readonly<{
+            shiftKey?: boolean;
+            trigger?: import("./date-range-picker.types").TngDateRangePickerTrigger;
+        }>) => void;
+        selectMonth: (monthIndex: number) => void;
+        selectYear: (year: number) => void;
+        setActiveDate: (date: any, trigger?: import("./date-range-picker.types").TngDateRangePickerTrigger) => void;
+        setConfig: (config: Partial<Readonly<{
+            adapter?: Readonly<{
+                addDays: (date: any, amount: number) => any;
+                addMonths: (date: any, amount: number) => any;
+                addYears: (date: any, amount: number) => any;
+                compare: (left: any, right: any) => -1 | 0 | 1;
+                createDate: (year: number, month: number, day: number) => any;
+                deserialize?: ((value: unknown, locale?: string) => any) | undefined;
+                endOfMonth: (date: any) => any;
+                format: (date: any, format: import("./date-range-picker.types").TngDateFormatToken | string, locale?: string) => string;
+                getDate: (date: any) => number;
+                getDay: (date: any) => number;
+                getMonth: (date: any) => number;
+                getYear: (date: any) => number;
+                isValid: (date: any) => boolean;
+                parse: (text: string, locale?: string) => any;
+                startOfMonth: (date: any) => any;
+                startOfWeek: (date: any, weekStartsOn: import("./date-range-picker.types").TngWeekdayIndex) => any;
+                today: () => any;
+            }> | undefined;
+            allowManualInput?: boolean;
+            ariaDescribedBy?: string | null;
+            ariaLabel?: string | null;
+            ariaLabelledBy?: string | null;
+            autoCommitView?: boolean;
+            closeOnEscape?: boolean;
+            closeOnOutsideClick?: boolean;
+            closeOnSelect?: boolean;
+            closeOthersOnOpen?: boolean;
+            defaultOpen?: boolean;
+            direction?: import("./date-range-picker.types").TngDateRangePickerDirection;
+            disableDate?: ((date: any) => boolean) | undefined;
+            disabled?: boolean;
+            enableRangeSelection?: boolean;
+            enableTypeahead?: boolean;
+            fixedWeeks?: boolean;
+            focusStrategy?: import("./date-range-picker.types").TngDateRangePickerFocusStrategy;
+            id?: string;
+            initialView?: import("./date-range-picker.types").TngCalendarView;
+            locale?: string;
+            max?: any;
+            maxDate?: any;
+            min?: any;
+            minDate?: any;
+            onPartialInputCommit?: boolean;
+            overlayMode?: import("./date-range-picker.types").TngDateRangePickerOverlayMode;
+            overlayRuntime?: Readonly<{
+                clearLayers: () => void;
+                dispatchKeydown: (event: Readonly<Readonly<{
+                    defaultPrevented?: boolean;
+                    key: string;
+                    preventDefault?: () => void;
+                }>>) => void;
+                dispatchPointerDown: (event: Readonly<Readonly<{
+                    composedPath?: () => readonly unknown[];
+                    defaultPrevented?: boolean;
+                    preventDefault?: () => void;
+                    target: unknown;
+                }>>) => void;
+                dismissById: (id: string, reason: import("@tailng-ui/cdk").TngOverlayDismissReason) => void;
+                getLayerIds: () => readonly string[];
+                isTopLayer: (id: string) => boolean;
+                registerLayer: (layer: Readonly<{
+                    containsTarget?: (target: unknown, path: readonly unknown[]) => boolean;
+                    dismissOnEscape?: boolean;
+                    dismissOnOutsidePointer?: boolean;
+                    id: string;
+                    modal?: boolean;
+                    onDismiss: (reason: import("@tailng-ui/cdk").TngOverlayDismissReason) => void;
+                    priority?: number;
+                }>) => void;
+                unregisterLayer: (id: string) => void;
+            }> | null | undefined;
+            overlaySize?: number;
+            ownerDocument?: Document | null;
+            position?: import("./date-range-picker.types").TngDateRangePickerPosition;
+            preserveViewOnOpenClose?: boolean;
+            restoreFocus?: boolean;
+            showOutsideDays?: boolean;
+            skipDisabled?: boolean;
+            today?: any;
+            trapFocus?: boolean;
+            value?: any;
+            weekStartsOn?: import("./date-range-picker.types").TngWeekdayIndex;
+            yearPageSize?: number;
+        }>>) => void;
+        setDisabled: (disabled: boolean) => void;
+        setFocusedSection: (section: import("./date-range-picker.types").TngDateRangePickerFocusedSection) => void;
+        setInputText: (text: string) => void;
+        setOpen: (open: boolean) => void;
+        setState: (patch: Readonly<{
+            activeDate?: any;
+            disabled?: boolean;
+            inputText?: string;
+            value?: any;
+            view?: import("./date-range-picker.types").TngCalendarView;
+            visibleMonth?: any;
+        }>) => void;
+        setValue: (value: any) => void;
+        setView: (view: import("./date-range-picker.types").TngCalendarView) => void;
+        setVisibleMonth: (valueOrYear: any, month?: number) => void;
+        setVisibleYear: (year: number) => void;
+        showDaysPanel: () => void;
+        showMonthsPanel: () => void;
+        showYearsPanel: () => void;
+        subscribe: (listener: import("./date-range-picker.types").TngDateRangePickerListener<any>) => () => void;
+        toggleOpen: () => void;
+    }>>;
+    protected readonly dataSlot: "date-range-picker-grid";
+    protected readonly role: "grid";
+    protected onKeydown(event: KeyboardEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TngDateRangePickerMonthGrid, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TngDateRangePickerMonthGrid, "[tngDateRangePickerMonthGrid]", ["tngDateRangePickerMonthGrid"], { "controller": { "alias": "tngDateRangePickerMonthGrid"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+export declare class TngDateRangePickerMonthOption extends TngDateRangePickerControllerPart {
+    private readonly monthGrid;
+    readonly controller: Signal<Readonly<{
+        clear: () => void;
+        close: (reason?: import("./date-range-picker.types").TngDateRangePickerCloseReason) => void;
+        commitInputText: () => boolean;
+        destroy: () => void;
+        formatDate: (date: any, format?: import("./date-range-picker.types").TngDateFormatToken | string) => string;
+        getOutputs: () => Readonly<{
+            activeDate: any;
+            cells: readonly Readonly<{
+                active: boolean;
+                colIndex: number;
+                date: any;
+                disabled: boolean;
+                focusVisible: boolean;
+                hidden: boolean;
+                id: string;
+                inMonth: boolean;
+                inRange: boolean;
+                label: string;
+                previewRange: boolean;
+                rangeEnd: boolean;
+                rangeStart: boolean;
+                rowIndex: number;
+                selected: boolean;
+                tabindex: -1 | 0;
+                today: boolean;
+            }>[];
+            endDate: any;
+            focusedDate: any;
+            focusedSection: import("./date-range-picker.types").TngDateRangePickerFocusedSection;
+            getCellAttributes: (cellOrDate: any) => TngDateRangePickerAttributeMap;
+            getGridAttributes: () => TngDateRangePickerAttributeMap;
+            getHostAttributes: () => TngDateRangePickerAttributeMap;
+            getMonthAttributes: (monthOrOption: number | Readonly<Readonly<{
+                active: boolean;
+                date: any;
+                disabled: boolean;
+                focusVisible: boolean;
+                id: string;
+                index: number;
+                label: string;
+                selected: boolean;
+                tabindex: -1 | 0;
+            }>>) => TngDateRangePickerAttributeMap;
+            getOverlayAttributes: () => TngDateRangePickerAttributeMap;
+            getTriggerAttributes: () => TngDateRangePickerAttributeMap;
+            getYearAttributes: (yearOrOption: number | Readonly<Readonly<{
+                active: boolean;
+                date: any;
+                disabled: boolean;
+                focusVisible: boolean;
+                id: string;
+                label: string;
+                selected: boolean;
+                tabindex: -1 | 0;
+                year: number;
+            }>>) => TngDateRangePickerAttributeMap;
+            inputText: string;
+            labelMonthYear: string;
+            layout: Readonly<{
+                mode: import("./date-range-picker.types").TngDateRangePickerOverlayMode;
+                offsetX: number;
+                width: number;
+            }>;
+            monthOptions: readonly Readonly<{
+                active: boolean;
+                date: any;
+                disabled: boolean;
+                focusVisible: boolean;
+                id: string;
+                index: number;
+                label: string;
+                selected: boolean;
+                tabindex: -1 | 0;
+            }>[];
+            open: boolean;
+            previewEndDate: any;
+            startDate: any;
+            validationError: string | null;
+            value: import("./date-range-picker.types").TngDateValue<any>;
+            view: import("./date-range-picker.types").TngCalendarView;
+            visibleMonth: any;
+            weekdayLabels: readonly string[];
+            yearOptions: readonly Readonly<{
+                active: boolean;
+                date: any;
+                disabled: boolean;
+                focusVisible: boolean;
+                id: string;
+                label: string;
+                selected: boolean;
+                tabindex: -1 | 0;
+                year: number;
+            }>[];
+        }>;
+        getState: () => Readonly<{
+            activeDate: any;
+            disabled: boolean;
+            endDate: any;
+            focusedDate: any;
+            focusedSection: import("./date-range-picker.types").TngDateRangePickerFocusedSection;
+            inputText: string;
+            lastCloseReason: import("./date-range-picker.types").TngDateRangePickerCloseReason | null;
+            open: boolean;
+            previewEndDate: any;
+            startDate: any;
+            validationError: string | null;
+            value: import("./date-range-picker.types").TngDateValue<any>;
+            view: import("./date-range-picker.types").TngCalendarView;
+            visibleMonth: any;
+        }>;
+        goToNextMonth: () => void;
+        goToPrevMonth: () => void;
+        handleCellClick: (date: any, options?: Readonly<{
+            shiftKey?: boolean;
+        }>) => void;
+        handleCellPointerEnter: (date: any) => void;
+        handleGridKeyDown: (event: Readonly<Pick<KeyboardEvent, "altKey" | "ctrlKey" | "key" | "metaKey" | "preventDefault" | "shiftKey">>) => void;
+        handleMonthGridKeyDown: (event: Readonly<Pick<KeyboardEvent, "altKey" | "ctrlKey" | "key" | "metaKey" | "preventDefault" | "shiftKey">>) => void;
+        handleOverlayKeyDown: (event: Readonly<Pick<KeyboardEvent, "altKey" | "ctrlKey" | "key" | "metaKey" | "preventDefault" | "shiftKey">>) => void;
+        handleTriggerKeyDown: (event: Readonly<Pick<KeyboardEvent, "key" | "preventDefault">>) => void;
+        handleYearGridKeyDown: (event: Readonly<Pick<KeyboardEvent, "altKey" | "ctrlKey" | "key" | "metaKey" | "preventDefault" | "shiftKey">>) => void;
+        nextMonth: () => void;
+        nextYear: () => void;
+        open: () => void;
+        parseInputText: (text: string) => any;
+        prevMonth: () => void;
+        prevYear: () => void;
+        registerOverlay: (element: HTMLElement | null) => void;
+        registerTrigger: (element: HTMLElement | null) => void;
+        selectDate: (date: any, options?: Readonly<{
+            shiftKey?: boolean;
+            trigger?: import("./date-range-picker.types").TngDateRangePickerTrigger;
+        }>) => void;
+        selectMonth: (monthIndex: number) => void;
+        selectYear: (year: number) => void;
+        setActiveDate: (date: any, trigger?: import("./date-range-picker.types").TngDateRangePickerTrigger) => void;
+        setConfig: (config: Partial<Readonly<{
+            adapter?: Readonly<{
+                addDays: (date: any, amount: number) => any;
+                addMonths: (date: any, amount: number) => any;
+                addYears: (date: any, amount: number) => any;
+                compare: (left: any, right: any) => -1 | 0 | 1;
+                createDate: (year: number, month: number, day: number) => any;
+                deserialize?: ((value: unknown, locale?: string) => any) | undefined;
+                endOfMonth: (date: any) => any;
+                format: (date: any, format: import("./date-range-picker.types").TngDateFormatToken | string, locale?: string) => string;
+                getDate: (date: any) => number;
+                getDay: (date: any) => number;
+                getMonth: (date: any) => number;
+                getYear: (date: any) => number;
+                isValid: (date: any) => boolean;
+                parse: (text: string, locale?: string) => any;
+                startOfMonth: (date: any) => any;
+                startOfWeek: (date: any, weekStartsOn: import("./date-range-picker.types").TngWeekdayIndex) => any;
+                today: () => any;
+            }> | undefined;
+            allowManualInput?: boolean;
+            ariaDescribedBy?: string | null;
+            ariaLabel?: string | null;
+            ariaLabelledBy?: string | null;
+            autoCommitView?: boolean;
+            closeOnEscape?: boolean;
+            closeOnOutsideClick?: boolean;
+            closeOnSelect?: boolean;
+            closeOthersOnOpen?: boolean;
+            defaultOpen?: boolean;
+            direction?: import("./date-range-picker.types").TngDateRangePickerDirection;
+            disableDate?: ((date: any) => boolean) | undefined;
+            disabled?: boolean;
+            enableRangeSelection?: boolean;
+            enableTypeahead?: boolean;
+            fixedWeeks?: boolean;
+            focusStrategy?: import("./date-range-picker.types").TngDateRangePickerFocusStrategy;
+            id?: string;
+            initialView?: import("./date-range-picker.types").TngCalendarView;
+            locale?: string;
+            max?: any;
+            maxDate?: any;
+            min?: any;
+            minDate?: any;
+            onPartialInputCommit?: boolean;
+            overlayMode?: import("./date-range-picker.types").TngDateRangePickerOverlayMode;
+            overlayRuntime?: Readonly<{
+                clearLayers: () => void;
+                dispatchKeydown: (event: Readonly<Readonly<{
+                    defaultPrevented?: boolean;
+                    key: string;
+                    preventDefault?: () => void;
+                }>>) => void;
+                dispatchPointerDown: (event: Readonly<Readonly<{
+                    composedPath?: () => readonly unknown[];
+                    defaultPrevented?: boolean;
+                    preventDefault?: () => void;
+                    target: unknown;
+                }>>) => void;
+                dismissById: (id: string, reason: import("@tailng-ui/cdk").TngOverlayDismissReason) => void;
+                getLayerIds: () => readonly string[];
+                isTopLayer: (id: string) => boolean;
+                registerLayer: (layer: Readonly<{
+                    containsTarget?: (target: unknown, path: readonly unknown[]) => boolean;
+                    dismissOnEscape?: boolean;
+                    dismissOnOutsidePointer?: boolean;
+                    id: string;
+                    modal?: boolean;
+                    onDismiss: (reason: import("@tailng-ui/cdk").TngOverlayDismissReason) => void;
+                    priority?: number;
+                }>) => void;
+                unregisterLayer: (id: string) => void;
+            }> | null | undefined;
+            overlaySize?: number;
+            ownerDocument?: Document | null;
+            position?: import("./date-range-picker.types").TngDateRangePickerPosition;
+            preserveViewOnOpenClose?: boolean;
+            restoreFocus?: boolean;
+            showOutsideDays?: boolean;
+            skipDisabled?: boolean;
+            today?: any;
+            trapFocus?: boolean;
+            value?: any;
+            weekStartsOn?: import("./date-range-picker.types").TngWeekdayIndex;
+            yearPageSize?: number;
+        }>>) => void;
+        setDisabled: (disabled: boolean) => void;
+        setFocusedSection: (section: import("./date-range-picker.types").TngDateRangePickerFocusedSection) => void;
+        setInputText: (text: string) => void;
+        setOpen: (open: boolean) => void;
+        setState: (patch: Readonly<{
+            activeDate?: any;
+            disabled?: boolean;
+            inputText?: string;
+            value?: any;
+            view?: import("./date-range-picker.types").TngCalendarView;
+            visibleMonth?: any;
+        }>) => void;
+        setValue: (value: any) => void;
+        setView: (view: import("./date-range-picker.types").TngCalendarView) => void;
+        setVisibleMonth: (valueOrYear: any, month?: number) => void;
+        setVisibleYear: (year: number) => void;
+        showDaysPanel: () => void;
+        showMonthsPanel: () => void;
+        showYearsPanel: () => void;
+        subscribe: (listener: import("./date-range-picker.types").TngDateRangePickerListener<any>) => () => void;
+        toggleOpen: () => void;
+    }>>;
+    readonly option: import("@angular/core").InputSignal<Readonly<Readonly<{
+        active: boolean;
+        date: any;
+        disabled: boolean;
+        focusVisible: boolean;
+        id: string;
+        index: number;
+        label: string;
+        selected: boolean;
+        tabindex: -1 | 0;
+    }>>>;
+    private readonly attributes;
+    protected get id(): string | null;
+    protected get role(): string | null;
+    protected get tabindex(): string | null;
+    protected get disabled(): boolean;
+    protected get ariaDisabled(): string | null;
+    protected get ariaSelected(): string | null;
+    protected get dataActive(): string | null;
+    protected get dataDisabled(): string | null;
+    protected get dataFocusVisible(): string | null;
+    protected get dataSelected(): string | null;
+    protected get dataSlot(): string | null;
+    protected onClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TngDateRangePickerMonthOption, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TngDateRangePickerMonthOption, "button[tngDateRangePickerMonthOption]", ["tngDateRangePickerMonthOption"], { "option": { "alias": "tngDateRangePickerMonthOption"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+export declare class TngDateRangePickerYearGrid extends TngDateRangePickerControllerPart {
+    readonly controller: import("@angular/core").InputSignal<Readonly<{
+        clear: () => void;
+        close: (reason?: import("./date-range-picker.types").TngDateRangePickerCloseReason) => void;
+        commitInputText: () => boolean;
+        destroy: () => void;
+        formatDate: (date: any, format?: import("./date-range-picker.types").TngDateFormatToken | string) => string;
+        getOutputs: () => Readonly<{
+            activeDate: any;
+            cells: readonly Readonly<{
+                active: boolean;
+                colIndex: number;
+                date: any;
+                disabled: boolean;
+                focusVisible: boolean;
+                hidden: boolean;
+                id: string;
+                inMonth: boolean;
+                inRange: boolean;
+                label: string;
+                previewRange: boolean;
+                rangeEnd: boolean;
+                rangeStart: boolean;
+                rowIndex: number;
+                selected: boolean;
+                tabindex: -1 | 0;
+                today: boolean;
+            }>[];
+            endDate: any;
+            focusedDate: any;
+            focusedSection: import("./date-range-picker.types").TngDateRangePickerFocusedSection;
+            getCellAttributes: (cellOrDate: any) => TngDateRangePickerAttributeMap;
+            getGridAttributes: () => TngDateRangePickerAttributeMap;
+            getHostAttributes: () => TngDateRangePickerAttributeMap;
+            getMonthAttributes: (monthOrOption: number | Readonly<Readonly<{
+                active: boolean;
+                date: any;
+                disabled: boolean;
+                focusVisible: boolean;
+                id: string;
+                index: number;
+                label: string;
+                selected: boolean;
+                tabindex: -1 | 0;
+            }>>) => TngDateRangePickerAttributeMap;
+            getOverlayAttributes: () => TngDateRangePickerAttributeMap;
+            getTriggerAttributes: () => TngDateRangePickerAttributeMap;
+            getYearAttributes: (yearOrOption: number | Readonly<Readonly<{
+                active: boolean;
+                date: any;
+                disabled: boolean;
+                focusVisible: boolean;
+                id: string;
+                label: string;
+                selected: boolean;
+                tabindex: -1 | 0;
+                year: number;
+            }>>) => TngDateRangePickerAttributeMap;
+            inputText: string;
+            labelMonthYear: string;
+            layout: Readonly<{
+                mode: import("./date-range-picker.types").TngDateRangePickerOverlayMode;
+                offsetX: number;
+                width: number;
+            }>;
+            monthOptions: readonly Readonly<{
+                active: boolean;
+                date: any;
+                disabled: boolean;
+                focusVisible: boolean;
+                id: string;
+                index: number;
+                label: string;
+                selected: boolean;
+                tabindex: -1 | 0;
+            }>[];
+            open: boolean;
+            previewEndDate: any;
+            startDate: any;
+            validationError: string | null;
+            value: import("./date-range-picker.types").TngDateValue<any>;
+            view: import("./date-range-picker.types").TngCalendarView;
+            visibleMonth: any;
+            weekdayLabels: readonly string[];
+            yearOptions: readonly Readonly<{
+                active: boolean;
+                date: any;
+                disabled: boolean;
+                focusVisible: boolean;
+                id: string;
+                label: string;
+                selected: boolean;
+                tabindex: -1 | 0;
+                year: number;
+            }>[];
+        }>;
+        getState: () => Readonly<{
+            activeDate: any;
+            disabled: boolean;
+            endDate: any;
+            focusedDate: any;
+            focusedSection: import("./date-range-picker.types").TngDateRangePickerFocusedSection;
+            inputText: string;
+            lastCloseReason: import("./date-range-picker.types").TngDateRangePickerCloseReason | null;
+            open: boolean;
+            previewEndDate: any;
+            startDate: any;
+            validationError: string | null;
+            value: import("./date-range-picker.types").TngDateValue<any>;
+            view: import("./date-range-picker.types").TngCalendarView;
+            visibleMonth: any;
+        }>;
+        goToNextMonth: () => void;
+        goToPrevMonth: () => void;
+        handleCellClick: (date: any, options?: Readonly<{
+            shiftKey?: boolean;
+        }>) => void;
+        handleCellPointerEnter: (date: any) => void;
+        handleGridKeyDown: (event: Readonly<Pick<KeyboardEvent, "altKey" | "ctrlKey" | "key" | "metaKey" | "preventDefault" | "shiftKey">>) => void;
+        handleMonthGridKeyDown: (event: Readonly<Pick<KeyboardEvent, "altKey" | "ctrlKey" | "key" | "metaKey" | "preventDefault" | "shiftKey">>) => void;
+        handleOverlayKeyDown: (event: Readonly<Pick<KeyboardEvent, "altKey" | "ctrlKey" | "key" | "metaKey" | "preventDefault" | "shiftKey">>) => void;
+        handleTriggerKeyDown: (event: Readonly<Pick<KeyboardEvent, "key" | "preventDefault">>) => void;
+        handleYearGridKeyDown: (event: Readonly<Pick<KeyboardEvent, "altKey" | "ctrlKey" | "key" | "metaKey" | "preventDefault" | "shiftKey">>) => void;
+        nextMonth: () => void;
+        nextYear: () => void;
+        open: () => void;
+        parseInputText: (text: string) => any;
+        prevMonth: () => void;
+        prevYear: () => void;
+        registerOverlay: (element: HTMLElement | null) => void;
+        registerTrigger: (element: HTMLElement | null) => void;
+        selectDate: (date: any, options?: Readonly<{
+            shiftKey?: boolean;
+            trigger?: import("./date-range-picker.types").TngDateRangePickerTrigger;
+        }>) => void;
+        selectMonth: (monthIndex: number) => void;
+        selectYear: (year: number) => void;
+        setActiveDate: (date: any, trigger?: import("./date-range-picker.types").TngDateRangePickerTrigger) => void;
+        setConfig: (config: Partial<Readonly<{
+            adapter?: Readonly<{
+                addDays: (date: any, amount: number) => any;
+                addMonths: (date: any, amount: number) => any;
+                addYears: (date: any, amount: number) => any;
+                compare: (left: any, right: any) => -1 | 0 | 1;
+                createDate: (year: number, month: number, day: number) => any;
+                deserialize?: ((value: unknown, locale?: string) => any) | undefined;
+                endOfMonth: (date: any) => any;
+                format: (date: any, format: import("./date-range-picker.types").TngDateFormatToken | string, locale?: string) => string;
+                getDate: (date: any) => number;
+                getDay: (date: any) => number;
+                getMonth: (date: any) => number;
+                getYear: (date: any) => number;
+                isValid: (date: any) => boolean;
+                parse: (text: string, locale?: string) => any;
+                startOfMonth: (date: any) => any;
+                startOfWeek: (date: any, weekStartsOn: import("./date-range-picker.types").TngWeekdayIndex) => any;
+                today: () => any;
+            }> | undefined;
+            allowManualInput?: boolean;
+            ariaDescribedBy?: string | null;
+            ariaLabel?: string | null;
+            ariaLabelledBy?: string | null;
+            autoCommitView?: boolean;
+            closeOnEscape?: boolean;
+            closeOnOutsideClick?: boolean;
+            closeOnSelect?: boolean;
+            closeOthersOnOpen?: boolean;
+            defaultOpen?: boolean;
+            direction?: import("./date-range-picker.types").TngDateRangePickerDirection;
+            disableDate?: ((date: any) => boolean) | undefined;
+            disabled?: boolean;
+            enableRangeSelection?: boolean;
+            enableTypeahead?: boolean;
+            fixedWeeks?: boolean;
+            focusStrategy?: import("./date-range-picker.types").TngDateRangePickerFocusStrategy;
+            id?: string;
+            initialView?: import("./date-range-picker.types").TngCalendarView;
+            locale?: string;
+            max?: any;
+            maxDate?: any;
+            min?: any;
+            minDate?: any;
+            onPartialInputCommit?: boolean;
+            overlayMode?: import("./date-range-picker.types").TngDateRangePickerOverlayMode;
+            overlayRuntime?: Readonly<{
+                clearLayers: () => void;
+                dispatchKeydown: (event: Readonly<Readonly<{
+                    defaultPrevented?: boolean;
+                    key: string;
+                    preventDefault?: () => void;
+                }>>) => void;
+                dispatchPointerDown: (event: Readonly<Readonly<{
+                    composedPath?: () => readonly unknown[];
+                    defaultPrevented?: boolean;
+                    preventDefault?: () => void;
+                    target: unknown;
+                }>>) => void;
+                dismissById: (id: string, reason: import("@tailng-ui/cdk").TngOverlayDismissReason) => void;
+                getLayerIds: () => readonly string[];
+                isTopLayer: (id: string) => boolean;
+                registerLayer: (layer: Readonly<{
+                    containsTarget?: (target: unknown, path: readonly unknown[]) => boolean;
+                    dismissOnEscape?: boolean;
+                    dismissOnOutsidePointer?: boolean;
+                    id: string;
+                    modal?: boolean;
+                    onDismiss: (reason: import("@tailng-ui/cdk").TngOverlayDismissReason) => void;
+                    priority?: number;
+                }>) => void;
+                unregisterLayer: (id: string) => void;
+            }> | null | undefined;
+            overlaySize?: number;
+            ownerDocument?: Document | null;
+            position?: import("./date-range-picker.types").TngDateRangePickerPosition;
+            preserveViewOnOpenClose?: boolean;
+            restoreFocus?: boolean;
+            showOutsideDays?: boolean;
+            skipDisabled?: boolean;
+            today?: any;
+            trapFocus?: boolean;
+            value?: any;
+            weekStartsOn?: import("./date-range-picker.types").TngWeekdayIndex;
+            yearPageSize?: number;
+        }>>) => void;
+        setDisabled: (disabled: boolean) => void;
+        setFocusedSection: (section: import("./date-range-picker.types").TngDateRangePickerFocusedSection) => void;
+        setInputText: (text: string) => void;
+        setOpen: (open: boolean) => void;
+        setState: (patch: Readonly<{
+            activeDate?: any;
+            disabled?: boolean;
+            inputText?: string;
+            value?: any;
+            view?: import("./date-range-picker.types").TngCalendarView;
+            visibleMonth?: any;
+        }>) => void;
+        setValue: (value: any) => void;
+        setView: (view: import("./date-range-picker.types").TngCalendarView) => void;
+        setVisibleMonth: (valueOrYear: any, month?: number) => void;
+        setVisibleYear: (year: number) => void;
+        showDaysPanel: () => void;
+        showMonthsPanel: () => void;
+        showYearsPanel: () => void;
+        subscribe: (listener: import("./date-range-picker.types").TngDateRangePickerListener<any>) => () => void;
+        toggleOpen: () => void;
+    }>>;
+    protected readonly dataSlot: "date-range-picker-grid";
+    protected readonly role: "grid";
+    protected onKeydown(event: KeyboardEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TngDateRangePickerYearGrid, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TngDateRangePickerYearGrid, "[tngDateRangePickerYearGrid]", ["tngDateRangePickerYearGrid"], { "controller": { "alias": "tngDateRangePickerYearGrid"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+export declare class TngDateRangePickerYearOption extends TngDateRangePickerControllerPart {
+    private readonly yearGrid;
+    readonly controller: Signal<Readonly<{
+        clear: () => void;
+        close: (reason?: import("./date-range-picker.types").TngDateRangePickerCloseReason) => void;
+        commitInputText: () => boolean;
+        destroy: () => void;
+        formatDate: (date: any, format?: import("./date-range-picker.types").TngDateFormatToken | string) => string;
+        getOutputs: () => Readonly<{
+            activeDate: any;
+            cells: readonly Readonly<{
+                active: boolean;
+                colIndex: number;
+                date: any;
+                disabled: boolean;
+                focusVisible: boolean;
+                hidden: boolean;
+                id: string;
+                inMonth: boolean;
+                inRange: boolean;
+                label: string;
+                previewRange: boolean;
+                rangeEnd: boolean;
+                rangeStart: boolean;
+                rowIndex: number;
+                selected: boolean;
+                tabindex: -1 | 0;
+                today: boolean;
+            }>[];
+            endDate: any;
+            focusedDate: any;
+            focusedSection: import("./date-range-picker.types").TngDateRangePickerFocusedSection;
+            getCellAttributes: (cellOrDate: any) => TngDateRangePickerAttributeMap;
+            getGridAttributes: () => TngDateRangePickerAttributeMap;
+            getHostAttributes: () => TngDateRangePickerAttributeMap;
+            getMonthAttributes: (monthOrOption: number | Readonly<Readonly<{
+                active: boolean;
+                date: any;
+                disabled: boolean;
+                focusVisible: boolean;
+                id: string;
+                index: number;
+                label: string;
+                selected: boolean;
+                tabindex: -1 | 0;
+            }>>) => TngDateRangePickerAttributeMap;
+            getOverlayAttributes: () => TngDateRangePickerAttributeMap;
+            getTriggerAttributes: () => TngDateRangePickerAttributeMap;
+            getYearAttributes: (yearOrOption: number | Readonly<Readonly<{
+                active: boolean;
+                date: any;
+                disabled: boolean;
+                focusVisible: boolean;
+                id: string;
+                label: string;
+                selected: boolean;
+                tabindex: -1 | 0;
+                year: number;
+            }>>) => TngDateRangePickerAttributeMap;
+            inputText: string;
+            labelMonthYear: string;
+            layout: Readonly<{
+                mode: import("./date-range-picker.types").TngDateRangePickerOverlayMode;
+                offsetX: number;
+                width: number;
+            }>;
+            monthOptions: readonly Readonly<{
+                active: boolean;
+                date: any;
+                disabled: boolean;
+                focusVisible: boolean;
+                id: string;
+                index: number;
+                label: string;
+                selected: boolean;
+                tabindex: -1 | 0;
+            }>[];
+            open: boolean;
+            previewEndDate: any;
+            startDate: any;
+            validationError: string | null;
+            value: import("./date-range-picker.types").TngDateValue<any>;
+            view: import("./date-range-picker.types").TngCalendarView;
+            visibleMonth: any;
+            weekdayLabels: readonly string[];
+            yearOptions: readonly Readonly<{
+                active: boolean;
+                date: any;
+                disabled: boolean;
+                focusVisible: boolean;
+                id: string;
+                label: string;
+                selected: boolean;
+                tabindex: -1 | 0;
+                year: number;
+            }>[];
+        }>;
+        getState: () => Readonly<{
+            activeDate: any;
+            disabled: boolean;
+            endDate: any;
+            focusedDate: any;
+            focusedSection: import("./date-range-picker.types").TngDateRangePickerFocusedSection;
+            inputText: string;
+            lastCloseReason: import("./date-range-picker.types").TngDateRangePickerCloseReason | null;
+            open: boolean;
+            previewEndDate: any;
+            startDate: any;
+            validationError: string | null;
+            value: import("./date-range-picker.types").TngDateValue<any>;
+            view: import("./date-range-picker.types").TngCalendarView;
+            visibleMonth: any;
+        }>;
+        goToNextMonth: () => void;
+        goToPrevMonth: () => void;
+        handleCellClick: (date: any, options?: Readonly<{
+            shiftKey?: boolean;
+        }>) => void;
+        handleCellPointerEnter: (date: any) => void;
+        handleGridKeyDown: (event: Readonly<Pick<KeyboardEvent, "altKey" | "ctrlKey" | "key" | "metaKey" | "preventDefault" | "shiftKey">>) => void;
+        handleMonthGridKeyDown: (event: Readonly<Pick<KeyboardEvent, "altKey" | "ctrlKey" | "key" | "metaKey" | "preventDefault" | "shiftKey">>) => void;
+        handleOverlayKeyDown: (event: Readonly<Pick<KeyboardEvent, "altKey" | "ctrlKey" | "key" | "metaKey" | "preventDefault" | "shiftKey">>) => void;
+        handleTriggerKeyDown: (event: Readonly<Pick<KeyboardEvent, "key" | "preventDefault">>) => void;
+        handleYearGridKeyDown: (event: Readonly<Pick<KeyboardEvent, "altKey" | "ctrlKey" | "key" | "metaKey" | "preventDefault" | "shiftKey">>) => void;
+        nextMonth: () => void;
+        nextYear: () => void;
+        open: () => void;
+        parseInputText: (text: string) => any;
+        prevMonth: () => void;
+        prevYear: () => void;
+        registerOverlay: (element: HTMLElement | null) => void;
+        registerTrigger: (element: HTMLElement | null) => void;
+        selectDate: (date: any, options?: Readonly<{
+            shiftKey?: boolean;
+            trigger?: import("./date-range-picker.types").TngDateRangePickerTrigger;
+        }>) => void;
+        selectMonth: (monthIndex: number) => void;
+        selectYear: (year: number) => void;
+        setActiveDate: (date: any, trigger?: import("./date-range-picker.types").TngDateRangePickerTrigger) => void;
+        setConfig: (config: Partial<Readonly<{
+            adapter?: Readonly<{
+                addDays: (date: any, amount: number) => any;
+                addMonths: (date: any, amount: number) => any;
+                addYears: (date: any, amount: number) => any;
+                compare: (left: any, right: any) => -1 | 0 | 1;
+                createDate: (year: number, month: number, day: number) => any;
+                deserialize?: ((value: unknown, locale?: string) => any) | undefined;
+                endOfMonth: (date: any) => any;
+                format: (date: any, format: import("./date-range-picker.types").TngDateFormatToken | string, locale?: string) => string;
+                getDate: (date: any) => number;
+                getDay: (date: any) => number;
+                getMonth: (date: any) => number;
+                getYear: (date: any) => number;
+                isValid: (date: any) => boolean;
+                parse: (text: string, locale?: string) => any;
+                startOfMonth: (date: any) => any;
+                startOfWeek: (date: any, weekStartsOn: import("./date-range-picker.types").TngWeekdayIndex) => any;
+                today: () => any;
+            }> | undefined;
+            allowManualInput?: boolean;
+            ariaDescribedBy?: string | null;
+            ariaLabel?: string | null;
+            ariaLabelledBy?: string | null;
+            autoCommitView?: boolean;
+            closeOnEscape?: boolean;
+            closeOnOutsideClick?: boolean;
+            closeOnSelect?: boolean;
+            closeOthersOnOpen?: boolean;
+            defaultOpen?: boolean;
+            direction?: import("./date-range-picker.types").TngDateRangePickerDirection;
+            disableDate?: ((date: any) => boolean) | undefined;
+            disabled?: boolean;
+            enableRangeSelection?: boolean;
+            enableTypeahead?: boolean;
+            fixedWeeks?: boolean;
+            focusStrategy?: import("./date-range-picker.types").TngDateRangePickerFocusStrategy;
+            id?: string;
+            initialView?: import("./date-range-picker.types").TngCalendarView;
+            locale?: string;
+            max?: any;
+            maxDate?: any;
+            min?: any;
+            minDate?: any;
+            onPartialInputCommit?: boolean;
+            overlayMode?: import("./date-range-picker.types").TngDateRangePickerOverlayMode;
+            overlayRuntime?: Readonly<{
+                clearLayers: () => void;
+                dispatchKeydown: (event: Readonly<Readonly<{
+                    defaultPrevented?: boolean;
+                    key: string;
+                    preventDefault?: () => void;
+                }>>) => void;
+                dispatchPointerDown: (event: Readonly<Readonly<{
+                    composedPath?: () => readonly unknown[];
+                    defaultPrevented?: boolean;
+                    preventDefault?: () => void;
+                    target: unknown;
+                }>>) => void;
+                dismissById: (id: string, reason: import("@tailng-ui/cdk").TngOverlayDismissReason) => void;
+                getLayerIds: () => readonly string[];
+                isTopLayer: (id: string) => boolean;
+                registerLayer: (layer: Readonly<{
+                    containsTarget?: (target: unknown, path: readonly unknown[]) => boolean;
+                    dismissOnEscape?: boolean;
+                    dismissOnOutsidePointer?: boolean;
+                    id: string;
+                    modal?: boolean;
+                    onDismiss: (reason: import("@tailng-ui/cdk").TngOverlayDismissReason) => void;
+                    priority?: number;
+                }>) => void;
+                unregisterLayer: (id: string) => void;
+            }> | null | undefined;
+            overlaySize?: number;
+            ownerDocument?: Document | null;
+            position?: import("./date-range-picker.types").TngDateRangePickerPosition;
+            preserveViewOnOpenClose?: boolean;
+            restoreFocus?: boolean;
+            showOutsideDays?: boolean;
+            skipDisabled?: boolean;
+            today?: any;
+            trapFocus?: boolean;
+            value?: any;
+            weekStartsOn?: import("./date-range-picker.types").TngWeekdayIndex;
+            yearPageSize?: number;
+        }>>) => void;
+        setDisabled: (disabled: boolean) => void;
+        setFocusedSection: (section: import("./date-range-picker.types").TngDateRangePickerFocusedSection) => void;
+        setInputText: (text: string) => void;
+        setOpen: (open: boolean) => void;
+        setState: (patch: Readonly<{
+            activeDate?: any;
+            disabled?: boolean;
+            inputText?: string;
+            value?: any;
+            view?: import("./date-range-picker.types").TngCalendarView;
+            visibleMonth?: any;
+        }>) => void;
+        setValue: (value: any) => void;
+        setView: (view: import("./date-range-picker.types").TngCalendarView) => void;
+        setVisibleMonth: (valueOrYear: any, month?: number) => void;
+        setVisibleYear: (year: number) => void;
+        showDaysPanel: () => void;
+        showMonthsPanel: () => void;
+        showYearsPanel: () => void;
+        subscribe: (listener: import("./date-range-picker.types").TngDateRangePickerListener<any>) => () => void;
+        toggleOpen: () => void;
+    }>>;
+    readonly option: import("@angular/core").InputSignal<Readonly<Readonly<{
+        active: boolean;
+        date: any;
+        disabled: boolean;
+        focusVisible: boolean;
+        id: string;
+        label: string;
+        selected: boolean;
+        tabindex: -1 | 0;
+        year: number;
+    }>>>;
+    private readonly attributes;
+    protected get id(): string | null;
+    protected get role(): string | null;
+    protected get tabindex(): string | null;
+    protected get disabled(): boolean;
+    protected get ariaDisabled(): string | null;
+    protected get ariaSelected(): string | null;
+    protected get dataActive(): string | null;
+    protected get dataDisabled(): string | null;
+    protected get dataFocusVisible(): string | null;
+    protected get dataSelected(): string | null;
+    protected get dataSlot(): string | null;
+    protected onClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TngDateRangePickerYearOption, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TngDateRangePickerYearOption, "button[tngDateRangePickerYearOption]", ["tngDateRangePickerYearOption"], { "option": { "alias": "tngDateRangePickerYearOption"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+export {};
+//# sourceMappingURL=tng-date-range-picker.parts.d.ts.map