import { default as default_2 } from 'react';
import { ReactNode } from 'react';

/**
 * Add days to a date
 * @param day - Day to add days to
 * @param days - Number of days to add (can be negative)
 * @param locale - Calendar locale
 * @returns New Day object with days added
 */
export declare function addDays(day: Day, days: number, calendarSystem?: CalendarLocale): Day;

/**
 * Add months to a date
 * @param day - Day to add months to
 * @param months - Number of months to add (can be negative)
 * @param locale - Calendar locale
 * @returns New Day object with months added
 */
export declare function addMonths(day: Day, months: number, calendarSystem?: CalendarLocale): Day;

/**
 * Add years to a date
 * @param day - Day to add years to
 * @param years - Number of years to add (can be negative)
 * @param locale - Calendar locale
 * @returns New Day object with years added
 */
export declare function addYears(day: Day, years: number, calendarSystem?: CalendarLocale): Day;

/**
 * Custom CSS classes for calendar components
 */
declare interface CalendarClasses {
    /** Header CSS class */
    header?: string;
    /** Days grid CSS class */
    days?: string;
    /** Months view CSS class */
    months?: string;
    /** Years view CSS class */
    years?: string;
}

/**
 * Date constraints for selection (internal, normalized)
 */
export declare interface CalendarConstraints {
    /** Maximum selectable date */
    maxDate?: Day;
    /** Minimum selectable date */
    minDate?: Day;
    /** List of disabled dates */
    disabledDates?: Day[];
    /** Custom function to check if a date should be disabled */
    isDateDisabled?: (date: Day) => boolean;
}

/**
 * Date constraints for selection (user-facing, accepts various formats)
 */
export declare interface CalendarConstraintsInput {
    /** Maximum selectable date (accepts Day, Date, string, or number) */
    maxDate?: DateInput;
    /** Minimum selectable date (accepts Day, Date, string, or number) */
    minDate?: DateInput;
    /** List of disabled dates (accepts Day, Date, string, or number) */
    disabledDates?: DateInput[];
    /** Custom function to check if a date should be disabled */
    isDateDisabled?: (date: Day) => boolean;
}

/**
 * Calendar customization options
 */
export declare interface CalendarCustomization {
    /** Custom CSS classes */
    classes?: CalendarClasses;
    /** Custom icons */
    icons?: CalendarIcons;
    /** Custom labels */
    labels?: CalendarLabels;
    /** Custom translations - overrides default translations for the selected locale */
    translations?: Partial<CalendarTranslations>;
}

/**
 * Error information for normalization/constraint failures
 */
export declare interface CalendarError {
    /** Error type */
    type: 'normalization' | 'validation';
    /** Field that failed (e.g., 'initValue', 'maxDate', 'minDate', 'disabledDates') */
    field: string;
    /** Original value that failed */
    value: unknown;
    /** Error message */
    message: string;
}

/**
 * Custom icons for calendar navigation
 */
declare interface CalendarIcons {
    /** Next month button icon */
    next?: default_2.ComponentType<{
        className?: string;
    }>;
    /** Previous month button icon */
    previous?: default_2.ComponentType<{
        className?: string;
    }>;
    /** Calendar trigger icon (for DtPicker only) */
    calendar?: default_2.ComponentType<{
        className?: string;
    }>;
}

/**
 * Custom labels/text for calendar
 */
declare interface CalendarLabels {
    /** Next month button title */
    nextMonth?: string;
    /** Previous month button title */
    previousMonth?: string;
}

/**
 * Calendar list style for year/month views
 * - 'grid': Display as grid
 * - 'list': Display as list
 */
export declare type CalendarListStyle = 'grid' | 'list';

/**
 * Calendar list style for year/month views
 * - 'grid': Display as grid
 * - 'list': Display as list
 */
declare type CalendarListStyle_2 = 'grid' | 'list';

/**
 * Calendar system
 * - 'gregorian': Gregorian calendar
 * - 'jalali': Jalali (Persian) calendar
 */
export declare type CalendarLocale = 'gregorian' | 'jalali';

