import type { ComponentProps } from '@fluentui/react-utilities';
import type { ComponentState } from '@fluentui/react-utilities';
import type { DistributiveOmit } from '@fluentui/react-utilities';
import type { EventData } from '@fluentui/react-utilities';
import type { EventHandler } from '@fluentui/react-utilities';
import type { ForwardRefComponent } from '@fluentui/react-utilities';
import type { JSXElement } from '@fluentui/react-utilities';
import type { PositioningProps as PositioningProps_2 } from '@fluentui/react-positioning';
import type { PositioningShorthandValue } from '@fluentui/react-positioning';
import * as React_2 from 'react';
import type { RefAttributes } from '@fluentui/react-utilities';
import type { Slot } from '@fluentui/react-utilities';

/**
 * Calendar shows a date grid and lets the user pick a date, a week, a work week or a month.
 */
declare const Calendar: ForwardRefComponent<CalendarProps>;

/**
 * A date and its formatted display value.
 */
declare type CalendarDateLabelData = {
    /**
     * The actual date object.
     */
    date: Date;
    /**
     * The formatted display value of the date.
     */
    formattedDate: string;
};

/**
 * Supported date and time display formats.
 */
declare type CalendarDateTimeFormat = 'day' | 'month' | 'shortMonth' | 'year' | 'monthDayYear' | 'monthYear' | 'weekday' | 'shortWeekday';

/**
 * CalendarDay shows a month header with navigation, above the grid of that month's days.
 */
declare const CalendarDay: ForwardRefComponent<CalendarDayProps>;

/**
 * Semantic day data passed to cell getters, without DOM props.
 */
declare type CalendarDayCellData = Day & {
    /**
     * The formatted day number, or the civil date label when `originalDate` is `null`.
     */
    label: string;
    /**
     * Whether this day is the grid's initial focus target.
     */
    isNavigated: boolean;
};

/**
 * Overrides for the existing elements of a visible day cell. These are prop bags, not slots.
 * Use label.children for day content or button.children to replace both the label and marker.
 */
declare type CalendarDayCellProps = {
    /**
     * Overrides for the `<td role="gridcell">`. Its children remain controlled by the renderer.
     */
    root?: Omit<React_2.ComponentProps<'td'>, 'children'>;
    /**
     * Overrides for the day button. Set `children` to replace both the label and marker.
     */
    button?: React_2.ComponentProps<'button'>;
    /**
     * Overrides for the day-number span. Set `children` to customize content while preserving the marker.
     */
    label?: React_2.ComponentProps<'span'>;
    /**
     * Overrides for the marker element. Applied only when the day is marked.
     */
    marker?: React_2.ComponentProps<'span'>;
};

/**
 * Data describing activation of the day picker's close button.
 */
declare type CalendarDayDismissData = EventData<'click' | 'keydown', React_2.SyntheticEvent<HTMLButtonElement>>;

/**
 * The imperative API exposed through CalendarDay's `imperativeRef` prop.
 */
declare type CalendarDayHandle = {
    /**
     * Moves focus to the day the grid is currently navigated to.
     */
    focus(options?: FocusOptions): void;
};

/**
 * Data describing activation of the day picker's month/year heading.
 */
declare type CalendarDayHeaderSelectData = EventData<'click' | 'keydown', React_2.SyntheticEvent<HTMLElement>>;

/**
 * Data describing a request to navigate the day picker.
 */
declare type CalendarDayNavigateData = EventData<'click' | 'keydown', React_2.SyntheticEvent<HTMLElement>> & {
    /**
     * The date to navigate to.
     */
    date: Date;
    /**
     * Whether focus should move into the day grid after navigation.
     */
    focusOnNavigatedDay: boolean;
};

/**
 * Props for the day picker. Shared selection, boundaries, and formatting come from CalendarProvider.
 */
declare type CalendarDayProps = ComponentProps<Partial<CalendarDaySlots>> & Pick<Partial<DayGridOptions>, 'daysToSelectInDayView'> & {
    /**
     * Provides access to the picker's focus handle.
     */
    imperativeRef?: React_2.Ref<CalendarDayHandle>;
    /**
     * The currently navigated date
     */
    navigatedDate?: Date;
    /**
     * Called when navigation is requested. The event data includes the destination date and whether
     * focus should move into the day grid.
     */
    onNavigateDate?: EventHandler<CalendarDayNavigateData>;
    /**
     * Callback issued when calendar day is closed
     */
    onDismiss?: EventHandler<CalendarDayDismissData>;
    /**
     * Callback function when the header is selected
     */
    onHeaderSelect?: EventHandler<CalendarDayHeaderSelectData>;
    /**
     * How many weeks to show. If not provided, shows enough weeks to display the navigated month,
     * between 4 and 6 depending.
     * @default undefined
     */
    weeksToShow?: number;
    /**
     * Optional callback function to mark specific days with a small symbol. Fires when the date range changes,
     * gives the starting and ending displayed dates and expects the list of which days in between should be
     * marked.
     */
    getMarkedDays?: (startingDate: Date, endingDate: Date) => Date[];
    /**
     * Overrides the existing elements of each visible cell, including placeholder dates.
     * Receives semantic day data and a formatted label, not DOM props.
     * Refs are composed, class names appended and styles merged.
     * Defined consumer props override defaults, including roles, focus, disabled/selection state and data attributes.
     * Consumers are responsible for preserving accessibility and interaction semantics when overriding these props.
     * Handlers run before the delegated grid behavior; preventDefault cancels selection and navigation.
     * Marker overrides apply only to marked days.
     * Called when the renderer resolves the cell's props, not while the hook builds its data.
     */
    getCellProps?: (day: CalendarDayCellData) => CalendarDayCellProps;
    /**
     * Overrides each visible week row and the weekday header row. Use row.type to identify the row.
     * Week-number overrides apply only when week numbers are shown.
     * Called when the renderer resolves the row's props.
     */
    getRowProps?: (row: CalendarDayRowData) => CalendarDayRowProps;
    /**
     * Overrides each weekday header cell, including its default role and scope.
     * Receives semantic weekday data and formatted labels. Called when the renderer resolves the cell's props.
     */
    getWeekdayCellProps?: (weekday: CalendarDayWeekdayCellData) => CalendarDayWeekdayCellProps;
};

