/** Payload when timepicker opens */
type OpenEventData = {
  hour: string;
  minutes: string;
  type?: string;
  degreesHours: number | null;
  degreesMinutes: number | null;
};

/** Payload when user cancels */
type CancelEventData = Record<string, never>;

/** Payload when user confirms time */
type ConfirmEventData = {
  hour?: string;
  minutes?: string;
  type?: string;
  /** When true, this confirm was triggered by commitOnScroll (auto-commit) */
  autoCommit?: boolean;
};

/** Payload when user clears time */
type ClearEventData = {
  previousValue: string | null;
};

/** Payload when modal shows */
type ShowEventData = Record<string, never>;

/** Payload when modal hides */
type HideEventData = Record<string, never>;

/** Payload for real-time updates */
type UpdateEventData = {
  hour?: string;
  minutes?: string;
  type?: string;
};

/** Payload when hour mode activated */
type SelectHourEventData = {
  hour: string;
};

/** Payload when minute mode activated */
type SelectMinuteEventData = {
  minutes: string;
};

/** Payload when AM selected */
type SelectAMEventData = Record<string, never>;

/** Payload when PM selected */
type SelectPMEventData = Record<string, never>;

/** Payload when switching view */
type SwitchViewEventData = Record<string, never>;

/** Payload when timezone is changed */
type TimezoneChangeEventData = {
  timezone: string;
};

type RangeConfirmEventData = {
  from: string;
  to: string;
  duration: number;
};

type RangeSwitchEventData = {
  active: 'from' | 'to';
  disabledTime?: {
    hours: string[];
    minutes: string[];
    fromType?: string;
    fromHour?: number;
  } | null;
};

type RangeValidationEventData = {
  valid: boolean;
  duration: number;
  minDuration?: number;
  maxDuration?: number;
};

type RangeMinuteCommitEventData = {
  hour: string;
  minutes: string;
  type?: string;
};

type RangeGetDisabledTimeEventData = Record<string, never>;

type RangeUpdateDisabledEventData = Record<string, never>;

/** Payload when wheel scroll starts on a column */
type WheelScrollStartEventData = {
  column: 'hours' | 'minutes' | 'ampm';
};

/** Payload when wheel scroll ends and snaps to a value */
type WheelScrollEndEventData = {
  column: 'hours' | 'minutes' | 'ampm';
  value: string;
  previousValue: string | null;
};

/** Payload when validation error occurs */
type ErrorEventData = {
  error: string;
  rejectedHour?: string;
  rejectedMinute?: string;
  inputHour?: string | number;
  inputMinute?: string | number;
  inputType?: string;
  inputLength?: string | number;
};

/** Callback function for timepicker events */
type TimepickerEventCallback<T = unknown> = (eventData: T) => void;