declare interface CalendarSelectionMulti {
    type: 'multi';
    /**
     * Callback function called when date changes
     * @param normalizedValue - Internal Multi object (array of Day objects)
     * @param jsDateValue - Array of JavaScript Date objects (always Gregorian)
     * @param formattedString - Formatted string (e.g., "3 dates selected")
     */
    onChange(normalizedValue: Multi | null, jsDateValue?: Date[] | null, formattedString?: string | null): void;
}

declare interface CalendarSelectionRange {
    type: 'range';
    /**
     * Callback function called when date changes
     * @param normalizedValue - Internal Range object (maintains calendar system integrity)
     * @param jsDateValue - Range of JavaScript Date objects (always Gregorian)
     * @param formattedString - Formatted range string (e.g., "From X to Y")
     */
    onChange(normalizedValue: Range_2 | null, jsDateValue?: RangeDate | null, formattedString?: string | null): void;
}

declare interface CalendarSelectionSingle {
    type?: 'single';
    /**
     * Callback function called when date changes
     * @param normalizedValue - Internal Day object (maintains calendar system integrity)
     * @param jsDateValue - Native JavaScript Date object (always Gregorian)
     * @param formattedString - Formatted string based on dateFormat prop
     */
    onChange(normalizedValue: Day | null, jsDateValue?: Date | null, formattedString?: string | null): void;
}

declare interface CalendarSelectionWeek {
    type: 'week';
    /**
     * Callback function called when date changes
     * @param normalizedValue - Internal Range object (week is represented as Range)
     * @param jsDateValue - Range of JavaScript Date objects (always Gregorian)
     * @param formattedString - Formatted range string (e.g., "From X to Y")
     */
    onChange(normalizedValue: Range_2 | null, jsDateValue: RangeDate | null, formattedString: string | null): void;
}

/**
 * Calendar system input (accepts shorthand aliases)
 * - 'gregorian' or 'ge': Gregorian calendar
 * - 'jalali' or 'ja': Jalali (Persian) calendar
 */
export declare type CalendarSystem = 'gregorian' | 'jalali' | 'ge' | 'ja';

/**
 * Translation object containing all text strings for a locale
 */
declare interface CalendarTranslations {
    /** Month names (12 elements, index 0-11 for months 1-12) */
    months: string[];
    /** Weekday names (7 elements, starting from first day of week) */
    weekdays: string[];
    /** Text direction */
    direction: 'ltr' | 'rtl';
    /** Number system - automatically determined from locale */
    numbers: 'latin' | 'persian';
    /** Common labels */
    labels: {
        /** Today button text */
        today: string;
        /** Clear button text - aria-label (accessibility only) - DtPicker only */
        clear: string;
        /** OK/Confirm button text */
        ok: string;
        /** Next month button title */
        nextMonth: string;
        /** Previous month button title */
        previousMonth: string;
        /** Month selection view label */
        selectMonth: string;
        /** Year selection view label */
        selectYear: string;
        /** Input field from label (for date range display in DtPicker) */
        from: string;
        /** Input field to label (for date range display in DtPicker) */
        to: string;
        /** Time selector from label (for time input in range selection) */
        timeFrom: string;
        /** Time selector to label (for time input in range selection) */
        timeTo: string;
        /** AM indicator */
        am: string;
        /** PM indicator */
        pm: string;
    };
    /** Preset range labels */
    presetRanges: {
        yesterday: string;
        last7days: string;
        last30days: string;
        thisMonth: string;
        lastMonth: string;
    };
}

/**
 * Calendar selection type
 * - 'single': Select a single date
 * - 'range': Select a date range
 * - 'multi': Select multiple dates
 * - 'week': Select an entire week
 */
export declare type CalendarType = 'single' | 'range' | 'multi' | 'week';

/**
 * Supported UI locales for internationalization
 */
declare type CalendarUILocale = 'en' | 'fa' | 'de' | 'es' | 'fr' | 'ko';

/**
 * Convert Jalali date to Gregorian date string
 * @param date - Day object in Jalali calendar
 * @param divider - String divider (default: '/')
 * @returns Formatted Gregorian date string
 */
export declare function convertToEn(date: Day, divider?: string): string;

/**
 * Convert Gregorian date to Jalali date string
 * @param date - Day object in Gregorian calendar
 * @param divider - String divider (default: '/')
 * @returns Formatted Jalali date string
 */
