ngx-com 0.0.1 → 0.0.4

package/types/ngx-com-components-calendar.d.ts

@@ -0,0 +1,1665 @@
+import * as i0 from '@angular/core';
+import { InjectionToken, InputSignal, TemplateRef, OutputEmitterRef, Signal, WritableSignal, Provider, OnDestroy } from '@angular/core';
+import { VariantProps } from 'class-variance-authority';
+import { ControlValueAccessor, Validator, ValidationErrors } from '@angular/forms';
+
+/**
+ * Calendar shared types and interfaces
+ */
+/** Represents a date range with a start and end date */
+interface DateRange<D> {
+    /** Start of the date range */
+    start: D | null;
+    /** End of the date range */
+    end: D | null;
+}
+/** Factory function to create a DateRange */
+declare function createDateRange<D>(start: D | null, end: D | null): DateRange<D>;
+/** Available calendar views */
+type CalendarView = 'month' | 'year' | 'multi-year';
+/** Cell states for styling */
+type CalendarCellState = 'default' | 'today' | 'selected' | 'range-start' | 'range-middle' | 'range-end' | 'disabled' | 'preview-start' | 'preview-middle' | 'preview-end';
+/** Data structure representing a calendar cell */
+interface CalendarCell<D> {
+    /** The date value this cell represents */
+    value: D;
+    /** Display text for the cell */
+    displayValue: string;
+    /** Accessible label for screen readers */
+    ariaLabel: string;
+    /** Whether this cell is enabled/selectable */
+    enabled: boolean;
+    /** CSS classes to apply (from dateClass input) */
+    cssClasses: string;
+    /** Whether this cell represents today */
+    isToday: boolean;
+    /** Whether this cell is currently selected */
+    isSelected: boolean;
+    /** Whether this cell is the start of a range */
+    isRangeStart: boolean;
+    /** Whether this cell is in the middle of a range */
+    isRangeMiddle: boolean;
+    /** Whether this cell is the end of a range */
+    isRangeEnd: boolean;
+    /** Whether this cell is the start of a preview range */
+    isPreviewStart: boolean;
+    /** Whether this cell is in the middle of a preview range */
+    isPreviewMiddle: boolean;
+    /** Whether this cell is the end of a preview range */
+    isPreviewEnd: boolean;
+    /** Comparison value for keyboard navigation and selection */
+    compareValue: number;
+}
+/** Configuration for creating a calendar cell */
+interface CalendarCellConfig<D> {
+    value: D;
+    displayValue: string;
+    ariaLabel: string;
+    enabled?: boolean;
+    cssClasses?: string;
+    compareValue: number;
+}
+/** Factory function to create a CalendarCell with defaults */
+declare function createCalendarCell<D>(config: CalendarCellConfig<D>): CalendarCell<D>;
+/** Style format for month and day names */
+type NameStyle = 'long' | 'short' | 'narrow';
+/** Number of days in a week */
+declare const DAYS_PER_WEEK = 7;
+/** Number of weeks displayed in month view */
+declare const WEEKS_PER_MONTH = 6;
+/** Number of years displayed in multi-year view */
+declare const YEARS_PER_PAGE = 24;
+/** Number of rows in multi-year view */
+declare const YEARS_PER_ROW = 4;
+/** Number of months per row in year view */
+declare const MONTHS_PER_ROW = 4;
+/** Function type for custom date filtering */
+type DateFilterFn<D> = (date: D) => boolean;
+/** Function type for applying custom CSS classes to dates */
+type DateClassFn<D> = (date: D, view: CalendarView) => string;
+
+/**
+ * Abstract date adapter class that provides date manipulation operations.
+ * Implement this class to support different date libraries (date-fns, Luxon, Temporal, etc.)
+ */
+declare abstract class DateAdapter<D> {
+    /** The locale to use for formatting. Can be overridden. */
+    locale: string;
+    /** Gets today's date */
+    abstract today(): D;
+    /** Gets the year component of the given date */
+    abstract getYear(date: D): number;
+    /** Gets the month component of the given date (0-indexed, 0 = January) */
+    abstract getMonth(date: D): number;
+    /** Gets the day of month component of the given date */
+    abstract getDate(date: D): number;
+    /** Gets the day of the week (0 = Sunday, 6 = Saturday) */
+    abstract getDayOfWeek(date: D): number;
+    /** Adds the given number of days to the date */
+    abstract addDays(date: D, days: number): D;
+    /** Adds the given number of months to the date */
+    abstract addMonths(date: D, months: number): D;
+    /** Adds the given number of years to the date */
+    abstract addYears(date: D, years: number): D;
+    /** Creates a new date with the given year, month (0-indexed), and day */
+    abstract createDate(year: number, month: number, date: number): D;
+    /** Gets the number of days in the month of the given date */
+    abstract getNumDaysInMonth(date: D): number;
+    /** Gets the first day of the week (0 = Sunday, 1 = Monday, etc.) */
+    abstract getFirstDayOfWeek(): number;
+    /** Gets the names of the months */
+    abstract getMonthNames(style: NameStyle): string[];
+    /** Gets the names of the days of the week */
+    abstract getDayOfWeekNames(style: NameStyle): string[];
+    /** Gets the display name for a year */
+    abstract getYearName(date: D): string;
+    /** Formats the date according to the given format string */
+    abstract format(date: D, displayFormat: string): string;
+    /** Parses a date string into a date object */
+    abstract parse(value: string, parseFormat: string): D | null;
+    /** Checks whether the given date is valid */
+    abstract isValid(date: D): boolean;
+    /** Checks whether two dates are the same day */
+    abstract isSameDay(first: D, second: D): boolean;
+    /** Compares two dates. Returns -1 if first < second, 0 if equal, 1 if first > second */
+    abstract compareDate(first: D, second: D): number;
+    /** Clamps the given date to the specified min/max range */
+    abstract clampDate(date: D, min: D | null, max: D | null): D;
+    /**
+     * Gets the first day of the month for the given date
+     */
+    getFirstDayOfMonth(date: D): D;
+    /**
+     * Checks whether two dates are in the same month and year
+     */
+    isSameMonthAndYear(first: D, second: D): boolean;
+    /**
+     * Checks whether the given date is within the specified range
+     */
+    isDateInRange(date: D, start: D | null, end: D | null): boolean;
+    /**
+     * Gets a unique identifier for the date (useful for trackBy)
+     */
+    getId(date: D): string;
+    /**
+     * Sets the locale for the adapter
+     */
+    setLocale(locale: string): void;
+}
+/** Injection token for the DateAdapter */
+declare const DATE_ADAPTER: InjectionToken<DateAdapter<unknown>>;
+
+/**
+ * DateAdapter implementation using the native JavaScript Date object.
+ * This is the default adapter shipped with the library.
+ */
+declare class NativeDateAdapter extends DateAdapter<Date> {
+    private readonly localeId;
+    constructor();
+    today(): Date;
+    getYear(date: Date): number;
+    getMonth(date: Date): number;
+    getDate(date: Date): number;
+    getDayOfWeek(date: Date): number;
+    addDays(date: Date, days: number): Date;
+    addMonths(date: Date, months: number): Date;
+    addYears(date: Date, years: number): Date;
+    createDate(year: number, month: number, day: number): Date;
+    getNumDaysInMonth(date: Date): number;
+    getFirstDayOfWeek(): number;
+    setLocale(locale: string): void;
+    getMonthNames(style: NameStyle): string[];
+    getDayOfWeekNames(style: NameStyle): string[];
+    getYearName(date: Date): string;
+    format(date: Date, displayFormat: string): string;
+    parse(value: string, _parseFormat: string): Date | null;
+    isValid(date: Date): boolean;
+    isSameDay(first: Date, second: Date): boolean;
+    compareDate(first: Date, second: Date): number;
+    clampDate(date: Date, min: Date | null, max: Date | null): Date;
+    /**
+     * Strips the time component from a date, returning midnight
+     */
+    private stripTime;
+    /**
+     * Gets the number of days in a specific month
+     */
+    private getDaysInMonth;
+    /**
+     * Parses a format string into Intl.DateTimeFormat options
+     */
+    private parseFormatString;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NativeDateAdapter, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NativeDateAdapter>;
+}
+
+type CellView = 'month' | 'year' | 'multi-year';
+type CellState = 'default' | 'today' | 'selected' | 'range-start' | 'range-middle' | 'range-end' | 'preview-start' | 'preview-middle' | 'preview-end' | 'disabled';
+type WrapperRange = 'none' | 'start' | 'middle' | 'end' | 'single';
+/**
+ * CVA variants for calendar cell styling.
+ * Uses semantic theme tokens for consistent cross-theme styling.
+ *
+ * @tokens `--color-ring`, `--color-foreground`, `--color-muted`,
+ *         `--color-primary`, `--color-primary-foreground`, `--color-primary-hover`,
+ *         `--color-primary-subtle`, `--color-primary-subtle-foreground`,
+ *         `--color-disabled-foreground`, `--radius-calendar-cell`
+ */
+declare const calendarCellVariants: (props?: {
+    view?: CellView;
+    state?: CellState;
+    outside?: boolean;
+}) => string;
+type CalendarCellVariants = {
+    view?: CellView;
+    state?: CellState;
+    outside?: boolean;
+};
+/**
+ * CVA variants for the calendar cell wrapper (used for range backgrounds)
+ *
+ * @tokens `--color-primary-subtle`
+ */
+declare const calendarCellWrapperVariants: (props?: {
+    range?: WrapperRange | undefined;
+}) => string;
+type CalendarCellWrapperVariants = {
+    range?: WrapperRange | undefined;
+};
+
+type ButtonType = 'navigation' | 'period';
+/**
+ * CVA variants for the calendar header container.
+ */
+declare const calendarHeaderVariants: () => string;
+type CalendarHeaderVariants = Record<string, never>;
+/**
+ * CVA variants for the calendar header buttons.
+ *
+ * @tokens `--color-foreground`, `--color-ring`, `--color-muted`,
+ *         `--color-disabled-foreground`, `--radius-calendar-cell`
+ */
+declare const calendarHeaderButtonVariants: (props?: {
+    type?: ButtonType;
+}) => string;
+type CalendarHeaderButtonVariants = {
+    type?: ButtonType;
+};
+
+/**
+ * CVA variants for the main calendar container.
+ *
+ * @tokens `--color-background`, `--color-border-subtle`, `--radius-calendar`
+ */
+declare const calendarVariants: (props?: {
+    bordered?: boolean;
+}) => string;
+type CalendarVariants = VariantProps<typeof calendarVariants>;
+
+/**
+ * Creates a 2D grid from a flat array of items.
+ *
+ * @param items The flat array of items to arrange into a grid
+ * @param columns Number of columns per row
+ * @returns 2D array where each inner array is a row
+ */
+declare function createGrid<T>(items: T[], columns: number): T[][];
+/**
+ * Calculates the new index when navigating a grid with arrow keys.
+ *
+ * @param currentIndex Current position in the flat array
+ * @param direction Navigation direction ('left' | 'right' | 'up' | 'down')
+ * @param totalItems Total number of items in the grid
+ * @param columns Number of columns per row
+ * @returns New index or null if navigation would go out of bounds
+ */
+declare function navigateGrid(currentIndex: number, direction: 'left' | 'right' | 'up' | 'down', totalItems: number, columns: number): number | null;
+/**
+ * Weekday header information for the month view.
+ */
+interface WeekdayHeader {
+    /** Full label for the weekday (used in aria-label) */
+    label: string;
+    /** Narrow/abbreviated label (displayed in the header cell) */
+    narrow: string;
+}
+/**
+ * Gets weekday headers for the calendar month view.
+ * The headers are ordered starting from the first day of the week.
+ *
+ * @param adapter Date adapter to use for getting weekday names
+ * @param style Style for the full label ('long' | 'short' | 'narrow')
+ * @param firstDayOfWeek Optional override for first day of week (0=Sun, 1=Mon, ..., 6=Sat)
+ * @returns Array of weekday headers starting from first day of week
+ */
+declare function getWeekdayHeaders<D>(adapter: DateAdapter<D>, style?: NameStyle, firstDayOfWeek?: number): WeekdayHeader[];
+/**
+ * Checks whether a date should be disabled based on constraints.
+ *
+ * @param date The date to check
+ * @param minDate Minimum allowed date (inclusive)
+ * @param maxDate Maximum allowed date (inclusive)
+ * @param dateFilter Custom filter function
+ * @param adapter Date adapter for comparisons
+ * @returns true if the date should be disabled
+ */
+declare function isDateDisabled<D>(date: D, minDate: D | null, maxDate: D | null, dateFilter: ((d: D) => boolean) | null, adapter: DateAdapter<D>): boolean;
+/**
+ * Checks whether a month should be disabled based on constraints.
+ * A month is disabled if ALL days in that month are disabled.
+ *
+ * @param year The year of the month to check
+ * @param month The month to check (0-indexed)
+ * @param minDate Minimum allowed date
+ * @param maxDate Maximum allowed date
+ * @param adapter Date adapter for date operations
+ * @returns true if the entire month should be disabled
+ */
+declare function isMonthDisabled<D>(year: number, month: number, minDate: D | null, maxDate: D | null, adapter: DateAdapter<D>): boolean;
+/**
+ * Checks whether a year should be disabled based on constraints.
+ * A year is disabled if ALL months in that year are disabled.
+ *
+ * @param year The year to check
+ * @param minDate Minimum allowed date
+ * @param maxDate Maximum allowed date
+ * @param adapter Date adapter for date operations
+ * @returns true if the entire year should be disabled
+ */
+declare function isYearDisabled<D>(year: number, minDate: D | null, maxDate: D | null, adapter: DateAdapter<D>): boolean;
+/**
+ * Gets the starting year for the multi-year view grid.
+ * Aligns the year to be at the start of a YEARS_PER_PAGE block.
+ *
+ * @param activeYear The currently active year
+ * @param yearsPerPage Number of years shown per page (default 24)
+ * @returns The first year of the multi-year page
+ */
+declare function getMultiYearStartingYear(activeYear: number, yearsPerPage?: number): number;
+
+/** Event emitted when a navigation key is pressed */
+interface CalendarCellKeyNavEvent<D> {
+    direction: string;
+    cell: CalendarCell<D>;
+}
+/**
+ * A single cell in the calendar grid.
+ * This is a shared, stateless component used across all calendar views.
+ *
+ * @example
+ * ```html
+ * <com-calendar-cell
+ *   [cell]="dayCell"
+ *   [view]="'month'"
+ *   (selected)="onSelect($event)"
+ * />
+ * ```
+ *
+ * @tokens `--color-ring`, `--color-foreground`, `--color-muted`, `--color-muted-foreground`,
+ *         `--color-primary`, `--color-primary-foreground`, `--color-primary-hover`,
+ *         `--color-primary-subtle`, `--color-primary-subtle-foreground`,
+ *         `--color-disabled-foreground`, `--radius-calendar-cell`
+ */
+declare class ComCalendarCell<D> {
+    /** Reference to the button element for focus management */
+    private readonly buttonRef;
+    /** The cell data to render */
+    readonly cell: InputSignal<CalendarCell<D>>;
+    /** The current calendar view */
+    readonly view: InputSignal<CalendarView>;
+    /** Whether this cell is outside the current month (for month view) */
+    readonly outside: InputSignal<boolean>;
+    /** Tab index for keyboard navigation (-1 for not focusable, 0 for focusable) */
+    readonly tabindex: InputSignal<number>;
+    /** Custom template for cell content */
+    readonly cellTemplate: InputSignal<TemplateRef<{
+        $implicit: CalendarCell<D>;
+    }> | null>;
+    /** Emitted when the cell is selected */
+    readonly selected: OutputEmitterRef<CalendarCell<D>>;
+    /** Emitted when the cell is focused */
+    readonly focused: OutputEmitterRef<CalendarCell<D>>;
+    /** Emitted when the mouse enters the cell (for range preview) */
+    readonly previewed: OutputEmitterRef<CalendarCell<D>>;
+    /** Emitted when a navigation key is pressed */
+    readonly keyNav: OutputEmitterRef<CalendarCellKeyNavEvent<D>>;
+    /** Computed cell state for styling */
+    protected readonly cellState: Signal<CalendarCellState>;
+    /** Computed wrapper range state */
+    protected readonly wrapperRange: Signal<'none' | 'start' | 'middle' | 'end' | 'single'>;
+    /** Computed CSS classes for the cell button */
+    protected readonly cellClasses: Signal<string>;
+    /** Computed CSS classes for the wrapper div */
+    protected readonly wrapperClasses: Signal<string>;
+    protected onCellClick(): void;
+    protected onKeydown(event: KeyboardEvent): void;
+    protected onMouseEnter(): void;
+    protected onFocus(): void;
+    /** Focuses the button element within this cell */
+    focusButton(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ComCalendarCell<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ComCalendarCell<any>, "com-calendar-cell", never, { "cell": { "alias": "cell"; "required": true; "isSignal": true; }; "view": { "alias": "view"; "required": false; "isSignal": true; }; "outside": { "alias": "outside"; "required": false; "isSignal": true; }; "tabindex": { "alias": "tabindex"; "required": false; "isSignal": true; }; "cellTemplate": { "alias": "cellTemplate"; "required": false; "isSignal": true; }; }, { "selected": "selected"; "focused": "focused"; "previewed": "previewed"; "keyNav": "keyNav"; }, never, never, true, never>;
+}
+
+/**
+ * Navigation header component for the calendar.
+ * Provides prev/next buttons and a clickable period label for view switching.
+ *
+ * @example
+ * ```html
+ * <com-calendar-header
+ *   [periodLabel]="'January 2024'"
+ *   [periodAriaLabel]="'January 2024, click to switch view'"
+ *   [prevDisabled]="false"
+ *   [nextDisabled]="false"
+ *   [canSwitchView]="true"
+ *   (prevClicked)="onPrev()"
+ *   (nextClicked)="onNext()"
+ *   (periodClicked)="onPeriodClick()"
+ * />
+ * ```
+ *
+ * @tokens `--color-foreground`, `--color-ring`, `--color-muted`,
+ *         `--color-disabled-foreground`, `--radius-calendar-cell`
+ */
+declare class ComCalendarHeader {
+    /** Display text (e.g., "January 2024", "2024", "2000 – 2023") */
+    readonly periodLabel: InputSignal<string>;
+    /** Accessible label for period button */
+    readonly periodAriaLabel: InputSignal<string>;
+    /** Accessible label for previous button */
+    readonly prevAriaLabel: InputSignal<string>;
+    /** Accessible label for next button */
+    readonly nextAriaLabel: InputSignal<string>;
+    /** Disable previous button */
+    readonly prevDisabled: InputSignal<boolean>;
+    /** Disable next button */
+    readonly nextDisabled: InputSignal<boolean>;
+    /** Whether clicking period label switches view */
+    readonly canSwitchView: InputSignal<boolean>;
+    /** Emitted when previous button is clicked */
+    readonly prevClicked: OutputEmitterRef<void>;
+    /** Emitted when next button is clicked */
+    readonly nextClicked: OutputEmitterRef<void>;
+    /** Emitted when period label is clicked (switch view) */
+    readonly periodClicked: OutputEmitterRef<void>;
+    /** Computed header container classes */
+    protected readonly headerClasses: Signal<string>;
+    /** Computed navigation button classes */
+    protected readonly navButtonClasses: Signal<string>;
+    /** Computed period button classes */
+    protected readonly periodButtonClasses: Signal<string>;
+    /**
+     * Handles period button click.
+     * Only emits if view switching is allowed.
+     */
+    protected onPeriodClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ComCalendarHeader, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ComCalendarHeader, "com-calendar-header", never, { "periodLabel": { "alias": "periodLabel"; "required": true; "isSignal": true; }; "periodAriaLabel": { "alias": "periodAriaLabel"; "required": true; "isSignal": true; }; "prevAriaLabel": { "alias": "prevAriaLabel"; "required": false; "isSignal": true; }; "nextAriaLabel": { "alias": "nextAriaLabel"; "required": false; "isSignal": true; }; "prevDisabled": { "alias": "prevDisabled"; "required": false; "isSignal": true; }; "nextDisabled": { "alias": "nextDisabled"; "required": false; "isSignal": true; }; "canSwitchView": { "alias": "canSwitchView"; "required": false; "isSignal": true; }; }, { "prevClicked": "prevClicked"; "nextClicked": "nextClicked"; "periodClicked": "periodClicked"; }, never, never, true, never>;
+}
+
+/**
+ * Main calendar orchestrator component.
+ * Composes the calendar header and view components (month, year, multi-year)
+ * with view switching, navigation, and enhanced accessibility.
+ *
+ * @tokens `--color-background`, `--color-foreground`, `--color-border-subtle`,
+ *         `--color-ring`, `--color-muted`, `--color-muted-foreground`,
+ *         `--color-primary`, `--color-primary-foreground`, `--color-primary-hover`,
+ *         `--color-primary-subtle`, `--color-primary-subtle-foreground`,
+ *         `--color-disabled-foreground`
+ *
+ * @example
+ * ```html
+ * <com-calendar
+ *   [activeDate]="activeDate"
+ *   [selected]="selectedDate"
+ *   [minDate]="minDate"
+ *   [maxDate]="maxDate"
+ *   (selectedChange)="onDateSelected($event)"
+ *   (viewChanged)="onViewChanged($event)"
+ * />
+ * ```
+ */
+declare class ComCalendar<D> {
+    /** Date adapter for date operations */
+    private readonly dateAdapter;
+    /** Optional selection strategy for custom selection behaviors */
+    private readonly selectionStrategy;
+    /** Query for month views for cross-grid focus management */
+    private readonly monthViews;
+    /** The date to display and navigate from */
+    readonly activeDate: InputSignal<D | undefined>;
+    /** The currently selected date or date range */
+    readonly selected: InputSignal<D | DateRange<D> | null>;
+    /** Minimum selectable date */
+    readonly minDate: InputSignal<D | null>;
+    /** Maximum selectable date */
+    readonly maxDate: InputSignal<D | null>;
+    /** Custom filter function to disable specific dates */
+    readonly dateFilter: InputSignal<DateFilterFn<D> | null>;
+    /** Custom function to add CSS classes to dates */
+    readonly dateClass: InputSignal<DateClassFn<D> | null>;
+    /** Whether to show the card border and shadow. Set to false when used inside datepicker panel. */
+    readonly bordered: InputSignal<boolean>;
+    /** Initial view to display */
+    readonly startView: InputSignal<CalendarView>;
+    /** Override first day of week (0=Sun, 1=Mon, ..., 6=Sat). Uses locale default if null. */
+    readonly firstDayOfWeek: InputSignal<number | null>;
+    /** Number of months to display side-by-side (1 or 2). Defaults to 2 when RangeSelectionStrategy is used. */
+    readonly monthColumns: InputSignal<number>;
+    /** Computed first day of week (input override or adapter default) */
+    readonly computedFirstDayOfWeek: Signal<number>;
+    /** Effective number of month columns (auto-defaults to 2 for RangeSelectionStrategy) */
+    readonly effectiveMonthColumns: Signal<number>;
+    /** Secondary active date for dual-month display (+1 month from primary) */
+    readonly secondaryActiveDate: Signal<D | null>;
+    /** Custom template for cell content */
+    readonly cellTemplate: InputSignal<TemplateRef<{
+        $implicit: CalendarCell<D>;
+    }> | null>;
+    /** Emitted when a date is selected */
+    readonly selectedChange: OutputEmitterRef<D>;
+    /** Emitted when the view changes */
+    readonly viewChanged: OutputEmitterRef<CalendarView>;
+    /** Emitted when the active date changes */
+    readonly activeDateChange: OutputEmitterRef<D>;
+    /** Current view state (synced from startView input, writable for view switching) */
+    readonly currentView: WritableSignal<CalendarView>;
+    /** Internal active date (synced from activeDate input, writable for navigation) */
+    readonly internalActiveDate: WritableSignal<D>;
+    /** Live announcement for screen readers */
+    readonly liveAnnouncement: WritableSignal<string>;
+    /** Internal selection state managed by strategy (synced from selected input) */
+    readonly internalSelection: WritableSignal<unknown>;
+    /** Currently hovered/previewed date */
+    readonly previewDate: WritableSignal<D | null>;
+    /** Computed preview range from strategy */
+    readonly previewRange: Signal<DateRange<D> | null>;
+    /** Calendar container classes */
+    readonly calendarClasses: Signal<string>;
+    /** Months container classes for single/dual-month layout */
+    readonly monthsContainerClasses: Signal<string>;
+    /** Month names for formatting */
+    private readonly monthNames;
+    /** Period label for the header (e.g., "January 2024", "January – February 2024", "2024", "2000 – 2023") */
+    readonly periodLabel: Signal<string>;
+    /** Accessible label for the period button */
+    readonly periodAriaLabel: Signal<string>;
+    /** Accessible label for the previous button */
+    readonly prevAriaLabel: Signal<string>;
+    /** Accessible label for the next button */
+    readonly nextAriaLabel: Signal<string>;
+    /** Whether the previous button is disabled */
+    readonly prevDisabled: Signal<boolean>;
+    /** Whether the next button is disabled */
+    readonly nextDisabled: Signal<boolean>;
+    /**
+     * Handles previous button click.
+     * Navigates to the previous period based on current view.
+     */
+    onPrevClicked(): void;
+    /**
+     * Handles next button click.
+     * Navigates to the next period based on current view.
+     */
+    onNextClicked(): void;
+    /**
+     * Handles period label click.
+     * Switches to the next higher view (month → year → multi-year).
+     */
+    onPeriodClicked(): void;
+    /**
+     * Handles date selection from month view.
+     * Uses selection strategy if available, otherwise emits directly.
+     */
+    onDateSelected(date: D): void;
+    /**
+     * Handles preview change from views (mouse hover).
+     * Updates the preview date for strategy to compute preview range.
+     */
+    onPreviewChange(date: D | null): void;
+    /**
+     * Handles month selection from year view.
+     * Drills down to month view with the selected month.
+     */
+    onMonthSelected(date: D): void;
+    /**
+     * Handles year selection from multi-year view.
+     * Drills down to year view with the selected year.
+     */
+    onYearSelected(date: D): void;
+    /**
+     * Handles active date change from child views (keyboard navigation).
+     * In dual-month mode, handles cross-grid focus transitions.
+     */
+    onActiveDateChange(date: D, gridIndex?: number): void;
+    /**
+     * Computes a unique compare value from a date for focus management.
+     */
+    private computeCompareValue;
+    /**
+     * Announces a view change to screen readers.
+     */
+    private announceViewChange;
+    /**
+     * Announces navigation to screen readers.
+     */
+    private announceNavigation;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ComCalendar<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ComCalendar<any>, "com-calendar", never, { "activeDate": { "alias": "activeDate"; "required": false; "isSignal": true; }; "selected": { "alias": "selected"; "required": false; "isSignal": true; }; "minDate": { "alias": "minDate"; "required": false; "isSignal": true; }; "maxDate": { "alias": "maxDate"; "required": false; "isSignal": true; }; "dateFilter": { "alias": "dateFilter"; "required": false; "isSignal": true; }; "dateClass": { "alias": "dateClass"; "required": false; "isSignal": true; }; "bordered": { "alias": "bordered"; "required": false; "isSignal": true; }; "startView": { "alias": "startView"; "required": false; "isSignal": true; }; "firstDayOfWeek": { "alias": "firstDayOfWeek"; "required": false; "isSignal": true; }; "monthColumns": { "alias": "monthColumns"; "required": false; "isSignal": true; }; "cellTemplate": { "alias": "cellTemplate"; "required": false; "isSignal": true; }; }, { "selectedChange": "selectedChange"; "viewChanged": "viewChanged"; "activeDateChange": "activeDateChange"; }, never, never, true, never>;
+}
+
+/**
+ * Abstract base class for calendar view components.
+ * Provides shared inputs, outputs, and utility methods for month, year, and multi-year views.
+ *
+ * @tokens None - abstract base class, tokens are defined in concrete view components
+ */
+declare abstract class CalendarViewBase<D> {
+    /** Date adapter for date operations */
+    protected readonly dateAdapter: DateAdapter<D>;
+    /** The date to display and navigate from */
+    readonly activeDate: InputSignal<D>;
+    /** The currently selected date or date range */
+    readonly selected: InputSignal<D | DateRange<D> | null>;
+    /** Minimum selectable date */
+    readonly minDate: InputSignal<D | null>;
+    /** Maximum selectable date */
+    readonly maxDate: InputSignal<D | null>;
+    /** Custom filter function to disable specific dates */
+    readonly dateFilter: InputSignal<DateFilterFn<D> | null>;
+    /** Custom function to add CSS classes to dates */
+    readonly dateClass: InputSignal<DateClassFn<D> | null>;
+    /** Start date for range preview (hover state) */
+    readonly previewStart: InputSignal<D | null>;
+    /** End date for range preview (hover state) */
+    readonly previewEnd: InputSignal<D | null>;
+    /** Custom template for cell content */
+    readonly cellTemplate: InputSignal<TemplateRef<{
+        $implicit: CalendarCell<D>;
+    }> | null>;
+    /** Emitted when a date is selected */
+    readonly selectedChange: OutputEmitterRef<D>;
+    /** Emitted when the active date changes (keyboard navigation) */
+    readonly activeDateChange: OutputEmitterRef<D>;
+    /** Emitted when the preview range changes (mouse hover) */
+    readonly previewChange: OutputEmitterRef<D | null>;
+    /** The calendar view type for this component */
+    protected abstract readonly view: CalendarView;
+    /** Cell components for focus management. Must be implemented by each view using viewChildren. */
+    protected abstract readonly cellComponents: Signal<readonly ComCalendarCell<D>[]>;
+    /** Internal signal for tracking the focused cell's compare value */
+    protected readonly focusedCellValue: WritableSignal<number | null>;
+    /** Signal for pending focus operation (set by focusCell, consumed by afterRender) */
+    protected readonly focusPending: WritableSignal<number | null>;
+    constructor();
+    /**
+     * The grid of cells to display.
+     * Must be implemented by each view to generate the appropriate cells.
+     */
+    abstract readonly cells: Signal<CalendarCell<D>[][]>;
+    /**
+     * Accessible label for the grid (e.g., "January 2024").
+     * Must be implemented by each view.
+     */
+    abstract readonly gridLabel: Signal<string>;
+    /** Today's date for comparison */
+    protected readonly today: Signal<D>;
+    /**
+     * Checks if a date is the currently selected date.
+     */
+    protected isSelected(date: D): boolean;
+    /**
+     * Checks if a date is the start of a selected range.
+     */
+    protected isRangeStart(date: D): boolean;
+    /**
+     * Checks if a date is the end of a selected range.
+     */
+    protected isRangeEnd(date: D): boolean;
+    /**
+     * Checks if a date is in the middle of a selected range.
+     */
+    protected isRangeMiddle(date: D): boolean;
+    /**
+     * Checks if a date is the start of the preview range.
+     */
+    protected isPreviewStart(date: D): boolean;
+    /**
+     * Checks if a date is the end of the preview range.
+     */
+    protected isPreviewEnd(date: D): boolean;
+    /**
+     * Checks if a date is in the middle of the preview range.
+     */
+    protected isPreviewMiddle(date: D): boolean;
+    /**
+     * Type guard to check if a value is a DateRange.
+     */
+    protected isDateRange(value: D | DateRange<D>): value is DateRange<D>;
+    /**
+     * Handles cell selection events.
+     */
+    onCellSelected(cell: CalendarCell<D>): void;
+    /**
+     * Handles cell preview events (mouse hover).
+     */
+    onCellPreviewed(cell: CalendarCell<D>): void;
+    /**
+     * Clears the preview when mouse leaves the grid.
+     */
+    onGridMouseLeave(): void;
+    /**
+     * Handles keyboard navigation within the grid.
+     * Must be implemented by each view to handle view-specific navigation.
+     */
+    abstract onKeyNav(event: {
+        direction: string;
+        cell: CalendarCell<D>;
+    }): void;
+    /**
+     * Checks if a cell should have tabindex="0" (be the focusable cell).
+     */
+    isActiveCell(cell: CalendarCell<D>): boolean;
+    /**
+     * Gets the compare value for the active date.
+     * Must be implemented by each view.
+     */
+    protected abstract getActiveCompareValue(): number;
+    /**
+     * Focuses the cell with the given compare value.
+     * Uses afterRender to ensure DOM is updated before focusing.
+     * Public to allow parent components to manage cross-grid focus in dual-month mode.
+     */
+    focusCell(compareValue: number): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CalendarViewBase<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CalendarViewBase<any>, never, never, { "activeDate": { "alias": "activeDate"; "required": true; "isSignal": true; }; "selected": { "alias": "selected"; "required": false; "isSignal": true; }; "minDate": { "alias": "minDate"; "required": false; "isSignal": true; }; "maxDate": { "alias": "maxDate"; "required": false; "isSignal": true; }; "dateFilter": { "alias": "dateFilter"; "required": false; "isSignal": true; }; "dateClass": { "alias": "dateClass"; "required": false; "isSignal": true; }; "previewStart": { "alias": "previewStart"; "required": false; "isSignal": true; }; "previewEnd": { "alias": "previewEnd"; "required": false; "isSignal": true; }; "cellTemplate": { "alias": "cellTemplate"; "required": false; "isSignal": true; }; }, { "selectedChange": "selectedChange"; "activeDateChange": "activeDateChange"; "previewChange": "previewChange"; }, never, never, true, never>;
+}
+
+/**
+ * Month view component displaying a 7x6 grid of days.
+ * Shows the days of the current month with leading/trailing days from adjacent months.
+ *
+ * @example
+ * ```html
+ * <com-calendar-month-view
+ *   [activeDate]="activeDate()"
+ *   [selected]="selected()"
+ *   (selectedChange)="onDateSelected($event)"
+ *   (activeDateChange)="onActiveDateChange($event)"
+ * />
+ * ```
+ *
+ * @tokens `--color-muted-foreground`
+ */
+declare class ComCalendarMonthView<D> extends CalendarViewBase<D> {
+    protected readonly view: CalendarView;
+    /** Cell components for focus management */
+    protected readonly cellComponents: Signal<readonly ComCalendarCell<D>[]>;
+    /** Override first day of week (0=Sun, 1=Mon, ..., 6=Sat) */
+    readonly firstDayOfWeek: InputSignal<number>;
+    /** Grid index for dual-month display (0=left, 1=right) */
+    readonly gridIndex: InputSignal<number>;
+    /** Weekday header labels */
+    readonly weekdayHeaders: Signal<WeekdayHeader[]>;
+    /** The month being displayed (0-indexed) */
+    readonly displayMonth: Signal<number>;
+    /** The year being displayed */
+    readonly displayYear: Signal<number>;
+    /** Grid of day cells (7 columns x 6 rows = 42 cells) */
+    readonly cells: Signal<CalendarCell<D>[][]>;
+    /** Accessible label for the grid showing month and year */
+    readonly gridLabel: Signal<string>;
+    /** First date of the displayed month */
+    private readonly firstOfMonth;
+    protected getActiveCompareValue(): number;
+    /**
+     * Checks if a cell is outside the current displayed month.
+     */
+    isOutsideMonth(cell: CalendarCell<D>): boolean;
+    /**
+     * Handles keyboard navigation for the month view.
+     * - Arrow left/right: ±1 day
+     * - Arrow up/down: ±7 days (one week)
+     * - Home: First day of week
+     * - End: Last day of week
+     * - PageUp: Previous month
+     * - PageDown: Next month
+     */
+    onKeyNav(event: CalendarCellKeyNavEvent<D>): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ComCalendarMonthView<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ComCalendarMonthView<any>, "com-calendar-month-view", never, { "firstDayOfWeek": { "alias": "firstDayOfWeek"; "required": false; "isSignal": true; }; "gridIndex": { "alias": "gridIndex"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Year view component displaying a 4x3 grid of months.
+ * Allows the user to select a month within the currently active year.
+ *
+ * @example
+ * ```html
+ * <com-calendar-year-view
+ *   [activeDate]="activeDate()"
+ *   [selected]="selected()"
+ *   (selectedChange)="onMonthSelected($event)"
+ *   (activeDateChange)="onActiveMonthChange($event)"
+ * />
+ * ```
+ *
+ * @tokens None - uses ComCalendarCell which provides all token styling
+ */
+declare class ComCalendarYearView<D> extends CalendarViewBase<D> {
+    protected readonly view: CalendarView;
+    /** Cell components for focus management */
+    protected readonly cellComponents: Signal<readonly ComCalendarCell<D>[]>;
+    /** The year being displayed */
+    readonly displayYear: Signal<number>;
+    /** Grid of month cells (4 columns x 3 rows = 12 months) */
+    readonly cells: Signal<CalendarCell<D>[][]>;
+    /** Accessible label for the grid */
+    readonly gridLabel: Signal<string>;
+    protected getActiveCompareValue(): number;
+    /**
+     * Handles keyboard navigation for the year view.
+     * - Arrow left/right: ±1 month
+     * - Arrow up/down: ±4 months (one row)
+     * - Home: January
+     * - End: December
+     * - PageUp: Previous year
+     * - PageDown: Next year
+     */
+    onKeyNav(event: CalendarCellKeyNavEvent<D>): void;
+    private isMonthSelected;
+    private isMonthRangeStart;
+    private isMonthRangeEnd;
+    private isMonthRangeMiddle;
+    private isMonthPreviewStart;
+    private isMonthPreviewEnd;
+    private isMonthPreviewMiddle;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ComCalendarYearView<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ComCalendarYearView<any>, "com-calendar-year-view", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Multi-year view component displaying a 4x6 grid of years (24 years total).
+ * Allows the user to select a year within the displayed range.
+ *
+ * @example
+ * ```html
+ * <com-calendar-multi-year-view
+ *   [activeDate]="activeDate()"
+ *   [selected]="selected()"
+ *   (selectedChange)="onYearSelected($event)"
+ *   (activeDateChange)="onActiveYearChange($event)"
+ * />
+ * ```
+ *
+ * @tokens None - uses ComCalendarCell which provides all token styling
+ */
+declare class ComCalendarMultiYearView<D> extends CalendarViewBase<D> {
+    protected readonly view: CalendarView;
+    /** Cell components for focus management */
+    protected readonly cellComponents: Signal<readonly ComCalendarCell<D>[]>;
+    /** The first year in the displayed range */
+    readonly startYear: Signal<number>;
+    /** The last year in the displayed range */
+    readonly endYear: Signal<number>;
+    /** Grid of year cells (4 columns x 6 rows = 24 years) */
+    readonly cells: Signal<CalendarCell<D>[][]>;
+    /** Accessible label for the grid showing the year range */
+    readonly gridLabel: Signal<string>;
+    protected getActiveCompareValue(): number;
+    /**
+     * Handles keyboard navigation for the multi-year view.
+     * - Arrow left/right: ±1 year
+     * - Arrow up/down: ±4 years (one row)
+     * - Home: First year in range
+     * - End: Last year in range
+     * - PageUp: Previous 24 years
+     * - PageDown: Next 24 years
+     */
+    onKeyNav(event: CalendarCellKeyNavEvent<D>): void;
+    private isYearSelected;
+    private isYearRangeStart;
+    private isYearRangeEnd;
+    private isYearRangeMiddle;
+    private isYearPreviewStart;
+    private isYearPreviewEnd;
+    private isYearPreviewMiddle;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ComCalendarMultiYearView<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ComCalendarMultiYearView<any>, "com-calendar-multi-year-view", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Result returned from a selection strategy's select method.
+ */
+interface SelectionResult<D, S> {
+    /** The new selection value */
+    selection: S;
+    /** Whether the selection is complete (emit to consumer) */
+    isComplete: boolean;
+    /** Optional: dates to highlight during incomplete selection */
+    preview?: DateRange<D> | null;
+}
+/**
+ * Abstract selection strategy that defines how dates are selected and previewed.
+ * Implement this class to create custom selection behaviors.
+ *
+ * @typeParam D - The date type (e.g., Date, Luxon DateTime)
+ * @typeParam S - The selection type (e.g., D | null, DateRange<D>, D[])
+ */
+declare abstract class CalendarSelectionStrategy<D, S = unknown> {
+    /**
+     * Process a date selection. Called when user clicks a date cell.
+     * @param date The clicked date
+     * @param currentSelection The current selection state
+     * @returns Object with new selection and whether selection is complete
+     */
+    abstract select(date: D, currentSelection: S): SelectionResult<D, S>;
+    /**
+     * Create a preview range based on current selection and hovered date.
+     * Used for showing range preview while hovering.
+     * @param activeDate The currently hovered date
+     * @param currentSelection The current selection state
+     * @returns DateRange for preview styling, or null if no preview
+     */
+    abstract createPreview(activeDate: D | null, currentSelection: S): DateRange<D> | null;
+    /**
+     * Check if a date is part of the current selection.
+     * Used for styling cells.
+     */
+    abstract isSelected(date: D, currentSelection: S): boolean;
+    /**
+     * Check if a date is the start of a selected range.
+     */
+    abstract isRangeStart(date: D, currentSelection: S): boolean;
+    /**
+     * Check if a date is the end of a selected range.
+     */
+    abstract isRangeEnd(date: D, currentSelection: S): boolean;
+    /**
+     * Check if a date is in the middle of a selected range.
+     */
+    abstract isRangeMiddle(date: D, currentSelection: S): boolean;
+}
+/** Injection token for the selection strategy */
+declare const CALENDAR_SELECTION_STRATEGY: InjectionToken<CalendarSelectionStrategy<unknown, unknown>>;
+
+/**
+ * Selection strategy for single date selection.
+ *
+ * Behavior:
+ * - Click date → immediately selects it
+ * - No preview range
+ * - Output: single date D
+ *
+ * @example
+ * ```typescript
+ * @Component({
+ *   providers: [
+ *     { provide: CALENDAR_SELECTION_STRATEGY, useClass: SingleSelectionStrategy }
+ *   ],
+ *   template: `<com-calendar (selectedChange)="onSelect($event)" />`
+ * })
+ * export class SinglePickerComponent {
+ *   onSelect(date: Date) {
+ *     console.log('Selected:', date);
+ *   }
+ * }
+ * ```
+ */
+declare class SingleSelectionStrategy<D> extends CalendarSelectionStrategy<D, D | null> {
+    private readonly dateAdapter;
+    select(date: D, _currentSelection: D | null): SelectionResult<D, D | null>;
+    createPreview(_activeDate: D | null, _currentSelection: D | null): DateRange<D> | null;
+    isSelected(date: D, currentSelection: D | null): boolean;
+    isRangeStart(_date: D, _currentSelection: D | null): boolean;
+    isRangeEnd(_date: D, _currentSelection: D | null): boolean;
+    isRangeMiddle(_date: D, _currentSelection: D | null): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SingleSelectionStrategy<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SingleSelectionStrategy<any>>;
+}
+
+/**
+ * Selection strategy for date range selection.
+ *
+ * Behavior:
+ * - First click → sets range start, selection incomplete
+ * - Second click → sets range end, selection complete
+ * - If second date is before first, swap them
+ * - Hovering after first click shows preview range
+ * - Output: DateRange<D>
+ *
+ * @example
+ * ```typescript
+ * @Component({
+ *   providers: [
+ *     { provide: CALENDAR_SELECTION_STRATEGY, useClass: RangeSelectionStrategy }
+ *   ],
+ *   template: `
+ *     <com-calendar
+ *       [selected]="selectedRange()"
+ *       (selectedChange)="onRangeSelect($event)"
+ *     />
+ *   `
+ * })
+ * export class RangePickerComponent {
+ *   selectedRange = signal<DateRange<Date> | null>(null);
+ *
+ *   onRangeSelect(range: DateRange<Date>) {
+ *     this.selectedRange.set(range);
+ *   }
+ * }
+ * ```
+ */
+declare class RangeSelectionStrategy<D> extends CalendarSelectionStrategy<D, DateRange<D> | null> {
+    private readonly dateAdapter;
+    select(date: D, currentSelection: DateRange<D> | null): SelectionResult<D, DateRange<D> | null>;
+    createPreview(activeDate: D | null, currentSelection: DateRange<D> | null): DateRange<D> | null;
+    isSelected(date: D, currentSelection: DateRange<D> | null): boolean;
+    isRangeStart(date: D, currentSelection: DateRange<D> | null): boolean;
+    isRangeEnd(date: D, currentSelection: DateRange<D> | null): boolean;
+    isRangeMiddle(date: D, currentSelection: DateRange<D> | null): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RangeSelectionStrategy<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RangeSelectionStrategy<any>>;
+}
+
+/**
+ * Selection strategy for multiple date selection.
+ *
+ * Behavior:
+ * - Click date → toggles it in/out of selection array
+ * - Each click is complete (emits immediately)
+ * - No preview range
+ * - Output: D[]
+ *
+ * @example
+ * ```typescript
+ * @Component({
+ *   providers: [
+ *     { provide: CALENDAR_SELECTION_STRATEGY, useClass: MultiSelectionStrategy }
+ *   ],
+ *   template: `<com-calendar (selectedChange)="onMultiSelect($event)" />`
+ * })
+ * export class MultiPickerComponent {
+ *   selectedDates = signal<Date[]>([]);
+ *
+ *   onMultiSelect(dates: Date[]) {
+ *     this.selectedDates.set(dates);
+ *   }
+ * }
+ * ```
+ */
+declare class MultiSelectionStrategy<D> extends CalendarSelectionStrategy<D, D[]> {
+    private readonly dateAdapter;
+    select(date: D, currentSelection: D[]): SelectionResult<D, D[]>;
+    createPreview(_activeDate: D | null, _currentSelection: D[]): DateRange<D> | null;
+    isSelected(date: D, currentSelection: D[]): boolean;
+    isRangeStart(_date: D, _currentSelection: D[]): boolean;
+    isRangeEnd(_date: D, _currentSelection: D[]): boolean;
+    isRangeMiddle(_date: D, _currentSelection: D[]): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MultiSelectionStrategy<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MultiSelectionStrategy<any>>;
+}
+
+/**
+ * Selection strategy for week selection.
+ *
+ * Behavior:
+ * - Click any day → selects the entire week containing that day
+ * - Week starts based on DateAdapter.getFirstDayOfWeek()
+ * - Single click completes selection
+ * - Output: DateRange<D> (Monday–Sunday or Sunday–Saturday)
+ *
+ * @example
+ * ```typescript
+ * @Component({
+ *   providers: [
+ *     { provide: CALENDAR_SELECTION_STRATEGY, useClass: WeekSelectionStrategy }
+ *   ],
+ *   template: `<com-calendar (selectedChange)="onWeekSelect($event)" />`
+ * })
+ * export class WeekPickerComponent {
+ *   onWeekSelect(week: DateRange<Date>) {
+ *     console.log('Week:', week.start, 'to', week.end);
+ *   }
+ * }
+ * ```
+ */
+declare class WeekSelectionStrategy<D> extends CalendarSelectionStrategy<D, DateRange<D> | null> {
+    private readonly dateAdapter;
+    select(date: D, _currentSelection: DateRange<D> | null): SelectionResult<D, DateRange<D> | null>;
+    createPreview(activeDate: D | null, _currentSelection: DateRange<D> | null): DateRange<D> | null;
+    isSelected(date: D, currentSelection: DateRange<D> | null): boolean;
+    isRangeStart(date: D, currentSelection: DateRange<D> | null): boolean;
+    isRangeEnd(date: D, currentSelection: DateRange<D> | null): boolean;
+    isRangeMiddle(date: D, currentSelection: DateRange<D> | null): boolean;
+    /** Compute the week range for a given date */
+    private getWeekRange;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WeekSelectionStrategy<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<WeekSelectionStrategy<any>>;
+}
+
+/**
+ * Provides the native JavaScript Date adapter for the calendar.
+ * This is required for the calendar component to work with native Date objects.
+ *
+ * @example
+ * ```typescript
+ * @Component({
+ *   providers: [provideNativeDateAdapter()],
+ * })
+ * export class MyComponent {}
+ * ```
+ */
+declare function provideNativeDateAdapter(): Provider;
+/**
+ * Provides the single selection strategy (default behavior).
+ * Allows selecting one date at a time.
+ *
+ * @example
+ * ```typescript
+ * @Component({
+ *   providers: [
+ *     provideNativeDateAdapter(),
+ *     provideSingleSelectionStrategy(),
+ *   ],
+ * })
+ * export class MyComponent {}
+ * ```
+ */
+declare function provideSingleSelectionStrategy(): Provider;
+/**
+ * Provides the range selection strategy.
+ * Allows selecting a start and end date to create a date range.
+ *
+ * @example
+ * ```typescript
+ * @Component({
+ *   providers: [
+ *     provideNativeDateAdapter(),
+ *     provideRangeSelectionStrategy(),
+ *   ],
+ * })
+ * export class MyComponent {
+ *   range = signal<DateRange<Date> | null>(null);
+ * }
+ * ```
+ */
+declare function provideRangeSelectionStrategy(): Provider;
+/**
+ * Provides the multi selection strategy.
+ * Allows selecting multiple individual dates.
+ *
+ * @example
+ * ```typescript
+ * @Component({
+ *   providers: [
+ *     provideNativeDateAdapter(),
+ *     provideMultiSelectionStrategy(),
+ *   ],
+ * })
+ * export class MyComponent {
+ *   dates = signal<Date[]>([]);
+ * }
+ * ```
+ */
+declare function provideMultiSelectionStrategy(): Provider;
+/**
+ * Provides the week selection strategy.
+ * Allows selecting entire weeks at a time.
+ *
+ * @example
+ * ```typescript
+ * @Component({
+ *   providers: [
+ *     provideNativeDateAdapter(),
+ *     provideWeekSelectionStrategy(),
+ *   ],
+ * })
+ * export class MyComponent {
+ *   range = signal<DateRange<Date> | null>(null);
+ * }
+ * ```
+ */
+declare function provideWeekSelectionStrategy(): Provider;
+
+/**
+ * Types and interfaces for DatePicker and DateRangePicker components.
+ */
+/** Date format preset names */
+type DateFormatPreset = 'short' | 'medium' | 'long' | 'full';
+/** Panel width configuration */
+type DatepickerPanelWidth = 'auto' | 'trigger' | `${number}px` | `${number}rem`;
+/** Size variants for datepicker components */
+type DatepickerSize = 'sm' | 'default' | 'lg';
+/** Visual variant for datepicker trigger */
+type DatepickerVariant = 'default' | 'outline' | 'ghost' | 'filled';
+/** Validation state for datepicker */
+type DatepickerState = 'default' | 'error' | 'success';
+/** Configuration for datepicker footer actions */
+interface DatepickerFooterConfig {
+    /** Show today button */
+    showToday?: boolean;
+    /** Show clear button */
+    showClear?: boolean;
+    /** Custom today button label */
+    todayLabel?: string;
+    /** Custom clear button label */
+    clearLabel?: string;
+}
+/** Value type for DateRangePicker */
+interface DateRangeValue<D> {
+    /** Start date of the range */
+    start: D | null;
+    /** End date of the range */
+    end: D | null;
+}
+/** Creates a DateRangeValue */
+declare function createDateRangeValue<D>(start?: D | null, end?: D | null): DateRangeValue<D>;
+declare function generateDatepickerId(): string;
+
+/**
+ * CVA variants for the datepicker trigger input.
+ * Uses semantic theme tokens for consistent cross-theme styling.
+ *
+ * @tokens `--color-input-background`, `--color-input-foreground`, `--color-input-border`,
+ *         `--color-input-placeholder`, `--color-ring`, `--color-muted`, `--color-muted-hover`,
+ *         `--color-warn`, `--color-success`, `--color-primary`, `--color-border`,
+ *         `--color-disabled`, `--color-disabled-foreground`, `--radius-input`
+ */
+declare const datepickerTriggerVariants: (props?: {
+    variant?: DatepickerVariant;
+    size?: DatepickerSize;
+    state?: DatepickerState;
+    open?: boolean;
+}) => string;
+type DatepickerTriggerVariants = VariantProps<typeof datepickerTriggerVariants>;
+/**
+ * CVA variants for the disabled state of datepicker trigger.
+ *
+ * @tokens `--color-disabled`, `--color-disabled-foreground`
+ */
+declare const datepickerDisabledVariants: () => string;
+type DatepickerDisabledVariants = VariantProps<typeof datepickerDisabledVariants>;
+/**
+ * CVA variants for the datepicker input field.
+ *
+ * @tokens `--color-input-foreground`, `--color-input-placeholder`
+ */
+declare const datepickerInputVariants: (props?: {
+    size?: DatepickerSize;
+}) => string;
+type DatepickerInputVariants = VariantProps<typeof datepickerInputVariants>;
+/**
+ * CVA variants for the calendar icon button.
+ *
+ * @tokens `--color-ring`, `--color-muted-foreground`, `--radius-interactive-sm`
+ */
+declare const datepickerIconVariants: (props?: {
+    size?: DatepickerSize;
+}) => string;
+type DatepickerIconVariants = VariantProps<typeof datepickerIconVariants>;
+/**
+ * CVA variants for the clear button.
+ *
+ * @tokens `--color-ring`, `--color-muted-foreground`, `--radius-interactive-sm`
+ */
+declare const datepickerClearVariants: (props?: {
+    size?: DatepickerSize;
+}) => string;
+type DatepickerClearVariants = VariantProps<typeof datepickerClearVariants>;
+/**
+ * CVA variants for the datepicker panel (overlay).
+ *
+ * @tokens `--color-popover`, `--color-popover-foreground`, `--color-border-subtle`, `--radius-overlay`
+ */
+declare const datepickerPanelVariants: (props?: {
+    size?: DatepickerSize;
+}) => string;
+type DatepickerPanelVariants = VariantProps<typeof datepickerPanelVariants>;
+/**
+ * CVA variants for the footer section of the datepicker panel.
+ *
+ * @tokens `--color-border-subtle`
+ */
+declare const datepickerFooterVariants: (props?: {
+    size?: DatepickerSize;
+}) => string;
+type DatepickerFooterVariants = VariantProps<typeof datepickerFooterVariants>;
+/**
+ * CVA variants for the footer buttons.
+ *
+ * @tokens `--color-primary`, `--color-primary-foreground`, `--color-primary-hover`,
+ *         `--color-muted`, `--color-muted-foreground`, `--color-muted-hover`, `--radius-control-sm`
+ */
+declare const datepickerFooterButtonVariants: (props?: {
+    size?: DatepickerSize;
+    variant?: 'primary' | 'secondary';
+}) => string;
+type DatepickerFooterButtonVariants = VariantProps<typeof datepickerFooterButtonVariants>;
+/**
+ * CVA variants for the range separator.
+ *
+ * @tokens `--color-muted-foreground`
+ */
+declare const datepickerRangeSeparatorVariants: (props?: {
+    size?: DatepickerSize;
+}) => string;
+type DatepickerRangeSeparatorVariants = VariantProps<typeof datepickerRangeSeparatorVariants>;
+
+/**
+ * Single date picker component with calendar popup.
+ * Implements ControlValueAccessor for Reactive Forms and Template-driven Forms.
+ *
+ * @tokens `--color-input-background`, `--color-input-foreground`, `--color-input-border`,
+ *         `--color-input-placeholder`, `--color-ring`, `--color-muted`, `--color-muted-foreground`,
+ *         `--color-popover`, `--color-popover-foreground`, `--color-border-subtle`,
+ *         `--color-primary`, `--color-primary-foreground`, `--color-primary-hover`,
+ *         `--color-warn`, `--color-success`, `--color-disabled`, `--color-disabled-foreground`
+ *
+ * @example
+ * ```html
+ * <com-datepicker
+ *   formControlName="birthDate"
+ *   placeholder="Select date..."
+ *   [min]="minDate"
+ *   [max]="maxDate"
+ *   [showTodayButton]="true"
+ *   [showClearButton]="true"
+ * />
+ * ```
+ */
+declare class ComDatepicker<D> implements ControlValueAccessor, Validator, OnDestroy {
+    private readonly elementRef;
+    private readonly destroyRef;
+    private readonly overlay;
+    private readonly viewContainerRef;
+    private readonly document;
+    private readonly dateAdapter;
+    /** Optional NgControl for form integration. */
+    private readonly ngControl;
+    /** Reference to the trigger element. */
+    private readonly triggerRef;
+    /** Reference to the input element. */
+    private readonly inputRef;
+    /** Reference to the panel template. */
+    private readonly panelTemplateRef;
+    /** Overlay reference. */
+    private overlayRef;
+    /** Unique ID for the datepicker. */
+    private readonly datepickerId;
+    /** Current value. */
+    readonly value: InputSignal<D | null>;
+    /** Minimum selectable date. */
+    readonly min: InputSignal<D | null>;
+    /** Maximum selectable date. */
+    readonly max: InputSignal<D | null>;
+    /** Custom filter function to disable specific dates. */
+    readonly dateFilter: InputSignal<DateFilterFn<D> | null>;
+    /** Date the calendar opens to (defaults to selected or today). */
+    readonly startAt: InputSignal<D | null>;
+    /** Initial calendar view. */
+    readonly startView: InputSignal<CalendarView>;
+    /** First day of week override (0=Sun, 1=Mon, ..., 6=Sat). */
+    readonly firstDayOfWeek: InputSignal<number | null>;
+    /** Placeholder text. */
+    readonly placeholder: InputSignal<string>;
+    /** Whether the datepicker is disabled. */
+    readonly disabled: InputSignal<boolean>;
+    /** Whether the datepicker is required. */
+    readonly required: InputSignal<boolean>;
+    /** Display format for the date. */
+    readonly dateFormat: InputSignal<DateFormatPreset>;
+    /** Show a clear button in the trigger. */
+    readonly showClearButton: InputSignal<boolean>;
+    /** Show a today button in the footer. */
+    readonly showTodayButton: InputSignal<boolean>;
+    /** Show a clear button in the footer. */
+    readonly showFooterClearButton: InputSignal<boolean>;
+    /** Don't auto-close on selection. */
+    readonly keepOpen: InputSignal<boolean>;
+    /** Allow manual text input. */
+    readonly allowManualInput: InputSignal<boolean>;
+    /** Additional CSS classes for the panel. */
+    readonly panelClass: InputSignal<string>;
+    /** Panel width strategy. */
+    readonly panelWidth: InputSignal<DatepickerPanelWidth>;
+    /** CVA variant for trigger styling. */
+    readonly variant: InputSignal<DatepickerVariant>;
+    /** Size variant. */
+    readonly size: InputSignal<DatepickerSize>;
+    /** Validation state. */
+    readonly state: InputSignal<DatepickerState>;
+    /** Additional CSS classes for the trigger. */
+    readonly userClass: InputSignal<string>;
+    /** Accessible label for the input. */
+    readonly ariaLabel: InputSignal<string | null>;
+    /** ID of element describing the input. */
+    readonly ariaDescribedBy: InputSignal<string | null>;
+    /** Emitted when a date is selected. */
+    readonly dateChange: OutputEmitterRef<D | null>;
+    /** Emitted when the panel opens. */
+    readonly opened: OutputEmitterRef<void>;
+    /** Emitted when the panel closes. */
+    readonly closed: OutputEmitterRef<void>;
+    /** Whether the panel is open. */
+    readonly isOpen: WritableSignal<boolean>;
+    /** Internal value state (managed by CVA or input). */
+    readonly internalValue: WritableSignal<D | null>;
+    /** Calendar active date for navigation. */
+    readonly calendarActiveDate: WritableSignal<D>;
+    /** Live announcements for screen readers. */
+    readonly liveAnnouncement: WritableSignal<string>;
+    /** Input element ID. */
+    readonly inputId: Signal<string>;
+    /** Panel element ID. */
+    readonly panelId: Signal<string>;
+    /** Whether the datepicker has a value. */
+    readonly hasValue: Signal<boolean>;
+    /** Formatted display value. */
+    readonly displayValue: Signal<string>;
+    /** Computed trigger classes. */
+    readonly triggerClasses: Signal<string>;
+    /** Computed input classes. */
+    readonly inputClasses: Signal<string>;
+    /** Computed icon classes. */
+    readonly iconClasses: Signal<string>;
+    /** Computed clear button classes. */
+    readonly clearClasses: Signal<string>;
+    /** Computed panel classes. */
+    readonly panelClasses: Signal<string>;
+    /** Computed footer classes. */
+    readonly footerClasses: Signal<string>;
+    /** Computed today button classes. */
+    readonly todayButtonClasses: Signal<string>;
+    /** Computed clear button classes (footer). */
+    readonly clearButtonClasses: Signal<string>;
+    private onChange;
+    private onTouched;
+    private onValidatorChange;
+    constructor();
+    ngOnDestroy(): void;
+    writeValue(value: D | null): void;
+    registerOnChange(fn: (value: D | null) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(_isDisabled: boolean): void;
+    validate(): ValidationErrors | null;
+    registerOnValidatorChange(fn: () => void): void;
+    /** Opens the datepicker panel. */
+    open(): void;
+    /** Closes the datepicker panel. */
+    close(): void;
+    /** Toggles the datepicker panel. */
+    toggle(): void;
+    /** Clears the selected date. */
+    clear(event?: Event): void;
+    /** Selects today's date. */
+    selectToday(): void;
+    protected onTriggerClick(): void;
+    protected onTriggerKeydown(event: KeyboardEvent): void;
+    protected onInputKeydown(event: KeyboardEvent): void;
+    protected onInputChange(event: Event): void;
+    protected onInputBlur(): void;
+    protected onPanelKeydown(event: KeyboardEvent): void;
+    protected onDateSelected(date: D): void;
+    protected onActiveDateChange(date: D): void;
+    private createOverlay;
+    private destroyOverlay;
+    private updateValue;
+    private parseAndSetValue;
+    private isDateValid;
+    private announce;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ComDatepicker<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ComDatepicker<any>, "com-datepicker", ["comDatepicker"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "dateFilter": { "alias": "dateFilter"; "required": false; "isSignal": true; }; "startAt": { "alias": "startAt"; "required": false; "isSignal": true; }; "startView": { "alias": "startView"; "required": false; "isSignal": true; }; "firstDayOfWeek": { "alias": "firstDayOfWeek"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "dateFormat": { "alias": "dateFormat"; "required": false; "isSignal": true; }; "showClearButton": { "alias": "showClearButton"; "required": false; "isSignal": true; }; "showTodayButton": { "alias": "showTodayButton"; "required": false; "isSignal": true; }; "showFooterClearButton": { "alias": "showFooterClearButton"; "required": false; "isSignal": true; }; "keepOpen": { "alias": "keepOpen"; "required": false; "isSignal": true; }; "allowManualInput": { "alias": "allowManualInput"; "required": false; "isSignal": true; }; "panelClass": { "alias": "panelClass"; "required": false; "isSignal": true; }; "panelWidth": { "alias": "panelWidth"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "state": { "alias": "state"; "required": false; "isSignal": true; }; "userClass": { "alias": "class"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "ariaDescribedBy": { "alias": "ariaDescribedBy"; "required": false; "isSignal": true; }; }, { "dateChange": "dateChange"; "opened": "opened"; "closed": "closed"; }, never, never, true, never>;
+}
+
+/**
+ * Date range picker component with calendar popup.
+ * Allows selecting a start and end date via a two-click interaction.
+ * Implements ControlValueAccessor for Reactive Forms and Template-driven Forms.
+ *
+ * @tokens `--color-input-background`, `--color-input-foreground`, `--color-input-border`,
+ *         `--color-input-placeholder`, `--color-ring`, `--color-muted`, `--color-muted-foreground`,
+ *         `--color-popover`, `--color-popover-foreground`, `--color-border-subtle`,
+ *         `--color-primary`, `--color-primary-foreground`, `--color-primary-hover`,
+ *         `--color-warn`, `--color-success`, `--color-disabled`, `--color-disabled-foreground`
+ *
+ * @example
+ * ```html
+ * <com-date-range-picker
+ *   formControlName="dateRange"
+ *   startPlaceholder="Start date"
+ *   endPlaceholder="End date"
+ *   [min]="minDate"
+ *   [max]="maxDate"
+ *   [showTodayButton]="true"
+ * />
+ * ```
+ */
+declare class ComDateRangePicker<D> implements ControlValueAccessor, Validator, OnDestroy {
+    private readonly elementRef;
+    private readonly destroyRef;
+    private readonly overlay;
+    private readonly viewContainerRef;
+    private readonly document;
+    private readonly dateAdapter;
+    /** Optional NgControl for form integration. */
+    private readonly ngControl;
+    /** Reference to the trigger element. */
+    private readonly triggerRef;
+    /** Reference to the start input element. */
+    private readonly startInputRef;
+    /** Reference to the end input element. */
+    private readonly endInputRef;
+    /** Reference to the panel template. */
+    private readonly panelTemplateRef;
+    /** Overlay reference. */
+    private overlayRef;
+    /** Unique ID for the datepicker. */
+    private readonly datepickerId;
+    /** Current value. */
+    readonly value: InputSignal<DateRangeValue<D> | null>;
+    /** Minimum selectable date. */
+    readonly min: InputSignal<D | null>;
+    /** Maximum selectable date. */
+    readonly max: InputSignal<D | null>;
+    /** Custom filter function to disable specific dates. */
+    readonly dateFilter: InputSignal<DateFilterFn<D> | null>;
+    /** Date the calendar opens to (defaults to start date or today). */
+    readonly startAt: InputSignal<D | null>;
+    /** Initial calendar view. */
+    readonly startView: InputSignal<CalendarView>;
+    /** First day of week override (0=Sun, 1=Mon, ..., 6=Sat). */
+    readonly firstDayOfWeek: InputSignal<number | null>;
+    /** Placeholder text for start date. */
+    readonly startPlaceholder: InputSignal<string>;
+    /** Placeholder text for end date. */
+    readonly endPlaceholder: InputSignal<string>;
+    /** Whether the datepicker is disabled. */
+    readonly disabled: InputSignal<boolean>;
+    /** Whether the datepicker is required. */
+    readonly required: InputSignal<boolean>;
+    /** Display format for the date. */
+    readonly dateFormat: InputSignal<DateFormatPreset>;
+    /** Show a clear button in the trigger. */
+    readonly showClearButton: InputSignal<boolean>;
+    /** Show a today button in the footer. */
+    readonly showTodayButton: InputSignal<boolean>;
+    /** Show a clear button in the footer. */
+    readonly showFooterClearButton: InputSignal<boolean>;
+    /** Don't auto-close on complete range selection. */
+    readonly keepOpen: InputSignal<boolean>;
+    /** Allow manual text input. */
+    readonly allowManualInput: InputSignal<boolean>;
+    /** Additional CSS classes for the panel. */
+    readonly panelClass: InputSignal<string>;
+    /** Panel width strategy. */
+    readonly panelWidth: InputSignal<DatepickerPanelWidth>;
+    /** CVA variant for trigger styling. */
+    readonly variant: InputSignal<DatepickerVariant>;
+    /** Size variant. */
+    readonly size: InputSignal<DatepickerSize>;
+    /** Validation state. */
+    readonly state: InputSignal<DatepickerState>;
+    /** Additional CSS classes for the trigger. */
+    readonly userClass: InputSignal<string>;
+    /** Accessible label for the start input. */
+    readonly startAriaLabel: InputSignal<string | null>;
+    /** Accessible label for the end input. */
+    readonly endAriaLabel: InputSignal<string | null>;
+    /** Emitted when a complete range is selected. */
+    readonly rangeChange: OutputEmitterRef<DateRangeValue<D> | null>;
+    /** Emitted when the panel opens. */
+    readonly opened: OutputEmitterRef<void>;
+    /** Emitted when the panel closes. */
+    readonly closed: OutputEmitterRef<void>;
+    /** Whether the panel is open. */
+    readonly isOpen: WritableSignal<boolean>;
+    /** Which input is currently focused. */
+    readonly activeInput: WritableSignal<'start' | 'end' | null>;
+    /** Internal value state (managed by CVA or input). */
+    readonly internalValue: WritableSignal<DateRangeValue<D> | null>;
+    /** Calendar active date for navigation. */
+    readonly calendarActiveDate: WritableSignal<D>;
+    /** Live announcements for screen readers. */
+    readonly liveAnnouncement: WritableSignal<string>;
+    /** Start input element ID. */
+    readonly startInputId: Signal<string>;
+    /** End input element ID. */
+    readonly endInputId: Signal<string>;
+    /** Panel element ID. */
+    readonly panelId: Signal<string>;
+    /** Whether the datepicker has a value. */
+    readonly hasValue: Signal<boolean>;
+    /** Calendar selection (converts DateRangeValue to DateRange for calendar). */
+    readonly calendarSelection: Signal<DateRange<D> | null>;
+    /** Formatted start display value. */
+    readonly startDisplayValue: Signal<string>;
+    /** Formatted end display value. */
+    readonly endDisplayValue: Signal<string>;
+    /** Computed trigger classes. */
+    readonly triggerClasses: Signal<string>;
+    /** Computed input classes. */
+    readonly inputClasses: Signal<string>;
+    /** Computed separator classes. */
+    readonly separatorClasses: Signal<string>;
+    /** Computed icon classes. */
+    readonly iconClasses: Signal<string>;
+    /** Computed clear button classes. */
+    readonly clearClasses: Signal<string>;
+    /** Computed panel classes. */
+    readonly panelClasses: Signal<string>;
+    /** Computed footer classes. */
+    readonly footerClasses: Signal<string>;
+    /** Computed today button classes. */
+    readonly todayButtonClasses: Signal<string>;
+    /** Computed clear button classes (footer). */
+    readonly clearButtonClasses: Signal<string>;
+    private onChange;
+    private onTouched;
+    private onValidatorChange;
+    constructor();
+    ngOnDestroy(): void;
+    writeValue(value: DateRangeValue<D> | null): void;
+    registerOnChange(fn: (value: DateRangeValue<D> | null) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(_isDisabled: boolean): void;
+    validate(): ValidationErrors | null;
+    registerOnValidatorChange(fn: () => void): void;
+    /** Opens the datepicker panel. */
+    open(): void;
+    /** Closes the datepicker panel. */
+    close(): void;
+    /** Toggles the datepicker panel. */
+    toggle(): void;
+    /** Clears the selected date range. */
+    clear(event?: Event): void;
+    /** Selects today's date as the start date. */
+    selectToday(): void;
+    protected onTriggerClick(): void;
+    protected onTriggerKeydown(event: KeyboardEvent): void;
+    protected onStartInputFocus(): void;
+    protected onEndInputFocus(): void;
+    protected onInputKeydown(event: KeyboardEvent, inputType: 'start' | 'end'): void;
+    protected onStartInputChange(_event: Event): void;
+    protected onEndInputChange(_event: Event): void;
+    protected onStartInputBlur(): void;
+    protected onEndInputBlur(): void;
+    protected onPanelKeydown(event: KeyboardEvent): void;
+    protected onCalendarSelectionChange(selection: unknown): void;
+    protected onActiveDateChange(date: D): void;
+    private createOverlay;
+    private destroyOverlay;
+    private updateValue;
+    private parseAndSetStart;
+    private parseAndSetEnd;
+    private isDateValid;
+    private formatDate;
+    private announce;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ComDateRangePicker<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ComDateRangePicker<any>, "com-date-range-picker", ["comDateRangePicker"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "dateFilter": { "alias": "dateFilter"; "required": false; "isSignal": true; }; "startAt": { "alias": "startAt"; "required": false; "isSignal": true; }; "startView": { "alias": "startView"; "required": false; "isSignal": true; }; "firstDayOfWeek": { "alias": "firstDayOfWeek"; "required": false; "isSignal": true; }; "startPlaceholder": { "alias": "startPlaceholder"; "required": false; "isSignal": true; }; "endPlaceholder": { "alias": "endPlaceholder"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "dateFormat": { "alias": "dateFormat"; "required": false; "isSignal": true; }; "showClearButton": { "alias": "showClearButton"; "required": false; "isSignal": true; }; "showTodayButton": { "alias": "showTodayButton"; "required": false; "isSignal": true; }; "showFooterClearButton": { "alias": "showFooterClearButton"; "required": false; "isSignal": true; }; "keepOpen": { "alias": "keepOpen"; "required": false; "isSignal": true; }; "allowManualInput": { "alias": "allowManualInput"; "required": false; "isSignal": true; }; "panelClass": { "alias": "panelClass"; "required": false; "isSignal": true; }; "panelWidth": { "alias": "panelWidth"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "state": { "alias": "state"; "required": false; "isSignal": true; }; "userClass": { "alias": "class"; "required": false; "isSignal": true; }; "startAriaLabel": { "alias": "startAriaLabel"; "required": false; "isSignal": true; }; "endAriaLabel": { "alias": "endAriaLabel"; "required": false; "isSignal": true; }; }, { "rangeChange": "rangeChange"; "opened": "opened"; "closed": "closed"; }, never, never, true, never>;
+}
+
+export { CALENDAR_SELECTION_STRATEGY, CalendarSelectionStrategy, CalendarViewBase, ComCalendar, ComCalendarCell, ComCalendarHeader, ComCalendarMonthView, ComCalendarMultiYearView, ComCalendarYearView, ComDateRangePicker, ComDatepicker, DATE_ADAPTER, DAYS_PER_WEEK, DateAdapter, MONTHS_PER_ROW, MultiSelectionStrategy, NativeDateAdapter, RangeSelectionStrategy, SingleSelectionStrategy, WEEKS_PER_MONTH, WeekSelectionStrategy, YEARS_PER_PAGE, YEARS_PER_ROW, calendarCellVariants, calendarCellWrapperVariants, calendarHeaderButtonVariants, calendarHeaderVariants, calendarVariants, createCalendarCell, createDateRange, createDateRangeValue, createGrid, datepickerClearVariants, datepickerDisabledVariants, datepickerFooterButtonVariants, datepickerFooterVariants, datepickerIconVariants, datepickerInputVariants, datepickerPanelVariants, datepickerRangeSeparatorVariants, datepickerTriggerVariants, generateDatepickerId, getMultiYearStartingYear, getWeekdayHeaders, isDateDisabled, isMonthDisabled, isYearDisabled, navigateGrid, provideMultiSelectionStrategy, provideNativeDateAdapter, provideRangeSelectionStrategy, provideSingleSelectionStrategy, provideWeekSelectionStrategy };
+export type { CalendarCell, CalendarCellConfig, CalendarCellKeyNavEvent, CalendarCellState, CalendarCellVariants, CalendarCellWrapperVariants, CalendarHeaderButtonVariants, CalendarHeaderVariants, CalendarVariants, CalendarView, DateClassFn, DateFilterFn, DateFormatPreset, DateRange, DateRangeValue, DatepickerClearVariants, DatepickerDisabledVariants, DatepickerFooterButtonVariants, DatepickerFooterConfig, DatepickerFooterVariants, DatepickerIconVariants, DatepickerInputVariants, DatepickerPanelVariants, DatepickerPanelWidth, DatepickerRangeSeparatorVariants, DatepickerSize, DatepickerState, DatepickerTriggerVariants, DatepickerVariant, NameStyle, SelectionResult, WeekdayHeader };