/**
 * A visible week or weekday-header row, without DOM props on the row or its items.
 */
declare type CalendarDayRowData = {
    /**
     * Identifies a row of day cells.
     */
    type: 'week';
    /**
     * Zero-based index of the visible week row.
     */
    key: number;
    /**
     * Semantic day data in display order, including placeholder dates.
     */
    days: CalendarDayCellData[];
    /**
     * The numeric week number, present only when week numbers are shown and the row has a representable date.
     */
    weekNumber?: number;
} | {
    /**
     * Identifies the weekday header row.
     */
    type: 'weekday';
    /**
     * Semantic header-cell data ordered from the configured first day of the week.
     */
    cells: CalendarDayWeekdayCellData[];
};

/** Overrides for a week row or weekday-header row. */
declare type CalendarDayRowProps = {
    /**
     * Overrides for the `<tr>`. Its cells remain controlled by the renderer.
     */
    root?: Omit<React_2.ComponentProps<'tr'>, 'children'>;
    /**
     * Overrides for the week-number `<th>`, or the header row's spacer.
     * Applied only when the corresponding element is rendered.
     */
    weekNumber?: React_2.ComponentProps<'th'>;
};

/**
 * Slots rendered by the day picker.
 */
declare type CalendarDaySlots = {
    /**
     * The outer container of the day picker.
     */
    root: NonNullable<Slot<'div'>>;
    /**
     * Holds the month/year title and the navigation buttons.
     */
    header: NonNullable<Slot<'div'>>;
    /**
     * The month and year label. Renders as a `button` when `onHeaderSelect` is set, otherwise as a
     * plain `div`.
     */
    heading: NonNullable<Slot<'button', 'div'>>;
    /**
     * Wraps the previous/next month and close buttons.
     */
    navigation: NonNullable<Slot<'div'>>;
    /**
     * The button to navigate to the previous month.
     */
    previousMonthButton: NonNullable<Slot<'button'>>;
    /**
     * The button to navigate to the next month.
     */
    nextMonthButton: NonNullable<Slot<'button'>>;
    /**
     * The close button.
     */
    closeButton?: Slot<'button'>;
    /**
     * The `<table role="grid">` holding the days of the navigated month, with a single roving tab stop. Arrows, Home
     * and End move focus between available days; Calendar owns selection, range hover and navigation beyond visible
     * dates.
     */
    grid: NonNullable<Slot<'table'>>;
    /**
     * The `<tbody>` wrapping every week row.
     */
    body: NonNullable<Slot<'tbody'>>;
};

/**
 * Semantic weekday data passed to header-cell getters.
 */
declare type CalendarDayWeekdayCellData = {
    /**
     * Stable key of the weekday header cell.
     */
    key: string;
    /**
     * The weekday represented by the header cell.
     */
    dayOfWeek: DayOfWeek;
    /**
     * The visible short weekday label, or a short month label at a month boundary in single-week view.
     */
    label: string;
    /**
     * The full weekday or month label used as the cell's default accessible name and title.
     */
    accessibleLabel: string;
};

/** Overrides for a weekday header cell. */
declare type CalendarDayWeekdayCellProps = {
    /**
     * Overrides for the `<th scope="col">`, including its visible content and accessible name.
     */
    root?: React_2.ComponentProps<'th'>;
};

/**
 * Event data for dismissing the Calendar.
 */
declare type CalendarDismissData = EventData<'click' | 'keydown', React_2.SyntheticEvent<HTMLElement>>;

/**
 * Formatters used for calendar display values and accessibility labels.
 */
declare type CalendarFormatters = {
    /**
     * Label for the button that navigates to today.
     */
    goToTodayLabel: () => string;
    /**
     * Label for the button that closes the calendar.
     */
    closeLabel: () => string;
    /**
     * Formats a date according to the specified format.
     */
    dateTime: (data: {
        date: Date;
        format: CalendarDateTimeFormat;
    }) => string;
    /**
     * Formats the label for the previous month button.
     */
    previousMonthLabel: (data: CalendarDateLabelData) => string;
    /**
     * Formats the label for the next month button.
     */
    nextMonthLabel: (data: CalendarDateLabelData) => string;
    /**
     * Formats the label for the previous year button.
     */
    previousYearLabel: (data: CalendarDateLabelData) => string;
    /**
     * Formats the label for the next year button.
     */
    nextYearLabel: (data: CalendarDateLabelData) => string;
    /**
     * Formats the label for the previous year range button.
     */
    previousYearRangeLabel: (data: CalendarYearRangeLabelData) => string;
    /**
     * Formats the label for the next year range button.
     */
    nextYearRangeLabel: (data: CalendarYearRangeLabelData) => string;
    /**
     * Formats the label for the month picker header.
     */
    monthPickerHeaderLabel: (data: CalendarDateLabelData) => string;
    /**
     * Formats the label for the day picker header.
     */
    dayPickerHeaderLabel: (data: CalendarDateLabelData) => string;
    /**
     * Formats the label for the year range picker header.
     */
    yearRangePickerHeaderLabel: (data: CalendarYearRangeLabelData) => string;
    /**
     * Formats the label for the week number column header.
     */
    weekNumberLabel: (data: {
        weekNumber: number;
    }) => string;
    /**
     * Formats the label for the selected date.
     */
    selectedDateLabel: (data: CalendarDateLabelData) => string;
    /**
     * Formats the label for today's date.
     */
    todayDateLabel: (data: CalendarDateLabelData) => string;
    /**
     * Formats the label for a marked day.
     */
    dayMarkedLabel: (data: CalendarDateLabelData) => string;
};