type OptionTypes = {
  /** Picker mode: clock, wheel, or compact-wheel @default "clock" */
  mode?: 'clock' | 'wheel' | 'compact-wheel';
  /** AM label text @default "AM" */
  amLabel?: string;
  /** Enable animations @default true */
  animation?: boolean;
  /**
   * @description Set default selector to append timepicker inside it. Timepicker default append to `body`
   * @default ""
   */
  appendModalSelector?: string;
  /** Enable backdrop @default true */
  backdrop?: boolean;
  /** Cancel button text @default "Cancel" */
  cancelLabel?: string;
  /** Edit hour/minutes in web mode @default false */
  editable?: boolean;
  /** Enable scroll when open @default false */
  enableScrollbar?: boolean;
  /** Icon to switch desktop/mobile @default false */
  enableSwitchIcon?: boolean;
  /** Mobile time label @default "Enter Time" */
  mobileTimeLabel?: string;
  /** Focus input after close @default false */
  focusInputAfterCloseModal?: boolean;
  /** Mobile hour label @default "Hour" */
  hourMobileLabel?: string;
  /** Desktop icon template */
  iconTemplate?: string;
  /** Mobile icon template */
  iconTemplateMobile?: string;
  /**
   * @description Set increment hour by `1`, `2`, `3` hour
   * @default 1
   */
  incrementHours?: number;
  /**
   * @description Set increment minutes by `1`, `5`, `10`, `15` minutes
   * @default 1
   */
  incrementMinutes?: number;
  /**
   * @description set custom text to minute label on mobile version
   * @default "Minute"
   */
  minuteMobileLabel?: string;
  /**
   * @description Turn on/off mobile version
   * @default false
   */
  mobile?: boolean;
  /**
   * @description Set custom text to ok label
   * @default "OK"
   */
  okLabel?: string;
  /** PM label @default "PM" */
  pmLabel?: string;
  /** Time label (desktop) @default "Select time" */
  timeLabel?: string;
  /** Auto-switch to minutes @default true */
  autoSwitchToMinutes?: boolean;
  /** Theme @default "basic" */
  theme?:
    | 'basic'
    | 'crane'
    | 'crane-straight'
    | 'm2'
    | 'm3-green'
    | 'dark'
    | 'glassmorphic'
    | 'pastel'
    | 'ai'
    | 'cyberpunk';
  /** Clock type: 12h or 24h @default "12h" */
  clockType?: '12h' | '24h';
  /** Disable specific times (hours/minutes/intervals) */
  disabledTime?: {
    minutes?: Array<string | number>;
    hours?: Array<string | number>;
    interval?: string | string[];
  };
  /** Current time config */
  /** Current time config */
  currentTime?:
    | {
        time?: Date;
        updateInput?: boolean;
        locales?: string | string[];
        preventClockType?: boolean;
      }
    | boolean;

  /** Focus trap on modal @default true */
  focusTrap?: boolean;
  /** Delay for clickable elements (ms) @default 300 */
  delayHandler?: number;
  /** Custom ID for instance */
  id?: string;
  /** Inline mode config */
  inline?: {
    enabled: boolean;
    containerId: string;
    /** @default false */
    showButtons?: boolean;
    /** @default true */
    autoUpdate?: boolean;
  };
  /** Additional CSS class */
  cssClass?: string;
  /** Callback when picker opens */
  onOpen?: TimepickerEventCallback<OpenEventData>;
  /** Callback when user cancels */
  onCancel?: TimepickerEventCallback<CancelEventData>;
  /** Callback when user confirms */
  onConfirm?: TimepickerEventCallback<ConfirmEventData>;
  /** Callback during interaction */
  onUpdate?: TimepickerEventCallback<UpdateEventData>;
  /** Callback when hour mode activated */
  onSelectHour?: TimepickerEventCallback<SelectHourEventData>;
  /** Callback when minute mode activated */
  onSelectMinute?: TimepickerEventCallback<SelectMinuteEventData>;
  /** Callback when AM selected */
  onSelectAM?: TimepickerEventCallback<SelectAMEventData>;
  /** Callback when PM selected */
  onSelectPM?: TimepickerEventCallback<SelectPMEventData>;
  /** Callback on validation error */
  onError?: TimepickerEventCallback<ErrorEventData>;
};

type EventHandler<T = unknown> = (data: T) => void;
interface TimepickerEventMap {
    open: OpenEventData;
    cancel: CancelEventData;
    confirm: ConfirmEventData;
    clear: ClearEventData;
    show: ShowEventData;
    hide: HideEventData;
    update: UpdateEventData;
    'select:hour': SelectHourEventData;
    'select:minute': SelectMinuteEventData;
    'select:am': SelectAMEventData;
    'select:pm': SelectPMEventData;
    'switch:view': SwitchViewEventData;
    'timezone:change': TimezoneChangeEventData;
    'range:confirm': RangeConfirmEventData;
    'range:switch': RangeSwitchEventData;
    'range:validation': RangeValidationEventData;
    'range:minute:commit': RangeMinuteCommitEventData;
    'range:get-disabled-time': RangeGetDisabledTimeEventData;
    'range:update-disabled': RangeUpdateDisabledEventData;
    'wheel:scroll:start': WheelScrollStartEventData;
    'wheel:scroll:end': WheelScrollEndEventData;
    'animation:clock': Record<string, never>;
    'animation:start': Record<string, never>;
    'animation:end': Record<string, never>;
    error: ErrorEventData;
    [key: string]: unknown;
}
declare class EventEmitter<EventMap extends Record<string, unknown> = TimepickerEventMap> {
    private events;
    on<K extends keyof EventMap>(event: K, handler: EventHandler<EventMap[K]>): void;
    once<K extends keyof EventMap>(event: K, handler: EventHandler<EventMap[K]>): void;
    off<K extends keyof EventMap>(event: K, handler?: EventHandler<EventMap[K]>): void;
    emit<K extends keyof EventMap>(event: K, data?: EventMap[K]): void;
    clear(): void;
    hasListeners<K extends keyof EventMap>(event: K): boolean;
}