export declare function convertToFa(date: Day, divider?: string): string;

/**
 * Convert a Jalali date to Gregorian
 * Alias for jalaliToGregorian for convenience
 * @param day - Day object in Jalali calendar
 * @returns Day object in Gregorian calendar
 */
export declare function convertToGregorian(day: Day): Day;

/**
 * Convert a Gregorian date to Jalali
 * Alias for gregorianToJalali for convenience
 * @param day - Day object in Gregorian calendar
 * @returns Day object in Jalali calendar
 */
export declare function convertToJalali(day: Day): Day;

export declare interface CustomPresetRange {
    /** Label for the custom preset button */
    label: string;
    /** Date range for the preset */
    range: Range_2;
}

/**
 * Acceptable date input formats that can be normalized
 */
export declare type DateInput = Day | Date | string | number;

/**
 * Day representation
 */
export declare interface Day {
    /** Year */
    year: number;
    /** Month (1-12) */
    month: number;
    /** Day of month (1-31) */
    day: number;
    /** Full day string representation (optional) */
    fullDay?: string;
    /** Hour (optional, for datetime) */
    hour?: number;
    /** Minute (optional, for datetime) */
    minute?: number;
}

/**
 * Convert Day to string format (for utility functions like convertToFa/convertToEn)
 */
export declare function dayToString(day: Day, divider?: string): string;

/**
 * DtCalendar Component
 *
 * A standalone calendar component without input field.
 *
 * @example
 * ```tsx
 * import { DtCalendar } from 'react-calendar-datetime-picker'
 *
 * function App() {
 *   const [date, setDate] = useState(null)
 *   return <DtCalendar onChange={setDate} calendarSystem="jalali" />
 * }
 * ```
 */
export declare const DtCalendar: default_2.FC<DtCalendarProps>;

declare type DtCalendarProps = DtCalendarPropsSingle | DtCalendarPropsRange | DtCalendarPropsMulti | DtCalendarPropsWeek;

declare interface DtCalendarPropsBase extends SharedCalendarProps {
    /**
     * Callback that runs when the calendar value is changed
     * Note: requires initValue to be provided
     */
    onCalenderChange?: (date: Day | Range_2 | Multi | null) => void;
}

declare interface DtCalendarPropsMulti extends DtCalendarPropsBase, CalendarSelectionMulti {
}

declare interface DtCalendarPropsRange extends DtCalendarPropsBase, CalendarSelectionRange {
}

declare interface DtCalendarPropsSingle extends DtCalendarPropsBase, CalendarSelectionSingle {
}

declare interface DtCalendarPropsWeek extends DtCalendarPropsBase, CalendarSelectionWeek {
}

/**
 * DtPicker Component
 *
 * A date picker with input field that opens a modal calendar.
 *
 * @example
 * ```tsx
 * import { DtPicker } from 'react-calendar-datetime-picker'
 *
 * function App() {
 *   const [date, setDate] = useState(null)
 *   return <DtPicker onChange={setDate} calendarSystem="gregorian" />
 * }
 * ```
 */
export declare const DtPicker: default_2.FC<DtPickerProps>;

declare type DtPickerProps = DtPickerPropsSingle | DtPickerPropsRange | DtPickerPropsMulti | DtPickerPropsWeek;

declare interface DtPickerPropsBase extends SharedCalendarProps {
    /**
     * Show time in input field
     * @default false
     */
    showTimeInput?: boolean;
    /**
     * Show clear button
     * @default false
     */
    clearBtn?: boolean;
    /**
     * Make input required
     * @default false
     */
    isRequired?: boolean;
    /**
     * Disable the picker
     * @default false
     */
    isDisabled?: boolean;
    /**
     * Placeholder text
     * @default 'Select date'
     */
    placeholder?: string;
    /**
     * Custom CSS class for input
     */
    inputClass?: string;
    /**
     * Auto-close calendar after selection
     * @default true
     */
    autoClose?: boolean;
    /**
     * Input element ID
     */
    inputId?: string;
    /**
     * Custom trigger element to replace the default input field
     * When provided, the input field will not be rendered
     */
    triggerElement?: ReactNode;
    /**
     * Custom CSS class for trigger wrapper when using custom trigger
     */
    triggerClass?: string;
}