/**
 * One row of the month or year grid.
 */
declare type CalendarGridRow<TCell> = {
    /** Stable key of the row. */
    key: number;
    /** Semantic cells in display order. */
    cells: TCell[];
};

/** Controls how the day and month pickers are arranged. */
declare type CalendarLayout = 'sideBySide' | 'overlay';

/**
 * CalendarMonth shows the months of the navigated year, and opens the year picker from its header.
 */
declare const CalendarMonth: ForwardRefComponent<CalendarMonthProps>;

/**
 * Semantic month data stored in the grid and passed to cell getters, without DOM props.
 */
declare type CalendarMonthCellData = {
    /**
     * Index of the month within the year, matching `Date.prototype.getMonth()`.
     */
    index: number;
    /**
     * The formatted short month name displayed in the cell.
     */
    label: string;
    /**
     * Whether this month is the grid's initial focus target, falling back to an available month when needed.
     */
    isNavigated: boolean;
    /**
     * Whether this month matches today's month and year, independently of consumer styling.
     */
    isCurrent: boolean;
    /**
     * Whether this is the selected month.
     */
    isSelected: boolean;
    /**
     * Whether this month can be selected.
     */
    isInBounds: boolean;
};

/** Overrides for a month gridcell and its nested button. */
declare type CalendarMonthCellProps = {
    /**
     * Overrides for the `<div role="gridcell">`.
     */
    root?: Omit<React_2.ComponentProps<'div'>, 'children'>;
    /**
     * Overrides for the nested month button. Set `children` to customize the month content.
     */
    button?: React_2.ComponentProps<'button'>;
};

/**
 * The imperative API exposed through CalendarMonth's `imperativeRef` prop.
 */
declare type CalendarMonthHandle = {
    /**
     * Moves focus to the navigated month (or the first available month if it is disabled),
     * or to the year picker while it is open.
     */
    focus(options?: FocusOptions): void;
    /**
     * Replaces the month grid with the year picker and moves focus into it. Does nothing when `yearPickerHidden` is set.
     */
    showYearPicker(): void;
};

/**
 * Data describing activation of the month picker's heading or a month selection that returns to the day view.
 */
declare type CalendarMonthHeaderSelectData = EventData<'click' | 'keydown', React_2.SyntheticEvent<HTMLButtonElement>>;

/**
 * Data describing a request to navigate the month picker.
 */
declare type CalendarMonthNavigateData = EventData<'click' | 'keydown', React_2.SyntheticEvent<HTMLElement>> & {
    /**
     * The date to navigate to.
     */
    date: Date;
    /**
     * Whether focus should move into the day grid after navigation.
     */
    focusOnNavigatedDay: boolean;
};

/**
 * Props for the month picker. Shared selection, boundaries, and formatting come from CalendarProvider.
 */
declare type CalendarMonthProps = ComponentProps<Partial<CalendarMonthSlots>> & {
    /**
     * Provides access to the picker's focus handle. The regular `ref` points to the root element.
     */
    imperativeRef?: React_2.Ref<CalendarMonthHandle>;
    /**
     * The currently navigated date
     */
    navigatedDate?: Date;
    /**
     * The date whose month is selected and whose year is selected in the year picker.
     * Defaults to the Calendar's selected value, or today when that value is undefined.
     * Set to null for an empty selection.
     */
    selectedDate?: Date | null;
    /**
     * Overrides each month gridcell and its nested button. Use button.children to customize its content.
     * Receives semantic month data and a formatted label, not DOM props.
     * Refs are composed, class names appended and styles merged.
     * Defined consumer props override defaults, including roles, focus, disabled/selection state and data attributes.
     * Consumers are responsible for preserving accessibility and interaction semantics when overriding these props.
     * Handlers run before the delegated grid behavior; preventDefault cancels selection.
     * Called when the renderer resolves the cell's props, not while the hook builds its data.
     */
    getCellProps?: (month: CalendarMonthCellData) => CalendarMonthCellProps;
    /**
     * Overrides each row's default props, including its role and focus attributes, without replacing its cells.
     * Receives semantic row and month data. Called when the renderer resolves the row's props.
     */
    getRowProps?: (row: CalendarMonthRowData) => CalendarMonthRowProps;
    /**
     * Called when a month is selected. The date is an available day in that month and the range
     * follows the CalendarProvider configuration. Year navigation does not select a month.
     */
    onSelectDate?: EventHandler<CalendarMonthSelectData>;
    /**
     * Called when month or year navigation is requested. The event data includes the destination date
     * and whether focus should move into the day grid.
     */
    onNavigateDate?: EventHandler<CalendarMonthNavigateData>;
    /**
     * Called when the heading is activated while the year picker is hidden, or when a month is selected
     * to return to the day view.
     */
    onHeaderSelect?: EventHandler<CalendarMonthHeaderSelectData>;
    /**
     * Whether the year picker is hidden
     * @default false
     */
    yearPickerHidden?: boolean;
};