/**
 * Grouped options structure for Timepicker UI v4.0.0
 *
 * BREAKING CHANGE from v3.x:
 * Options are now organized into logical groups for better clarity and maintainability.
 */



/**
 * Clock behavior configuration
 */
interface ClockOptions {
  /**
   * @description Set type of clock: `12h` or `24h`
   * @default "12h"
   */
  type?: '12h' | '24h';

  /**
   * @description Set increment for hours (1, 2, 3, etc.)
   * @default 1
   */
  incrementHours?: number;

  /**
   * @description Set increment for minutes (1, 5, 10, 15, etc.)
   * @default 1
   */
  incrementMinutes?: number;

  /**
   * @description Automatically switch to minutes after selecting hour
   * @default true
   */
  autoSwitchToMinutes?: boolean;

  /**
   * @description Enable smooth hour snapping with animation
   * In v5.0.0, this will become default and option will be renamed to discreteHourJump (inverted)
   * @default true
   */
  smoothHourSnap?: boolean;

  /**
   * @description Disable specific hours/minutes or time intervals
   * @example
   * disabledTime: {
   *   minutes: [1, 2, 4, 5, 55, 23, "22", "38"],
   *   hours: [1, "3", "5", 8],
   *   interval: "10:00 AM - 12:00 PM" | ["10:00 AM - 12:00 PM", "5:00 PM - 8:00 PM"]
   * }
   */
  disabledTime?: {
    minutes?: Array<string | number>;
    hours?: Array<string | number>;
    interval?: string | string[];
  };

  /**
   * @description Set current time to the input and timepicker
   * @example
   * currentTime: {
   *   time: new Date(),
   *   updateInput: true,
   *   locales: "en-US",
   *   preventClockType: false
   * }
   * @example currentTime: true
   */
  currentTime?:
    | {
        time?: Date;
        updateInput?: boolean;
        locales?: string | string[];
        preventClockType?: boolean;
      }
    | boolean;
}

/**
 * UI appearance and behavior configuration
 */
interface UIOptions {
  /**
   * @description Picker mode: analog clock face, scroll wheel spinner, or compact wheel (no header)
   * @default "clock"
   */
  mode?: 'clock' | 'wheel' | 'compact-wheel';

  /**
   * @description Theme for the timepicker
   * @default "basic"
   */
  theme?:
    | 'basic'
    | 'crane'
    | 'crane-straight'
    | 'm2'
    | 'm3-green'
    | 'dark'
    | 'glassmorphic'
    | 'pastel'
    | 'ai'
    | 'cyberpunk';

  /**
   * @description Enable/disable animations
   * @default true
   */
  animation?: boolean;

  /**
   * @description Show backdrop when timepicker is open
   * @default true
   */
  backdrop?: boolean;

  /**
   * @description Force mobile mode
   * @default false
   */
  mobile?: boolean;

  /**
   * @description Enable switch icon (mobile ↔ desktop)
   * @default false
   */
  enableSwitchIcon?: boolean;

  /**
   * @description Allow editing hour/minutes directly
   * @default false
   */
  editable?: boolean;