declare interface DtPickerPropsMulti extends DtPickerPropsBase, CalendarSelectionMulti {
}

declare interface DtPickerPropsRange extends DtPickerPropsBase, CalendarSelectionRange {
}

declare interface DtPickerPropsSingle extends DtPickerPropsBase, CalendarSelectionSingle {
}

declare interface DtPickerPropsWeek extends DtPickerPropsBase, CalendarSelectionWeek {
}

/**
 * Get the end of day (sets time to 23:59)
 * @param day - Day object
 * @returns Day object with hour set to 23 and minute set to 59
 */
export declare function endOfDay(day: Day): Day;

/**
 * Get the end of month (last day of the month)
 * @param day - Day object
 * @param locale - Calendar locale
 * @returns Day object representing the last day of the month
 */
export declare function endOfMonth(day: Day, calendarSystem?: CalendarLocale): Day;

/**
 * Get the end of year (last day of the year)
 * @param day - Day object
 * @param locale - Calendar locale
 * @returns Day object representing the last day of the year
 */
export declare function endOfYear(day: Day, calendarSystem?: CalendarLocale): Day;

/**
 * Format a date value for input display based on type
 */
export declare function formatDateForInput(value: Day | Range_2 | Multi | Week | null, numberSystem: 'latin' | 'persian', type: CalendarType, showTime?: boolean, fromLabel?: string, toLabel?: string, dateFormat?: string): string;

/**
 * Get the difference in days between two dates
 * @param day1 - First day
 * @param day2 - Second day
 * @param locale - Calendar locale
 * @returns Number of days difference (positive if day1 is after day2)
 */
export declare function getDifferenceInDays(day1: Day, day2: Day, calendarSystem?: CalendarLocale): number;

/**
 * Get the difference in months between two dates
 * @param day1 - First day
 * @param day2 - Second day
 * @param locale - Calendar locale
 * @returns Number of months difference (positive if day1 is after day2)
 */
export declare function getDifferenceInMonths(day1: Day, day2: Day, _calendarSystem?: CalendarLocale): number;

/**
 * Get the difference in years between two dates
 * @param day1 - First day
 * @param day2 - Second day
 * @param locale - Calendar locale
 * @returns Number of years difference (positive if day1 is after day2)
 */
export declare function getDifferenceInYears(day1: Day, day2: Day, _calendarSystem?: CalendarLocale): number;

/**
 * Get today's date in the specified locale
 */
export declare function getToday(calendarSystem: CalendarLocale): Day;

/**
 * Convert Gregorian Day to Jalali Day
 * @throws {Error} If the input date is invalid or conversion fails
 */
export declare function gregorianToJalali(day: Day): Day;

/**
 * Initial value input types - accepts various formats that will be normalized
 * For 'single': accepts a single date in any format
 * For 'range': accepts a range object or a single date
 * For 'multi': accepts an array of dates in any format
 */
export declare type InitValueInput = DateInput | {
    from: DateInput;
    to: DateInput;
} | DateInput[] | null;

/**
 * Check if day1 is after day2
 * @param day1 - First day to compare
 * @param day2 - Second day to compare
 * @param locale - Calendar locale of the days
 * @returns true if day1 is after day2
 */
export declare function isAfter(day1: Day, day2: Day, calendarSystem?: CalendarLocale): boolean;

/**
 * Check if day1 is before day2
 * @param day1 - First day to compare
 * @param day2 - Second day to compare
 * @param locale - Calendar locale of the days
 * @returns true if day1 is before day2
 */
export declare function isBefore(day1: Day, day2: Day, calendarSystem?: CalendarLocale): boolean;

/**
 * Check if a day is between two other days (inclusive)
 * @param day - Day to check
 * @param start - Start day of the range
 * @param end - End day of the range
 * @param locale - Calendar locale of the days
 * @returns true if day is between start and end (inclusive)
 */
export declare function isBetween(day: Day, start: Day, end: Day, calendarSystem?: CalendarLocale): boolean;

/**
 * Check if a date is within the min/max range
 */
export declare function isDateInRange(day: Day, minDate?: Day, maxDate?: Day, calendarSystem?: CalendarLocale): boolean;

/**
 * Check if a date can be selected (valid, in range, not disabled)
 */