/** Semantic month row passed to getters, without DOM props on the row or its cells. */
declare type CalendarMonthRowData = CalendarGridRow<CalendarMonthCellData>;

/** Overrides for a month row. */
declare type CalendarMonthRowProps = {
    /**
     * Overrides for the row's `<div>`. Its month cells remain controlled by the renderer.
     */
    root?: React_2.ComponentProps<'div'>;
};

/**
 * Data describing a month selection and its bounded, unrestricted date range.
 */
declare type CalendarMonthSelectData = EventData<'click' | 'keydown', React_2.SyntheticEvent<HTMLButtonElement>> & {
    /**
     * An available day in the selected month, preserving the navigated day of the month when possible.
     */
    date: Date;
    /**
     * The dates selected for the configured range, excluding restricted and out-of-bounds dates.
     */
    selectedDateRange: Date[];
};

/**
 * Slots rendered by the month picker.
 */
declare type CalendarMonthSlots = {
    /**
     * The outer container of the month picker.
     */
    root: NonNullable<Slot<'div'>>;
    /**
     * Holds the year title and the navigation buttons.
     */
    header: NonNullable<Slot<'div'>>;
    /**
     * The year label, which opens the year picker when it is not hidden.
     */
    heading: NonNullable<Slot<'button', 'div'>>;
    /**
     * Wraps the previous and next year buttons.
     */
    navigation: NonNullable<Slot<'div'>>;
    /**
     * The button to navigate to the previous year.
     */
    previousYearButton: NonNullable<Slot<'button'>>;
    /**
     * The button to navigate to the next year.
     */
    nextYearButton: NonNullable<Slot<'button'>>;
    /**
     * The grid holding the month rows, with a roving tab stop and arrow, Home and End navigation.
     */
    grid: NonNullable<Slot<'div'>>;
    /**
     * The year picker, which replaces the whole month picker while it is open. Only rendered while
     * `isYearPickerVisible` is set.
     */
    yearPicker: NonNullable<Slot<typeof CalendarYear>>;
};

/** Event data reported when the displayed date changes through user interaction. */
declare type CalendarNavigateData = EventData<'click' | 'keydown', React_2.SyntheticEvent<HTMLElement>> & {
    /** The date displayed by the calendar. */
    displayedDate: Date;
};

/**
 * Props for the Calendar component.
 */
declare type CalendarProps = DistributiveOmit<ComponentProps<Partial<CalendarSlots>>, 'defaultValue'> & {
    /**
     * Callback for when a date is selected
     * @param date - The date the user selected
     * @param selectedDateRange - The resultant list of dates that are selected based on the date range type set
     * for the component.
     */
    onSelectDate?: EventHandler<CalendarSelectDateData>;
    /**
     * Callback for when calendar is closed
     */
    onDismiss?: EventHandler<CalendarDismissData>;
    /**
     * The selected date. `null` represents an explicitly empty controlled selection.
     * A value outside `minDate`/`maxDate` renders as an empty selection and warns in development.
     */
    value?: Date | null;
    /** The initial selected date when uncontrolled. `null` starts with no selection. */
    defaultValue?: Date | null;
    /** The displayed date, controlled independently of value. When omitted, external value changes navigate automatically. */
    displayedDate?: Date;
    /** The initial displayed date when uncontrolled. */
    defaultDisplayedDate?: Date;
    /** Called once per user navigation or selection action. External prop changes do not fire this callback. */
    onDisplayedDateChange?: EventHandler<CalendarNavigateData>;
    /** The active picker in an overlay layout. */
    view?: CalendarView;
    /** The initial active picker when uncontrolled. */
    defaultView?: CalendarView;
    /** Called when user interaction changes the active picker. */
    onViewChange?: EventHandler<CalendarViewChangeData>;
    /**
     * How the day and month pickers are arranged. Consumers control responsive layout changes.
     * @default 'sideBySide'
     */
    layout?: CalendarLayout;
    /**
     * Value of today. If unspecified, the current time on the client machine is used. Pass this explicitly
     * while server rendering to keep the server and client calendars consistent.
     */
    today?: Date;
    /**
     * The date range type indicating how many days should be selected as the user
     * selects days
     * @default 'day'
     */
    dateRangeType?: DateRangeType;
    /**
     * The first day of the week for your locale.
     * @default 'sunday'
     */
    firstDayOfWeek?: DayOfWeek;
    /**
     * Defines when the first week of the year should start.
     * @default 'firstDay'
     */
    firstWeekOfYear?: FirstWeekOfYear;
    /**
     * Whether the calendar should show the week-of-year number before each week row.
     * @default false
     */
    showWeekNumbers?: boolean;
    /**
     * Overrides date and accessibility label formatters. Omitted formatters use the defaults.
     */
    formatters?: Partial<CalendarFormatters>;
    /**
     * If set the Calendar will not allow navigation to or selection of a date earlier than this value.
     */
    minDate?: Date;
    /**
     * If set the Calendar will not allow navigation to or selection of a date later than this value.
     */
    maxDate?: Date;
    /**
     * If set the Calendar will not allow selection of dates in this array.
     */
    restrictedDates?: Date[];
    /**
     * The days that are selectable when `dateRangeType` is `workWeek`.
     * If `dateRangeType` is not `workWeek` this property does nothing.
     * @default ['monday', 'tuesday', 'wednesday', 'thursday', 'friday']
     */
    workWeekDays?: DayOfWeek[];
    /**
     * Allows all dates and buttons to be focused, including disabled ones
     * @default false
     */
    allFocusable?: boolean;
    /**
     * Number of columns in the month picker.
     * @default 4
     */
    calendarMonthColumns?: 3 | 4;
    /**
     * Number of columns in the year picker.
     * @default 4
     */
    calendarYearColumns?: 3 | 4;
};