  /**
   * @description Enable scrollbar when timepicker is open
   * @default false
   */
  enableScrollbar?: boolean;

  /**
   * @description Additional CSS class for the wrapper
   * @example cssClass: "my-custom-timepicker"
   */
  cssClass?: string;

  /**
   * @description Show clear button to reset time selection
   * @default false
   */
  clearButton?: boolean;

  /**
   * @description Selector where to append modal (default: body)
   * @default ""
   */
  appendModalSelector?: string;

  /**
   * @description Custom keyboard icon template (desktop → mobile)
   * @default Material Icons template
   */
  iconTemplate?: string;

  /**
   * @description Custom schedule icon template (mobile → desktop)
   * @default Material Icons template
   */
  iconTemplateMobile?: string;

  /**
   * @description Inline mode configuration
   * @example
   * inline: {
   *   enabled: true,
   *   containerId: "timepicker-container",
   *   showButtons: false,
   *   autoUpdate: true
   * }
   */
  inline?: {
    enabled: boolean;
    containerId: string;
    showButtons?: boolean;
    autoUpdate?: boolean;
  };
}

/**
 * Text labels configuration
 */
interface LabelsOptions {
  /**
   * @description "AM" label text
   * @default "AM"
   */
  am?: string;

  /**
   * @description "PM" label text
   * @default "PM"
   */
  pm?: string;

  /**
   * @description "OK" button text
   * @default "OK"
   */
  ok?: string;

  /**
   * @description "Cancel" button text
   * @default "Cancel"
   */
  cancel?: string;

  /**
   * @description Time label on desktop
   * @default "Select time"
   */
  time?: string;

  /**
   * @description Time label on mobile
   * @default "Enter Time"
   */
  mobileTime?: string;

  /**
   * @description Hour label on mobile
   * @default "Hour"
   */
  mobileHour?: string;

  /**
   * @description Minute label on mobile
   * @default "Minute"
   */
  mobileMinute?: string;

  /**
   * @description "Clear" button text
   * @default "Clear"
   */
  clear?: string;
}

/**
 * Behavior configuration
 */
interface BehaviorOptions {
  /**
   * @description Focus input after closing modal
   * @default false
   */
  focusInputAfterClose?: boolean;

  /**
   * @description Enable focus trap in modal
   * @default true
   */
  focusTrap?: boolean;

  /**
   * @description Delay for clickable elements (ms)
   * @default 300
   */
  delayHandler?: number;

  /**
   * @description Custom ID for the timepicker instance
   * @example id: "my-timepicker-1"
   */
  id?: string;
}

/**
 * Timezone configuration (opt-in, UI-only)
 * @description Optional timezone selector for B2B/global use cases.
 * This is a presentation layer only - no automatic time conversions.
 */
interface TimezoneOptions {
  /**
   * @description Enable timezone selector UI
   * @default false
   */
  enabled?: boolean;

  /**
   * @description Default timezone ID (e.g., 'America/New_York')
   * Uses browser's local timezone if not specified.
   */
  default?: string;

  /**
   * @description Whitelist of allowed timezone IDs.
   * If not provided, uses a curated list of common timezones.
   * @example whitelist: ['UTC', 'America/New_York', 'Europe/London']
   */
  whitelist?: readonly string[];

  /**
   * @description Label for timezone selector
   * @default "Timezone"
   */
  label?: string;
}

/**
 * Wheel / compact-wheel mode configuration
 * @example
 * wheel: {
 *   placement: 'auto',
 *   hideFooter: true,
 *   commitOnScroll: true
 * }
 */
interface WheelOptions {
  /**
   * @description Popover placement relative to input in compact-wheel mode.
   * 'auto' opens below if space allows, otherwise above.
   * Defaults to 'auto' in compact-wheel mode.
   * Can be overridden to 'top' or 'bottom' for fixed positioning.
   * @default 'auto' (compact-wheel) | undefined (wheel)
   */
  placement?: 'auto' | 'top' | 'bottom';

