import type { TimePeriod } from './type.js';
export declare const createChangeEvent: (value: string) => React.ChangeEvent<HTMLInputElement>;
export declare const ALLOWED_TIME_FORMATS: string[];
export declare const isFormatTimeAllowed: (format: string) => boolean;
export declare const TIME_PATTERNS: {
    /** Matches times in 24-hour format (HH:mm) like: 0:00, 09:30, 23:59 */
    readonly HOURS_24: RegExp;
    /** Matches times in 12-hour format (h:mm a) like: 1:00 AM, 12:59 PM */
    readonly HOURS_12: RegExp;
};
export declare const cleanTime: (time: string) => string;
/**
 * Convert a 24-hour format time to a 12-hour format time
 * @param input - The time in 24-hour format like 14:35
 * @returns The time in 12-hour format like 2:35 PM
 */
export declare const convert24hTo12h: (input: string) => string;
/**
 * Get the time from the input value in ISO 8601 format
 * @param value - The input value in ISO 8601 format like 2024-01-01T14:35:00.000Z
 * @returns The time in 24-hour format like 14:35
 */
export declare const getTime: (value: string) => string;
/**
 * Round the minute to the nearest interval
 * @param minute - The minute to round
 * @param interval - The interval to round to
 * @returns The rounded minute
 */
export declare const roundMinute: (minute: number, interval: number) => number;
/**
 * Transform the input time to the correct format
 * @param input - The input time
 * @param is12HourFormat - Whether the time is in 12-hour format
 * @param interval - The interval to round to
 * @returns The transformed time example string like 08:00 AM or 14:00
 */
export declare const transformInputTime: (input: string, is12HourFormat: boolean, interval?: number, periodToCheck?: TimePeriod) => {
    hour: string;
    minute: string;
    period?: TimePeriod;
};
/**
 * Validate the input time
 * @param input - The input time string. Valid formats include:
 *   - 12-hour format with AM/PM: "2:34 AM", "11:45 PM"
 *   - 24-hour format: "15:23", "08:00"
 *   - Short numeric format: "345" (transforms to "3:45"), "1430" (transforms to "14:30")
 * @returns Whether the input time is valid and can be transformed into a proper time format
 */
export declare const isValidTimeInput: (input: string) => boolean;
/**
 * Get the formatted offset of the time zone for display purposes
 * @param timeZone - The time zone (e.g., "America/New_York", "Europe/London")
 * @returns The offset prefixed with "UTC" (e.g., "UTC+05:30", "UTC-04:00")
 * @example
 * getOffsetToDisplay("America/New_York") // Returns "UTC-04:00" or "UTC-05:00"
 * getOffsetToDisplay("Asia/Kolkata")     // Returns "UTC+05:30"
 * getOffsetToDisplay()                   // Returns "UTC±00:00"
 */
export declare const getOffsetToDisplay: (timeZone?: string) => string;
/**
 * Gets a list of all available timezone options formatted for display
 * @param includeContinent - Optional boolean to control whether continent names are included in labels
 *                          true: "America/New York", false: "New York" (defaults to false)
 * @returns {Array<{value: string, label: string}>} An array of timezone options
 *
 * @example
 * // With includeContinent = true
 * getOptions(true)
 * // Returns:
 * [
 *   { value: "America/New_York", label: "(UTC-04:00) America/New York" },
 *   { value: "Europe/London", label: "(UTC+01:00) Europe/London" }
 * ]
 *
 * // With includeContinent = false
 * getOptions(false)
 * // Returns:
 * [
 *   { value: "America/New_York", label: "(UTC-04:00) New York" },
 *   { value: "Europe/London", label: "(UTC+01:00) London" }
 * ]
 *
 * @description
 * This function:
 * 1. Gets all supported timezone identifiers from the system
 * 2. Formats each timezone with its UTC offset
 * 3. Optionally includes or excludes the continent name in the label
 * 4. Returns an array of objects with value (timezone identifier) and label (formatted display string)
 */
export declare const getOptions: (includeContinent?: boolean) => {
    value: string;
    label: string;
}[];
/**
 * Split the datetime into hours, minutes, and last part (offset)
 * @param datetime - The datetime string
 * @returns An object containing hours, minutes, and last part (offset)
 */
export declare const splitDatetime: (datetime?: string) => {
    hours: string;
    minutes: string;
    timezoneOffset: string;
};
/**
 * Get the hours from the datetime
 * @param datetime - The datetime string
 * @returns The hours
 */
export declare const getHours: (datetime?: string) => string;
/**
 * Get the minutes from the datetime
 * @param datetime - The datetime string
 * @returns The minutes
 */