/**
 * Event data for a date selection.
 */
declare type CalendarSelectDateData = EventData<'click' | 'keydown', React_2.SyntheticEvent<HTMLElement>> & {
    /**
     * The date selected by the user.
     */
    date: Date;
    /**
     * Dates selected according to the configured range type.
     */
    selectedDateRange: Date[];
};

/**
 * Slots available to the Calendar component.
 */
declare type CalendarSlots = {
    /**
     * Root container.
     */
    root: NonNullable<Slot<'div'>>;
    /**
     * Announces the selected date to assistive technology.
     */
    liveRegion: NonNullable<Slot<'div'>>;
    /**
     * The day picker. Set to `null` to select months without showing the day picker.
     */
    dayPicker?: Slot<typeof CalendarDay>;
    /**
     * Separates the day picker from the month picker when both are visible.
     */
    divider: NonNullable<Slot<'div'>>;
    /**
     * Wraps the month picker.
     */
    monthPickerWrapper: NonNullable<Slot<'div'>>;
    /**
     * The month picker. Set to `null` to show only the day picker.
     */
    monthPicker?: Slot<typeof CalendarMonth>;
    /**
     * The "go to today" button, rendered as the root's last child.
     * Use CSS to position it below either picker or across the full width. Set to `null` to hide it.
     */
    goToTodayButton?: Slot<'button'>;
};

/** Picker views available when Calendar uses an overlay layout. */
declare type CalendarView = 'day' | 'month';

/** Event data reported when user interaction changes the active overlay view. */
declare type CalendarViewChangeData = EventData<'click' | 'keydown', React_2.SyntheticEvent<HTMLElement>> & {
    /** The active picker when the calendar uses an overlay layout. */
    view: CalendarView;
};

/**
 * CalendarYear shows a range of years and lets the user pick one.
 */
declare const CalendarYear: ForwardRefComponent<CalendarYearProps>;

/**
 * Semantic year data stored in the grid and passed to cell getters, without DOM props.
 */
declare type CalendarYearCellData = {
    /**
     * The numeric year represented by the cell.
     */
    year: number;
    /**
     * Formatted year label.
     */
    label: string;
    /**
     * Whether this is the current year.
     */
    isCurrent: boolean;
    /**
     * Whether this is the selected year.
     */
    isSelected: boolean;
    /**
     * Whether this is the focus target in the displayed range.
     */
    isNavigated: boolean;
    /**
     * Whether this year cannot be selected.
     */
    isDisabled: boolean;
};

/** Overrides for a year gridcell and its nested button. */
declare type CalendarYearCellProps = {
    /**
     * Overrides for the `<div role="gridcell">`.
     */
    root?: Omit<React_2.ComponentProps<'div'>, 'children'>;
    /**
     * Overrides for the nested year button. Set `children` to customize the year content.
     */
    button?: React_2.ComponentProps<'button'>;
};

/**
 * The imperative API exposed through CalendarYear's `imperativeRef` prop.
 */
declare type CalendarYearHandle = {
    /**
     * Focuses the navigated year, or the selected/current year when navigation is unspecified,
     * within the focusable visible range.
     */
    focus(options?: FocusOptions): void;
};

/**
 * Data describing activation of the year-range heading.
 */
declare type CalendarYearHeaderSelectData = EventData<'click' | 'keydown', React_2.SyntheticEvent<HTMLElement>> & {
    /**
     * Whether focus should move to the parent picker when returning from the year view.
     */
    focus: boolean;
};

/**
 * Data describing navigation to another visible year range.
 */
declare type CalendarYearNavigateData = EventData<'click' | 'keydown', React_2.SyntheticEvent<HTMLButtonElement>> & {
    /**
     * The first year of the destination range.
     */
    year: number;
};

/**
 * Props for the year picker. Shared selection, boundaries, and formatting come from CalendarProvider.
 */
declare type CalendarYearProps = ComponentProps<Partial<CalendarYearSlots>> & {
    /**
     * Provides access to the picker's focus handle. The regular `ref` points to the root element.
     */
    imperativeRef?: React_2.Ref<CalendarYearHandle>;
    /**
     * The currently navigated year. Takes precedence over selectedYear for the displayed range and focus.
     */
    navigatedYear?: number;
    /**
     * The highlighted year. Initializes the displayed range and focus only when navigatedYear is omitted.
     * Defaults to the year of the Calendar's selected value. Set to null for an empty selection.
     */
    selectedYear?: number | null;
    /**
     * Overrides each year gridcell and its nested button. Use button.children to customize its content.
     * Receives semantic year data and a formatted label, not DOM props.
     * Refs are composed, class names appended and styles merged.
     * Defined consumer props override defaults, including roles, focus, disabled/selection state and data attributes.
     * Consumers are responsible for preserving accessibility and interaction semantics when overriding these props.
     * Handlers run before the delegated grid behavior; preventDefault cancels selection.
     * Called when the renderer resolves the cell's props, not while the hook builds its data.
     */
    getCellProps?: (year: CalendarYearCellData) => CalendarYearCellProps;
    /**
     * Overrides each row's default props, including its role and focus attributes, without replacing its cells.
     * Receives semantic row and year data. Called when the renderer resolves the row's props.
     */
    getRowProps?: (row: CalendarYearRowData) => CalendarYearRowProps;
    /**
     * Called when a year is selected. The event data includes the selected year.
     */
    onSelectYear?: EventHandler<CalendarYearSelectData>;
    /**
     * Called when navigation changes the visible twelve-year range.
     * The event data includes the first year of the destination range.
     */
    onNavigateDate?: EventHandler<CalendarYearNavigateData>;
    /**
     * Called when the year-range heading is activated to return to the parent picker.
     */
    onHeaderSelect?: EventHandler<CalendarYearHeaderSelectData>;
};