  /**
   * @description When true, the footer (OK/Cancel/Clear buttons + switch icon)
   * is not rendered in the DOM at all. Only works in compact-wheel mode.
   * Useful when commitOnScroll is enabled and buttons are unnecessary.
   * @default false
   */
  hideFooter?: boolean;

  /**
   * @description When enabled, the timepicker automatically commits the selected time
   * at the end of wheel scrolling, updating the input value and emitting a change event
   * without requiring the user to press OK. Only applies to wheel and compact-wheel modes.
   * @default false
   */
  commitOnScroll?: boolean;

  /**
   * @description When true, disabled hours/minutes are completely removed from the wheel list
   * instead of being dimmed. Only applies to wheel and compact-wheel modes.
   * Useful when many values are disabled (e.g., business hours only).
   * @default false
   */
  hideDisabled?: boolean;

  /**
   * @description When true, clicking outside the picker area does not close it.
   * Only applies to wheel and compact-wheel modes (popover and modal).
   * The user must explicitly press OK or Cancel to close the picker.
   * @default false
   */
  ignoreOutsideClick?: boolean;
}

/**
 * Range mode configuration (opt-in)
 */
interface RangeOptions {
  /**
   * @description Enable range mode (from-to selection)
   * @default false
   */
  enabled?: boolean;

  /**
   * @description Minimum duration in minutes
   */
  minDuration?: number;

  /**
   * @description Maximum duration in minutes
   */
  maxDuration?: number;

  /**
   * @description Label for "from" segment
   * @default "From"
   */
  fromLabel?: string;

  /**
   * @description Label for "to" segment
   * @default "To"
   */
  toLabel?: string;
}

/**
 * Event callbacks configuration
 */
interface CallbacksOptions {
  /**
   * @description Triggered when timepicker opens
   */
  onOpen?: TimepickerEventCallback<OpenEventData>;

  /**
   * @description Triggered when user cancels
   */
  onCancel?: TimepickerEventCallback<CancelEventData>;

  /**
   * @description Triggered when user confirms time
   */
  onConfirm?: TimepickerEventCallback<ConfirmEventData>;

  /**
   * @description Triggered during interaction (real-time)
   */
  onUpdate?: TimepickerEventCallback<UpdateEventData>;

  /**
   * @description Triggered when hour mode is selected
   */
  onSelectHour?: TimepickerEventCallback<SelectHourEventData>;

  /**
   * @description Triggered when minute mode is selected
   */
  onSelectMinute?: TimepickerEventCallback<SelectMinuteEventData>;

  /**
   * @description Triggered when AM is selected
   */
  onSelectAM?: TimepickerEventCallback<SelectAMEventData>;

  /**
   * @description Triggered when PM is selected
   */
  onSelectPM?: TimepickerEventCallback<SelectPMEventData>;

  /**
   * @description Triggered on invalid time format
   */
  onError?: TimepickerEventCallback<ErrorEventData>;

  /**
   * @description Triggered when timezone is changed (opt-in feature)
   */
  onTimezoneChange?: TimepickerEventCallback<TimezoneChangeEventData>;

  /**
   * @description Triggered when range is confirmed (range mode only)
   */
  onRangeConfirm?: TimepickerEventCallback<RangeConfirmEventData>;

  /**
   * @description Triggered when switching between from/to (range mode only)
   */
  onRangeSwitch?: TimepickerEventCallback<RangeSwitchEventData>;

  /**
   * @description Triggered on range validation (range mode only)
   */
  onRangeValidation?: TimepickerEventCallback<RangeValidationEventData>;

  /**
   * @description Triggered when clear button is clicked
   */
  onClear?: TimepickerEventCallback<ClearEventData>;
}

/**
 * Clear button behavior configuration
 */
interface ClearBehaviorOptions {
  /**
   * @description Whether clicking clear also empties the input field value
   * @default true
   */
  clearInput?: boolean;
}

/**
 * Main options type with grouped structure (v4.0.0)
 */