export declare function isDateSelectable(day: Day, options: {
    minDate?: Day;
    maxDate?: Day;
    disabledDates?: Day[];
    isDateDisabled?: (date: Day) => boolean;
    calendarSystem?: CalendarLocale;
}): boolean;

/**
 * Check if day1 is the same as day2 (ignores time)
 * @param day1 - First day to compare
 * @param day2 - Second day to compare
 * @param locale - Calendar locale of the days
 * @returns true if both days are the same
 */
export declare function isSameDay(day1: Day, day2: Day, calendarSystem?: CalendarLocale): boolean;

/**
 * Validate a Day object
 */
export declare function isValidDay(day: Day, calendarSystem: CalendarLocale): boolean;

/**
 * Convert Jalali Day to Gregorian Day
 * @throws {Error} If the input date is invalid or conversion fails
 */
export declare function jalaliToGregorian(day: Day): Day;

/**
 * Multiple dates representation
 */
export declare type Multi = Day[];

/**
 * Result with error information
 */
export declare interface NormalizationResult<T> {
    /** Normalized value (null if normalization failed) */
    value: T | null;
    /** Array of errors encountered during normalization */
    errors: CalendarError[];
}

/**
 * Normalize initial value based on calendar type (backward compatible)
 * @deprecated Use normalizeInitValueWithErrors for error information
 */
export declare function normalizeInitValue(value: unknown, calendarSystem: CalendarLocale, type: CalendarType): Day | Range_2 | Multi | Week | null;

/**
 * Parse and validate a date string in one step
 * Combines parseDateString and validateDay for convenience
 * Also validates that the year is within the calendar's year range
 * @param dateString - Date string to parse (e.g., "2024/12/25", "2024-12-25", "25/12/2024")
 * @param calendarSystem - Calendar system ('gregorian' or 'jalali')
 * @param dateFormat - Optional format pattern (e.g., "DD/MM/YYYY", "MM-DD-YYYY"). If provided, parses according to this format.
 * @returns ValidationResult with parsed and validated Day object, or error if parsing/validation fails
 */
export declare function parseAndValidateDate(dateString: string, calendarSystem: CalendarLocale, dateFormat?: string): ValidationResult<Day>;

/**
 * Parse a date string to Day object
 * Supports formats: YYYY/MM/DD, YYYY-MM-DD, etc.
 * If dateFormat is provided, parses according to the format pattern (e.g., "DD/MM/YYYY", "MM-DD-YYYY")
 * For Jalali locale, also supports Persian numerals
 */
export declare function parseDateString(dateString: string, calendarSystem: CalendarLocale, dateFormat?: string): Day | null;

export declare interface PresetRangesConfig {
    /** Show yesterday button */
    yesterday?: boolean;
    /** Show last 7 days button */
    last7days?: boolean;
    /** Show last 30 days button */
    last30days?: boolean;
    /** Show this month button */
    thisMonth?: boolean;
    /** Show last month button */
    lastMonth?: boolean;
    /** Custom preset ranges (completely custom ranges with custom labels) */
    custom?: CustomPresetRange[];
}

/**
 * Preset range button configuration
 * Each key can be:
 * - `true`: Show button with default label
 * - `string`: Show button with custom label
 * - `undefined` or not present: Don't show button
 * Note: 'today' is excluded as it has its own `todayBtn` prop
 */
export declare type PresetRangeType = 'yesterday' | 'last7days' | 'last30days' | 'thisMonth' | 'lastMonth';

/**
 * Date range representation
 */
declare interface Range_2 {
    /** Start date */
    from: Day;
    /** End date (can be null for incomplete ranges) */
    to: Day | null;
}
export { Range_2 as Range }

/**
 * Shared prop interfaces for calendar type selection logic
 * These define strict typings for onChange based on the 'type' prop
 */
/**
 * Range of JavaScript Date objects (always Gregorian)
 */
declare interface RangeDate {
    from: Date | null;
    to: Date | null;
}

/**
 * Shared properties for both DtPicker and DtCalendar
 */