/**
 * A year range and its formatted display value.
 */
declare type CalendarYearRangeLabelData = {
    /**
     * The starting year of the range.
     */
    fromYear: number;
    /**
     * The ending year of the range.
     */
    toYear: number;
    /**
     * The formatted display value of the year range.
     */
    formattedRange: string;
};

/** Semantic year row passed to getters, without DOM props on the row or its cells. */
declare type CalendarYearRowData = CalendarGridRow<CalendarYearCellData>;

/** Overrides for a year row. */
declare type CalendarYearRowProps = {
    /**
     * Overrides for the row's `<div>`. Its year cells remain controlled by the renderer.
     */
    root?: Omit<React_2.ComponentProps<'div'>, 'children'>;
};

/**
 * Data describing a year selection.
 */
declare type CalendarYearSelectData = EventData<'click' | 'keydown', React_2.SyntheticEvent<HTMLButtonElement>> & {
    /**
     * The selected year.
     */
    year: number;
};

/**
 * Slots rendered by the year picker.
 */
declare type CalendarYearSlots = {
    /**
     * The outer container of the year picker.
     */
    root: NonNullable<Slot<'div'>>;
    /**
     * Holds the year range title and the navigation buttons.
     */
    header: NonNullable<Slot<'div'>>;
    /**
     * The year range label. Renders as a `button` when `onHeaderSelect` is set, otherwise as a
     * plain `div`.
     */
    heading: NonNullable<Slot<'button', 'div'>>;
    /**
     * Wraps the previous and next range buttons.
     */
    navigation: NonNullable<Slot<'div'>>;
    /**
     * The button to navigate to the previous year range.
     */
    previousRangeButton: NonNullable<Slot<'button'>>;
    /**
     * The button to navigate to the next year range.
     */
    nextRangeButton: NonNullable<Slot<'button'>>;
    /**
     * The grid holding the year rows, with a roving tab stop and arrow, Home and End navigation.
     */
    grid: NonNullable<Slot<'div'>>;
};

/**
 * DatePicker lets someone choose one calendar date from a field that opens a non-modal Calendar dialog, and
 * optionally type a date they already know.
 *
 * The field needs an accessible name from a Field label, `aria-labelledby` or `aria-label`.
 */
export declare const DatePicker: DatePickerComponent;

/**
 * Props shared by both DatePicker field controls.
 */
export declare type DatePickerBaseProps = {
    /**
     * Calendar configuration. Selection, boundaries and today are owned by DatePicker.
     */
    calendar?: NonNullable<Slot<DatePickerCalendarProps>>;
    /**
     * The committed date. `null` represents an explicitly empty controlled value.
     */
    value?: Date | null;
    /**
     * The initially committed date when uncontrolled.
     */
    defaultValue?: Date | null;
    /**
     * Called when a calendar selection, accepted typed date, or clearing the field changes the committed date.
     */
    onDateChange?: EventHandler<DatePickerDateChangeData>;
    /**
     * Called after typed text or a calendar selection is validated.
     */
    onValidationResult?: EventHandler<DatePickerValidationResultData>;
    /**
     * Shown while no date is committed.
     * @default 'Select a date'
     */
    placeholder?: string;
    /**
     * Sets `aria-required` on the field control. A surrounding Field owns the visual required affordance.
     * @default false
     */
    required?: boolean;
    /**
     * Controlled popup visibility.
     */
    open?: boolean;
    /**
     * Initial popup visibility when uncontrolled.
     * @default false
     */
    defaultOpen?: boolean;
    /**
     * Called when user interaction requests a popup visibility change.
     */
    onOpenChange?: EventHandler<DatePickerOpenChangeData>;
    /**
     * Shows the calendar's Go-to-today button, which shows today's month and focuses today. Style the button through
     * `calendar.goToTodayButton`.
     * @default false
     */
    showGoToToday?: boolean;
    /**
     * Value of today. Pass this explicitly while server rendering to keep server and client output consistent.
     */
    today?: Date;
    /**
     * Inclusive local-date lower boundary for calendar and typed dates.
     */
    minDate?: Date;
    /**
     * Inclusive local-date upper boundary for calendar and typed dates.
     */
    maxDate?: Date;
    /**
     * Formats the committed date for display.
     * @default English long date, such as "August 12, 2026"
     */
    formatDate?: (date: Date) => string;
    /**
     * Parses typed text into a local date, returning `null` when the text is not a valid date.
     * The default accepts `YYYY-MM-DD`, an English month name followed by day and four-digit year, and `M/D/YYYY`.
     */
    parseDate?: (text: string) => Date | null;
    /**
     * Describes a validation error in `errorMessage`, including an accepted format or the allowed range.
     */
    formatErrorMessage?: (data: DatePickerErrorMessageData) => string;
    /**
     * Where the popup opens relative to the field.
     * @default { position: 'below', align: 'start' }
     */
    positioning?: PositioningShorthand;
};

/**
 * Props for a DatePicker with a non-editable field. Native props and the forwarded ref target the `<button>` trigger.
 */
export declare type DatePickerButtonProps = Omit<ComponentProps<Partial<DatePickerSlots>, 'trigger'>, DatePickerOmittedNativeProps> & DatePickerBaseProps & {
    /**
     * Renders an editable text input instead of a non-editable trigger.
     * @default false
     */
    allowTextInput?: false;
};