interface TimepickerOptions {
  clock?: ClockOptions;
  ui?: UIOptions;
  labels?: LabelsOptions;
  behavior?: BehaviorOptions;
  callbacks?: CallbacksOptions;
  timezone?: TimezoneOptions;
  range?: RangeOptions;
  wheel?: WheelOptions;
  clearBehavior?: ClearBehaviorOptions;
}

type Callback = () => void;
declare class TimepickerUI {
    private readonly core;
    private readonly managers;
    private readonly lifecycle;
    private readonly emitter;
    constructor(selectorOrElement: string | HTMLElement, options?: TimepickerOptions);
    private setupInternalEventListeners;
    /**
     * Create the timepicker instance and render it in the DOM. If inline mode is enabled, the timepicker will be mounted immediately.
     */
    create(): void;
    /**
     * Open the timepicker, optionally executing a callback after opening.
     * @param callback - Optional callback to be executed after opening.
     */
    open(callback?: Callback): void;
    /**
     * Close the timepicker, optionally updating the input value before closing.
     * @param update - If true, the input value will be updated with the current selection before closing.
     * @param callback - Optional callback to be executed after closing.
     */
    close(update?: boolean, callback?: Callback): void;
    /**
     * Destroy the timepicker instance, removing all event listeners and DOM elements.
     * @param options - Optional parameters to control destruction behavior.
     *                  If a callback function is provided directly, it will be treated as the callback parameter.
     *                  If an options object is provided, it can include:
     *                  - keepInputValue: A boolean indicating whether to keep the input value after destruction (default: false).
     *                  - callback: An optional callback function to be executed after destruction.
     */
    destroy(options?: {
        keepInputValue?: boolean;
        callback?: Callback;
    } | Callback): void;
    /**
     * Update the timepicker instance with new options.
     * @param value - The new options and optional create flag.
     * @param callback - Optional callback to be executed after update.
     */
    update(value: {
        options: TimepickerOptions;
        create?: boolean;
    }, callback?: Callback): void;
    /**
     * Get the current selected time value from the timepicker.
     * @returns An object containing the current hour, minutes, type (if applicable), formatted time string, and degrees for hours and minutes.
     */
    getValue(): {
        hour: string;
        minutes: string;
        type?: string;
        time: string;
        degreesHours: number | null;
        degreesMinutes: number | null;
    };
    /**
     * Set the timepicker value programmatically.
     * @param time - The time string to set, in the format "HH:MM" for 24h or "HH:MM AM/PM" for 12h.
     * @param updateInput - If true, the input field will be updated with the new time value. Default is true.
     */
    setValue(time: string, updateInput?: boolean): void;
    private parseTimeString;
    private applyParsedTime;
    private syncPeriodIndicator;
    private syncClockVisual;
    /**
     * Get the root element of the timepicker instance.
     * @returns - The HTMLElement that serves as the root of the timepicker instance.
     */
    getElement(): HTMLElement;
    /**
     * Get the unique instance ID of the timepicker.
     * @return - The unique instance ID as a string.
     */
    get instanceId(): string;
    /**
     * Get the current options of the timepicker instance.
     * @returns - The current options of the timepicker instance.
     */
    get options(): Required<TimepickerOptions>;
    /**
     * Check if the timepicker instance is currently initialized.
     * @returns - True if the instance is initialized, false otherwise.
     */
    get isInitialized(): boolean;
    /**
     * Check if the timepicker instance has been destroyed.
     * @returns - True if the instance is destroyed, false otherwise.
     */
    get isDestroyed(): boolean;
    /**
     * Get the hour input element of the timepicker instance.
     * @returns - The HTMLInputElement for the hour input, or null if not found.
     */
    get hour(): HTMLInputElement | null;
    /**
     * Get the minutes input element of the timepicker instance.
     * @returns - The HTMLInputElement for the minutes input, or null if not found.
     */
    get minutes(): HTMLInputElement | null;
    /**
     * Get the OK button element of the timepicker instance.
     * @returns - The HTMLButtonElement for the OK button, or null if not found.
     */
    get okButton(): HTMLButtonElement | null;
    /**
     * Get the Cancel button element of the timepicker instance.
     * @returns - The HTMLButtonElement for the Cancel button, or null if not found.
     */
    get cancelButton(): HTMLButtonElement | null;
    /**
     * Get the clock hand element of the timepicker instance.
     * @returns - The HTMLDivElement for the clock hand, or null if not found.
     */
    get clockHand(): HTMLDivElement | null;
    /**
     * Subscribe to a timepicker event with a handler function.
     * @param event - The name of the event to subscribe to.
     * @param handler - The function to handle the event.
     * @returns - void
     */
    on<K extends keyof TimepickerEventMap>(event: K, handler: (data: TimepickerEventMap[K]) => void): void;
    /**
     * Subscribe to a timepicker event with a handler function that will be called only once.
     * @param event - The name of the event to subscribe to.
     * @param handler - The function to handle the event.
     * @returns - void
     */
    once<K extends keyof TimepickerEventMap>(event: K, handler: (data: TimepickerEventMap[K]) => void): void;
    /**
     * Unsubscribe from a timepicker event. If a handler is provided, only that handler will be removed. If no handler is provided, all handlers for the event will be removed.
     * @param event - The name of the event to unsubscribe from.
     * @param handler - The function to handle the event.
     * @returns - void
     */
    off<K extends keyof TimepickerEventMap>(event: K, handler?: (data: TimepickerEventMap[K]) => void): void;
    private resolveInputElement;
    private createWrapperElement;
    /**
     * Get a timepicker instance by its unique ID.
     * @param id - The unique instance ID of the timepicker to retrieve.
     * @returns - The timepicker instance if found, otherwise undefined.
     */
    static getById(id: string): TimepickerUI | undefined;
    /**
     * Get all existing timepicker instances.
     * @returns - An array of all timepicker instances.
     */
    static getAllInstances(): TimepickerUI[];
    /**
     *  Check if a timepicker instance can be created for the given selector or element. This method verifies that the environment is a browser, the element exists in the DOM, and is either an input or contains an input.
     * @param selectorOrElement - A CSS selector string or an HTMLElement to check for timepicker availability.
     * @returns - True if a timepicker instance can be created for the given selector or element, false otherwise.
     */
    static isAvailable(selectorOrElement: string | HTMLElement): boolean;
    /**
     * Destroy all existing timepicker instances. This method iterates through all registered instances, calls their destroy method, and clears the instance registry.
     */
    static destroyAll(): void;
}