declare interface SharedCalendarProps {
    /**
     * Initial value for the calendar
     * Accepts Day objects, Date objects, date strings, timestamps, or range/multi formats
     */
    initValue?: InitValueInput;
    /**
     * Enable time selection
     * @default false
     */
    withTime?: boolean;
    /**
     * Calendar system: 'gregorian' (Gregorian) or 'jalali' (Jalali)
     * Also accepts shorthand aliases: 'ge' for 'gregorian', 'ja' for 'jalali'
     * @default 'gregorian'
     */
    calendarSystem?: CalendarSystem;
    /**
     * Locale for internationalization
     * Controls language, text direction, and number system
     * Number system is automatically determined from locale:
     * - Persian numbers (fa, ar): use Persian numerals (۰-۹)
     * - Latin numbers (en, de, es, fr): use Latin numerals (0-9)
     * For jalali calendar, default locale is 'fa' (Persian numbers)
     * For gregorian calendar, default locale is 'en' (Latin numbers)
     * @default 'en'
     */
    locale?: CalendarUILocale;
    /**
     * Show weekend highlighting
     * @default false
     */
    showWeekend?: boolean;
    /**
     * First day of the week (0 = Sunday, 1 = Monday, 2 = Tuesday, 3 = Wednesday, 4 = Thursday, 5 = Friday, 6 = Saturday)
     * If not provided, defaults based on calendar system:
     * - Gregorian: Sunday (0)
     * - Jalali: Saturday (6)
     * @default undefined (auto-determined by calendar system)
     */
    weekStart?: 0 | 1 | 2 | 3 | 4 | 5 | 6;
    /**
     * Show today button
     * @default false
     */
    todayBtn?: boolean;
    /**
     * Preset range buttons configuration
     * Only works with type='range' or type='week'
     */
    presetRanges?: PresetRangesConfig;
    /**
     * Date constraints (maxDate, minDate, disabledDates)
     * Accepts Day objects, Date objects, date strings, timestamps, or timestamps
     */
    constraints?: CalendarConstraintsInput;
    /**
     * Custom CSS class for calendar modal
     */
    calenderModalClass?: string;
    /**
     * Customization options (classes, icons, labels)
     */
    customization?: CalendarCustomization;
    /**
     * Custom format string for displaying the date and time.
     *
     * The format string allows you to customize how the selected date is rendered in the input.
     * Any characters not matching the tokens below will be rendered as-is.
     *
     * **Important:** The format string must include at least one date token (YYYY, MM, or DD).
     * Time-only formats like "HH:mm" are not supported because the calendar always requires a date.
     *
     * **Available Tokens:**
     *
     * | Token | Description | Example |
     * |-------|-------------|---------|
     * | `YYYY` | 4-digit year | 2025 |
     * | `MM`   | 2-digit month | 01, 12 |
     * | `DD`   | 2-digit day | 05, 31 |
     * | `HH`   | 24-hour clock (00-23) | 14, 00 |
     * | `hh`   | 12-hour clock (01-12) | 02, 12 |
     * | `mm`   | Minutes | 05, 59 |
     * | `A`    | Uppercase AM/PM | AM, PM |
     * | `a`    | Lowercase am/pm | am, pm |
     *
     * @example
     * // Standard Date
     * dateFormat="DD/MM/YYYY" // "25/12/2025"
     *
     * @example
     * // Date with Time (24h) - requires withTime={true}
     * dateFormat="YYYY-MM-DD HH:mm" // "2025-12-25 14:30"
     *
     * @example
     * // Date with Time (12h) - requires withTime={true}
     * dateFormat="MM/DD/YYYY hh:mm A" // "12/25/2025 02:30 PM"
     *
     * @example
     * // withTime={true}
     * dateFormat="YYYY-MM-DD HH:mm" // "2025-12-09 14:30"
     *
     * @example
     * // withTime={false} (Time tokens are ignored)
     * dateFormat="YYYY-MM-DD HH:mm" // "2025-12-09"
     *
     * @example
     * // Custom Separators & Text
     * dateFormat="Year: YYYY, Month: MM" // "Year: 2025, Month: 12"
     *
     * @example
     * // ❌ Time-only formats are NOT supported (requires date tokens)
     * // dateFormat="HH:mm" // This will not work - date tokens are required
     *
     * @default undefined (Renders as "YYYY/MM/DD")
     */
    dateFormat?: string;
    /**
     * Number of months to display side by side
     * Particularly useful for range selection
     * @default 1
     */
    numberOfMonths?: 1 | 2 | 3;
    /**
     * Year list style
     * @default 'grid'
     */
    yearListStyle?: CalendarListStyle_2;
    /**
     * Enlarge selected day text in the calendar grid
     * @default true
     */
    enlargeSelectedDay?: boolean;
    /**
     * Enable dark theme
     * @default false
     */
    dark?: boolean;
    /**
     * Callback when date is selected
     */
    onDateSelect?: (day: Day) => void;
    /**
     * Callback when month is selected (in month view)
     */
    onMonthSelect?: (month: number) => void;
    /**
     * Callback when year is selected (in year view)
     */
    onYearSelect?: (year: number) => void;
    /**
     * Callback when view changes (calendar, months, years)
     */
    onViewChange?: (view: 'calendar' | 'months' | 'years') => void;
    /**
     * Callback when navigating months
     */
    onMonthNavigate?: (direction: 'prev' | 'next') => void;
    /**
     * Callback to navigate to today's date
     */
    onGoToToday?: () => void;
    /**
     * Callback function called when normalization or constraint errors occur
     * @param errors - Array of error objects describing what failed
     */
    onError?: (errors: CalendarError[]) => void;
}