/**
 * Calendar configuration accepted by DatePicker. Selection, boundaries and today belong on DatePicker.
 */
export declare type DatePickerCalendarProps = Omit<CalendarProps, 'value' | 'defaultValue' | 'today' | 'minDate' | 'maxDate' | 'displayedDate' | 'defaultDisplayedDate'>;

/**
 * The DatePicker component type. Like `ForwardRefComponent`, but the forwarded ref follows `allowTextInput`: it is the
 * `<input>` when `allowTextInput` is set, otherwise the `<button>` trigger.
 */
export declare type DatePickerComponent = React_2.NamedExoticComponent<(DatePickerButtonProps & RefAttributes<HTMLButtonElement>) | (DatePickerInputProps & RefAttributes<HTMLInputElement>)>;

/**
 * Data reported when the committed date changes.
 */
export declare type DatePickerDateChangeData = EventData<string, React_2.SyntheticEvent | Event> & {
    /**
     * The newly committed date, or `null` when the field was cleared.
     */
    value: Date | null;
    /**
     * How the date was committed.
     */
    reason: 'calendar' | 'input' | 'clear';
};

/**
 * Data passed to `formatErrorMessage`.
 */
export declare type DatePickerErrorMessageData = {
    /**
     * The validation error to describe.
     */
    error: DatePickerErrorType;
    /**
     * The inclusive lower boundary, if any.
     */
    minDate?: Date;
    /**
     * The inclusive upper boundary, if any.
     */
    maxDate?: Date;
    /**
     * Formats a date the same way the field does.
     */
    formatDate: (date: Date) => string;
};

/**
 * Why a typed or committed date was rejected.
 */
export declare type DatePickerErrorType = 'invalid-input' | 'out-of-bounds' | 'required-input';

/**
 * Props for a DatePicker that accepts typed dates. Native props and the forwarded ref target the `<input>`.
 */
export declare type DatePickerInputProps = Omit<ComponentProps<Partial<DatePickerSlots>, 'input'>, DatePickerOmittedNativeProps> & DatePickerBaseProps & {
    /**
     * Renders an editable text input instead of a non-editable trigger.
     */
    allowTextInput: true;
};

/**
 * Native props that DatePicker owns or that do not apply to its field control.
 */
declare type DatePickerOmittedNativeProps = 'calendar' | 'value' | 'defaultValue' | 'onChange' | 'type' | 'readOnly' | 'placeholder' | 'children' | 'required';

/**
 * Data reported for a requested popup visibility change.
 */
export declare type DatePickerOpenChangeData = EventData<string, React_2.SyntheticEvent | Event> & {
    /**
     * The requested open state.
     */
    open: boolean;
    /**
     * What requested the change.
     * - `trigger`: activation of the non-editable field
     * - `icon`: click on the calendar icon
     * - `keyboard`: Alt + Arrow Down, or Escape on the field
     * - `selection`: a day was selected
     * - `escape`: Escape inside the calendar
     * - `focusOut`: focus left the calendar
     * - `outsideClick`: a pointer press outside the date picker
     */
    reason: 'trigger' | 'icon' | 'keyboard' | 'selection' | 'escape' | 'focusOut' | 'outsideClick';
};

/**
 * Props for the DatePicker component, discriminated by `allowTextInput`. Native props and the forwarded ref are applied
 * to the field control: the `<input>` when `allowTextInput` is set, otherwise the `<button>`.
 */
export declare type DatePickerProps = DatePickerButtonProps | DatePickerInputProps;

/**
 * Slots available to the DatePicker component.
 */
export declare type DatePickerSlots = {
    /**
     * Field chrome wrapping the field control and the calendar icon. Receives `className` and `style`; every other
     * native prop is forwarded to the field control.
     */
    root: NonNullable<Slot<'div'>>;
    /**
     * The editable field control, rendered only when `allowTextInput` is set. Receives the forwarded ref.
     */
    input?: NonNullable<Slot<'input'>>;
    /**
     * The non-editable field control, rendered unless `allowTextInput` is set. Receives the forwarded ref.
     */
    trigger?: NonNullable<Slot<'button'>>;
    /**
     * Displays the formatted selected date, or the placeholder when empty, inside the trigger.
     */
    displayValue: NonNullable<Slot<'span'>>;
    /**
     * The trailing calendar icon. It is decorative inside the trigger. With `allowTextInput`, it is a button that toggles
     * the calendar on click, Enter or Space without adding a tab stop. Provide the icon as its children.
     */
    icon?: Slot<'span'>;
    /**
     * Correction text for a rejected typed date. It is a polite live region rendered after the field and referenced by
     * the field's `aria-describedby` while the error is shown. Set to `null` to show the error through a Field instead.
     */
    errorMessage?: Slot<'div'>;
    /**
     * The non-modal calendar dialog, mounted only while open and shown in the top layer with the Popover API.
     */
    popupSurface: NonNullable<Slot<'div'>>;
    /**
     * The Calendar shown in the popup. Selection, boundaries and today are owned by DatePicker.
     */
    calendar: NonNullable<Slot<typeof Calendar>>;
};

/**
 * State used to render the DatePicker component.
 */