interface CoreStateData {
    readonly degreesHours: number | null;
    readonly degreesMinutes: number | null;
    readonly options: Required<TimepickerOptions>;
    readonly element: HTMLElement;
    readonly instanceId: string;
    readonly isMobileView: boolean;
    readonly isTouchMouseMove: boolean;
    readonly disabledTime: {
        value?: {
            isInterval?: boolean;
            intervals?: string[];
            clockType?: string;
            hours?: string[];
            minutes?: string[];
        };
    } | null;
    readonly cloned: Node | null;
    readonly isModalRemove: boolean;
    readonly isOpen: boolean;
    readonly isInitialized: boolean;
    readonly customId?: string;
    readonly eventHandlersRegistered: boolean;
    readonly isDestroyed: boolean;
}
declare class CoreState {
    private state;
    constructor(element: HTMLElement, options: Required<TimepickerOptions>, instanceId: string, customId?: string);
    get degreesHours(): number | null;
    get degreesMinutes(): number | null;
    get options(): Required<TimepickerOptions>;
    get element(): HTMLElement;
    get instanceId(): string;
    get isMobileView(): boolean;
    get isTouchMouseMove(): boolean;
    get disabledTime(): CoreStateData['disabledTime'];
    get cloned(): Node | null;
    get isModalRemove(): boolean;
    get isOpen(): boolean;
    get isInitialized(): boolean;
    get customId(): string | undefined;
    get eventHandlersRegistered(): boolean;
    get isDestroyed(): boolean;
    setDegreesHours(value: number | null): void;
    setDegreesMinutes(value: number | null): void;
    setOptions(options: Required<TimepickerOptions>): void;
    setIsMobileView(value: boolean): void;
    setIsTouchMouseMove(value: boolean): void;
    setDisabledTime(value: CoreStateData['disabledTime']): void;
    setCloned(value: Node | null): void;
    setIsModalRemove(value: boolean): void;
    setIsOpen(value: boolean): void;
    setIsInitialized(value: boolean): void;
    setEventHandlersRegistered(value: boolean): void;
    setIsDestroyed(value: boolean): void;
    updateOptions(updates: Partial<TimepickerOptions>): void;
    reset(): void;
    getModalElement(): HTMLDivElement | null;
    getInput(): HTMLInputElement | null;
    getClockFace(): HTMLDivElement | null;
    getClockHand(): HTMLDivElement | null;
    getCircle(): HTMLDivElement | null;
    getTipsWrapper(): HTMLDivElement | null;
    getTipsWrapperFor24h(): HTMLDivElement | null;
    getMinutes(): HTMLInputElement | null;
    getHour(): HTMLInputElement | null;
    getAM(): HTMLDivElement | null;
    getPM(): HTMLDivElement | null;
    getHourText(): HTMLDivElement | null;
    getMinutesText(): HTMLDivElement | null;
    getHeader(): HTMLDivElement | null;
    getInputWrappers(): NodeListOf<Element> | null;
    getDots(): HTMLDivElement | null;
    getMinutesTips(): HTMLDivElement | null;
    getHourTips(): HTMLDivElement | null;
    getAllValueTips(): Array<HTMLDivElement>;
    getOpenElementData(): string[] | null;
    getOpenElement(): NodeListOf<Element> | readonly [HTMLInputElement];
    getCancelButton(): HTMLButtonElement | null;
    getOkButton(): HTMLButtonElement | null;
    getActiveTypeMode(): HTMLButtonElement | null;
    getKeyboardClockIcon(): HTMLButtonElement | null;
    getFooter(): HTMLDivElement | null;
    getWrapper(): HTMLDivElement | null;
}