/**
 * Get the start of day (sets time to 00:00)
 * @param day - Day object
 * @returns Day object with hour and minute set to 0
 */
export declare function startOfDay(day: Day): Day;

/**
 * Get the start of month (first day of the month)
 * @param day - Day object
 * @param _locale - Calendar locale (unused, kept for API consistency)
 * @returns Day object representing the first day of the month
 */
export declare function startOfMonth(day: Day, _calendarSystem?: CalendarLocale): Day;

/**
 * Get the start of year (first day of the year)
 * @param day - Day object
 * @returns Day object representing the first day of the year
 */
export declare function startOfYear(day: Day): Day;

/**
 * Subtract days from a date
 * @param day - Day to subtract days from
 * @param days - Number of days to subtract
 * @param locale - Calendar locale
 * @returns New Day object with days subtracted
 */
export declare function subtractDays(day: Day, days: number, calendarSystem?: CalendarLocale): Day;

/**
 * Subtract months from a date
 * @param day - Day to subtract months from
 * @param months - Number of months to subtract
 * @param locale - Calendar locale
 * @returns New Day object with months subtracted
 */
export declare function subtractMonths(day: Day, months: number, calendarSystem?: CalendarLocale): Day;

/**
 * Subtract years from a date
 * @param day - Day to subtract years from
 * @param years - Number of years to subtract
 * @param locale - Calendar locale
 * @returns New Day object with years subtracted
 */
export declare function subtractYears(day: Day, years: number, calendarSystem?: CalendarLocale): Day;

/**
 * Core types for the calendar library
 */
/**
 * Time representation
 */
export declare interface Time {
    /** Hour (0-23) */
    hour: number;
    /** Minute (0-59) */
    minute: number;
}

/**
 * Time range representation
 */
export declare interface TimeRange {
    /** Start time */
    from: Time;
    /** End time */
    to: Time;
}

/**
 * Convert a number to Persian numerals
 */
export declare function toPersianNumeral(num: number | string): string;

/**
 * Unified validation function using ValidationResult interface
 * Provides consistent error handling across utilities
 * @param day - Day object or unknown value to validate
 * @param locale - Calendar system (gregorian or jalali)
 * @returns ValidationResult with success status and data or error
 */
export declare function validateDay(day: unknown, locale: CalendarLocale): ValidationResult<Day>;

/**
 * Unified validation result interface for consistent error handling across utilities
 * @template T The type of the validated data
 */
declare interface ValidationResult<T> {
    /** Whether validation succeeded */
    success: boolean;
    /** Validated data (only present if success is true) */
    data?: T;
    /** Error information (only present if success is false) */
    error?: {
        /** Error code for programmatic handling */
        code: string;
        /** Human-readable error message */
        message: string;
        /** Additional error details */
        details?: unknown;
    };
}

/**
 * Week representation (start and end of week)
 */
export declare interface Week {
    /** Start date of the week */
    from: Day;
    /** End date of the week */
    to: Day;
}

export { }