export declare const getMinutes: (datetime?: string) => string;
export declare const getInputValue: (datetime?: string) => string;
/**
 * Removes the date portion from an ISO 8601 datetime string, keeping only the time
 * @param datetime - The datetime string (e.g., "2024-03-21T14:30:00" or "14:30:00")
 * @returns The time portion of the string (e.g., "14:30:00")
 * @example
 * removeDate("2024-03-21T14:30:00") // Returns "14:30:00"
 * removeDate("14:30:00")            // Returns "14:30:00"
 */
export declare const removeDate: (datetime: string) => string;
/**
 * Get the timezone from the utcOffset
 * @param utcOffset - The utcOffset string
 * @returns The timezone
 */
export declare const getTimezone: (utcOffset: string) => string;
/**
 * Formats time components into an ISO-like datetime string with milliseconds and timezone offset
 * @param hours - The hours component (e.g., "14" or "02")
 * @param minutes - The minutes component, may include AM/PM (e.g., "30" or "30 PM")
 * @param timezoneOffset - The timezone offset (e.g., "+05:30" or "-04:00")
 * @returns Formatted datetime string (e.g., "14:30:00.000+05:30")
 * @example
 * formatInputsToValueFormat("14", "30", "+05:30")     // Returns "14:30:00.000+05:30"
 * formatInputsToValueFormat("02", "30 PM", "-04:00")  // Returns "02:30:00.000-04:00"
 */
export declare const formatInputsToValueFormat: (hours: string, minutes: string, timezoneOffset: string) => string;
/**
 * Convert a 12-hour format time to a 24-hour format time
 * @param input - The time in 12-hour format like 2:35 PM
 * @returns The time in 24-hour format like 14:35
 */
export declare const convert12hTo24h: (input: string) => string;
/**
 * Formats a time input string into a standardized display format
 * @param input - The input time string. Can be in various formats:
 *   - 24-hour format (e.g., "14:30", "08:00")
 *   - 12-hour format (e.g., "2:30 PM", "8:00 AM")
 *   - Short format (e.g., "1430", "0800")
 * @param is12HourFormat - If true, returns in 12-hour format with AM/PM
 *                        If false, returns in 24-hour format
 * @param timeIntervals - Optional interval in minutes to round the time
 *                       (e.g., 15 will round to the nearest quarter hour)
 * @param periodToCheck - Specific period (AM/PM) to force in the output,
 *                       avoiding automatic period conversion
 * @returns Formatted time string
 *   - 12-hour format: "hh:mm AM/PM" (e.g., "02:30 PM")
 *   - 24-hour format: "HH:mm" (e.g., "14:30")
 * @example
 * // With 12-hour format
 * formatInputToDisplayValid("14:30", true) // Returns "02:30 PM"
 * formatInputToDisplayValid("14:30", true, undefined, "AM") // Returns "02:30 AM"
 *
 * // With 24-hour format
 * formatInputToDisplayValid("2:30 PM", false) // Returns "14:30"
 */
export declare const formatInputToDisplayValid: (input: string, is12HourFormat: boolean, timeIntervals?: number, periodToCheck?: TimePeriod) => string;
/**
 * Extracts the hours and minutes from the input time string.
 *
 * This function takes a time string as input and returns an object containing the hours and minutes.
 * It supports various input formats, including 24-hour format (e.g., "14:30"), 12-hour format (e.g., "2:30 PM"), and short format (e.g., "1430").
 *
 * @param input - The input time string.
 * @returns An object with two properties: `hours` and `minutes`, representing the extracted hours and minutes from the input string.
 *
 * Examples:
 * - `getHoursAndMinutes("14:30")` returns `{ hours: "14", minutes: "30" }`.
 * - `getHoursAndMinutes("2:30 PM")` returns `{ hours: "2", minutes: "30", period: "PM" }`.
 * - `getHoursAndMinutes("1430")` returns `{ hours: "14", minutes: "30" }`.
 */
export declare const getHoursAndMinutes: (input: string) => {
    hours: string;
    minutes: string;
    period: string | undefined;
};
export declare const handleKeyDown: (e: React.KeyboardEvent<HTMLInputElement>) => void;
/**
 * Validates if a string has the hh:mm format and represents a valid time.
 * @param {string} timeString - The string to validate.
 * @returns {boolean} - Returns true if the string is valid, false otherwise.
 */
export declare const isValidTimeFromValue: (timeString: string) => boolean;
/**
 * Extracts hours and minutes from a time string value.
 * @param {string} timeString - The time string to process.
 * @returns {string} - Returns the time in hh:mm format if valid, empty string otherwise.
 */
export declare const getHoursAndMinutesFromValue: (timeString: string) => string;
//# sourceMappingURL=utils.d.ts.map