export declare type DatePickerState = ComponentState<DatePickerSlots> & Required<Pick<DatePickerBaseProps, 'open' | 'required'>> & {
    /**
     * Whether the field accepts typed dates.
     */
    allowTextInput: boolean;
    /**
     * Whether the date picker is disabled.
     */
    disabled: boolean;
    /**
     * The committed date.
     */
    value: Date | null;
    /**
     * The current validation error, if any.
     */
    error: DatePickerErrorType | undefined;
    root: {
        /**
         * Present while the calendar is open.
         */
        'data-open'?: string;
        /**
         * Present when the date picker is disabled.
         */
        'data-disabled'?: string;
        /**
         * Present while a validation error is shown.
         */
        'data-invalid'?: string;
        /**
         * Present when the field accepts typed dates.
         */
        'data-editable'?: string;
        /**
         * Present while no date is committed and the placeholder is shown.
         */
        'data-placeholder'?: string;
    };
};

/**
 * Data reported after DatePicker validates pending text or a calendar selection.
 */
export declare type DatePickerValidationResultData = EventData<string, React_2.SyntheticEvent | Event> & {
    /**
     * The validation error, or `undefined` when the value was accepted.
     */
    error?: DatePickerErrorType;
};

/**
 * The supported date range types, describing how many days are selected when the user picks a date.
 */
declare type DateRangeType = 'day' | 'week' | 'month' | 'workWeek';

declare interface Day {
    /**
     * Local year, zero-based month, and day joined with hyphens (`year-month-day`)
     */
    key: string;
    /**
     * `Date.getDate()` value of current date
     */
    date: string;
    /**
     * `Date` object of current date
     */
    originalDate: Date | null;
    /**
     * Whether this cell represents a civil date that does not exist in the local timezone.
     */
    isPlaceholder: boolean;
    /**
     * Whether the current date is in the same month as the navigated date
     */
    isInMonth: boolean;
    /**
     * Is current date is "today" date
     */
    isToday: boolean;
    /**
     * Whether the current date is selected in a range
     */
    isSelected: boolean;
    /**
     * Whether the current date is selected without a range
     */
    isSingleSelected: boolean;
    /**
     * Is current date within restriction boundaries
     */
    isInBounds: boolean;
    /**
     * Is current date marked
     */
    isMarked: boolean;
}

declare interface DayGridOptions extends RestrictedDatesOptions {
    /**
     * The first day of the week for your locale.
     */
    firstDayOfWeek: DayOfWeek;
    /**
     * The date range type indicating how  many days should be selected as the user
     * selects days
     */
    dateRangeType: DateRangeType;
    /**
     * The number of days to select while `dateRangeType` is `day`. Used in order to have multi-day
     * views.
     */
    daysToSelectInDayView?: number;
    /**
     * Value of today. If unspecified, current time in client machine will be used.
     */
    today?: Date;
    /**
     * The days that are selectable when `dateRangeType` is `workWeek`.
     * If `dateRangeType` is not `workWeek` this property does nothing.
     */
    workWeekDays?: DayOfWeek[];
    /**
     * Which days in the generated grid should be marked.
     */
    markedDays?: Date[];
    /**
     * The currently selected date
     */
    selectedDate?: Date | null;
    /**
     * The currently navigated date
     */
    navigatedDate: Date;
    /**
     * How many weeks to show by default. If not provided, will show enough weeks to display the current
     * month, between 4 and 6 depending
     */
    weeksToShow?: number;
}

/**
 * The days of the week.
 */
declare type DayOfWeek = 'sunday' | 'monday' | 'tuesday' | 'wednesday' | 'thursday' | 'friday' | 'saturday';

/**
 * Formats a date as an English long date, such as "August 12, 2026".
 */
export declare const defaultFormatDate: (date: Date) => string;

/**
 * Parses the English date formats accepted by DatePicker: `YYYY-MM-DD`, a full or abbreviated month name followed by
 * the day and a four-digit year with an optional comma, and `M/D/YYYY`. Date-only ISO values are local calendar dates,
 * not UTC timestamps.
 *
 * @returns The parsed local date, or `null` when the text is not a real calendar date in a supported format.
 */
export declare const defaultParseDate: (text: string) => Date | null;

/**
 * Determines which week counts as the first week of the year.
 * - `firstDay` - the week containing January 1st.
 * - `firstFullWeek` - the first week entirely within the new year.
 * - `firstFourDayWeek` - the first week with at least four days in the new year.
 */
declare type FirstWeekOfYear = 'firstDay' | 'firstFullWeek' | 'firstFourDayWeek';

declare type PositioningProps = Pick<PositioningProps_2, 'align' | 'coverTarget' | 'fallbackPositions' | 'matchTargetSize' | 'offset' | 'pinned' | 'position' | 'positioningRef' | 'strategy' | 'target'>;

declare type PositioningShorthand = PositioningProps | PositioningShorthandValue;

/**
 * Renders the final JSX of DatePicker. The popup surface follows the field in the DOM, so Tab and Shift+Tab move
 * between the field and the calendar in their natural order.
 */
export declare const renderDatePicker: (state: DatePickerState) => JSXElement;

declare interface RestrictedDatesOptions {
    /**
     * If set the Calendar will not allow navigation to or selection of a date earlier than this value.
     */
    minDate?: Date;
    /**
     * If set the Calendar will not allow navigation to or selection of a date later than this value.
     */
    maxDate?: Date;
    /**
     * If set the Calendar will not allow selection of dates in this array.
     */
    restrictedDates?: Date[];
}

/**
 * Creates DatePicker state: the committed date, pending typed text and validation, the popup lifecycle and its focus
 * management, and the Calendar configuration.
 * @param props - Props from this instance of DatePicker.
 * @param ref - Reference to the field control: the input when `allowTextInput` is set, otherwise the trigger button.
 */
export declare const useDatePicker: (props: DatePickerProps, ref: React_2.Ref<HTMLInputElement | HTMLButtonElement>) => DatePickerState;

export { }