interface PluginManager {
    init(): void;
    destroy(): void;
}
type PluginFactory = (core: CoreState, emitter: EventEmitter<TimepickerEventMap>) => PluginManager;
type TemplateProvider = (options: Required<TimepickerOptions>, instanceId: string) => string;
type ClearHandler = (core: CoreState, emitter: EventEmitter<TimepickerEventMap>) => void;
interface Plugin {
    name: string;
    factory: PluginFactory;
    optionsExtender?: (options: Record<string, unknown>) => void;
    templateProvider?: TemplateProvider;
    clearHandler?: ClearHandler;
}
declare class PluginRegistryClass {
    private plugins;
    register(plugin: Plugin): void;
    getAll(): Plugin[];
    has(name: string): boolean;
    get(name: string): Plugin | undefined;
    getTemplateProvider(name: string): TemplateProvider | undefined;
    getClearHandler(name: string): ClearHandler | undefined;
}
declare const PluginRegistry: PluginRegistryClass;

export { CoreState, EventEmitter, PluginRegistry, TimepickerUI, TimepickerUI as default };
export type { BehaviorOptions, CallbacksOptions, CancelEventData, ClearBehaviorOptions, ClearEventData, ClearHandler, ClockOptions, ConfirmEventData, ErrorEventData, HideEventData, LabelsOptions, OpenEventData, OptionTypes, Plugin, PluginFactory, PluginManager, RangeConfirmEventData, RangeOptions, RangeSwitchEventData, RangeValidationEventData, SelectAMEventData, SelectHourEventData, SelectMinuteEventData, SelectPMEventData, ShowEventData, SwitchViewEventData, TemplateProvider, TimepickerEventMap, TimepickerOptions, TimezoneChangeEventData, TimezoneOptions, UIOptions, UpdateEventData, WheelOptions, WheelScrollEndEventData, WheelScrollStartEventData };