/**
 * @license
 *-------------------------------------------------------------------------------------------
 * Copyright © 2025 Progress Software Corporation. All rights reserved.
 * Licensed under commercial license. See LICENSE.md in the package root for more information
 *-------------------------------------------------------------------------------------------
 */
import { BaseEvent as BaseEvent_2 } from '@progress/kendo-react-common';
import { CheckboxHandle } from '@progress/kendo-react-inputs';
import { CheckboxProps } from '@progress/kendo-react-inputs';
import { ComboBoxProps } from '@progress/kendo-react-dropdowns';
import { DateFormatOptions } from '@progress/kendo-react-intl';
import { DatePickerCloseEvent } from '@progress/kendo-react-dateinputs';
import { DatePickerOpenEvent } from '@progress/kendo-react-dateinputs';
import { DatePickerProps } from '@progress/kendo-react-dateinputs';
import { DateRange as DateRange_2 } from '../..';
import { DateTimePickerCloseEvent } from '@progress/kendo-react-dateinputs';
import { DateTimePickerOpenEvent } from '@progress/kendo-react-dateinputs';
import { DateTimePickerProps } from '@progress/kendo-react-dateinputs';
import { Day } from '@progress/kendo-date-math';
import { DialogHandle } from '@progress/kendo-react-dialogs';
import { DialogProps } from '@progress/kendo-react-dialogs';
import { DropDownListProps } from '@progress/kendo-react-dropdowns';
import { ErrorProps } from '@progress/kendo-react-labels';
import { FieldProps } from '@progress/kendo-react-form';
import { FieldRenderProps } from '@progress/kendo-react-form';
import { FormElementHandle } from '@progress/kendo-react-form';
import { FormElementProps } from '@progress/kendo-react-form';
import { FormProps } from '@progress/kendo-react-form';
import { FormRenderProps } from '@progress/kendo-react-form';
import { InferProps } from 'prop-types';
import { InputHandle } from '@progress/kendo-react-inputs';
import { InputProps } from '@progress/kendo-react-inputs';
import { IntlService } from '@progress/kendo-react-intl';
import { JSX } from 'react/jsx-runtime';
import { LabelProps } from '@progress/kendo-react-labels';
import { LocalizationService } from '@progress/kendo-react-intl';
import { MultiSelectProps } from '@progress/kendo-react-dropdowns';
import * as React_2 from 'react';
import { ReactNodeLike } from 'prop-types';
import { RecurrenceEditorProps } from '../recurrence/RecurrenceEditor';
import { Requireable } from 'prop-types';
import { ResourceEditorProps } from './ResourceEditor';
import { SchedulerFooterHandle as SchedulerFooterHandle_2 } from './components/footer/SchedulerFooter';
import { SchedulerFormHandle as SchedulerFormHandle_2 } from '../components/SchedulerForm';
import { SchedulerHeaderHandle as SchedulerHeaderHandle_2 } from './components/header/SchedulerHeader';
import { SchedulerItemHandle as SchedulerItemHandle_2 } from '../../items/SchedulerItem';
import { SchedulerNavigationHandle } from './components/header/navigation/SchedulerNavigation';
import { SchedulerNavigationProps } from './components/header/navigation/SchedulerNavigation';
import { SchedulerOccurrenceDialogHandle as SchedulerOccurrenceDialogHandle_2 } from '../components/SchedulerOccurrenceDialog';
import { SchedulerRemoveDialogHandle as SchedulerRemoveDialogHandle_2 } from '../components/SchedulerRemoveDialog';
import { SchedulerTaskHandle as SchedulerTaskHandle_2 } from './SchedulerTask';
import { SchedulerViewDateRangeArgs as SchedulerViewDateRangeArgs_2 } from '../..';
import { SchedulerViewItemHandle as SchedulerViewItemHandle_2 } from '../../items/SchedulerViewItem';
import { SchedulerViewItemHandle as SchedulerViewItemHandle_3 } from './SchedulerViewItem';
import { SchedulerViewSelectorHandle } from './components/header/view-selector/SchedulerViewSelector';
import { SchedulerViewSelectorProps } from './components/header/view-selector/SchedulerViewSelector';
import { SchedulerViewSlotHandle as SchedulerViewSlotHandle_2 } from './SchedulerViewSlot';
import { SchedulerViewTaskHandle as SchedulerViewTaskHandle_2 } from './SchedulerViewTask';
import { TextAreaHandle } from '@progress/kendo-react-inputs';
import { TextAreaProps } from '@progress/kendo-react-inputs';
import { ToolbarProps } from '@progress/kendo-react-buttons';
import { ZonedDate } from '@progress/kendo-date-math';

/**
 * Represents the KendoReact [AgendaView]({% slug agenda_view_scheduler %}) Component.
 */
export declare const AgendaView: React_2.FunctionComponent<AgendaViewProps>;

/** @hidden */
export declare const agendaViewDefaultProps: {
    name: string;
    title: (localization: LocalizationService) => string;
    dateRange: ({ intl, date, numberOfDays, timezone }: SchedulerViewDateRangeArgs) => DateRange;
    selectedDateFormat: string;
    selectedShortDateFormat: string;
    slotDuration: number;
    slotDivision: number;
    numberOfDays: number;
};

/**
 * Represents the properties of the KendoReact [AgendaView]({% slug api_scheduler_agendaview %}) Component.
 */
export declare interface AgendaViewProps extends SchedulerViewProps {
    /**
     * Specifies the step by which the currently rendered days will be changed, when using the back and forwards buttons in the toolbar navigation.
     */
    step?: number;
    /**
     * Specifies the number of days that the view will render.
     * Defaults to `7`.
     */
    numberOfDays?: number;
    /**
     * The long-date format for displaying the
     * selected date in the Scheduler toolbar.
     * Defaults to `{0:D} - {1:D}`
     * ([more information](https://www.github.com/telerik/kendo-intl/blob/develop/docs/date-formatting/index.md))
     */
    selectedDateFormat?: string;
    /**
     * The short-date format for displaying the
     * selected date in the Scheduler toolbar.
     * Defaults to `{0:d} - {1-d}`
     * ([more information](https://www.github.com/telerik/kendo-intl/blob/develop/docs/date-formatting/index.md))
     */
    selectedShortDateFormat?: string;
    /**
     * Sets a custom `className` to the wrapping element of the `AgendaView`.
     */
    className?: string;
    /**
     * Sets a custom `id` to the wrapping element of the `AgendaView`.
     */
    id?: string;
    /**
     * Sets a custom `style` property to the wrapping element of the `AgendaView`.
     */
    style?: React_2.CSSProperties;
    /**
     * Overrides the general `editable` prop of the Scheduler for the specified view only.
     */
    editable?: EditableProp;
    /**
     * Overrides the `task` prop of the Scheduler for the specified view only.
     */
    task?: React_2.ComponentType<SchedulerTaskProps>;
    /**
     * Overrides the `viewTask` prop of the Scheduler for the specified view only.
     */
    viewTask?: React_2.ComponentType<SchedulerTaskProps>;
    /**
     * Overrides the `editTask` prop of the Scheduler for the specified view only.
     */
    editTask?: React_2.ComponentType<SchedulerTaskProps>;
    /**
     * Overrides the `slot` prop of the Scheduler for the specified view only.
     */
    slot?: React_2.ComponentType<SchedulerSlotProps>;
    /**
     * Overrides the `viewSlot` prop of the Scheduler for the specified view only.
     */
    viewSlot?: React_2.ComponentType<SchedulerViewSlotProps>;
    /**
     * Overrides the `editSlot` prop of the Scheduler for the specified view only.
     */
    editSlot?: React_2.ComponentType<SchedulerEditSlotProps>;
}

/**
 * @hidden
 **/
export declare interface BaseEvent<T> {
    target: T;
}

/**
 * Specifies the available [DataAction]({% slug api_scheduler_data_action %}) types.
 */
export declare enum DATA_ACTION {
    create = 0,
    update = 1,
    remove = 2
}

/**
 * Specifies the action which can be dispatched through the [SchedulerDataContext]({% slug api_scheduler_schedulerdatacontext %}).
 *
 * For more information refer to the [Scheduler Context]({% slug context_scheduler %}) article.
 */
export declare interface DataAction {
    /**
     * The `type` of the action. The available types are:
     * - `create`
     * - `update`
     * - `remove`
     */
    type: DATA_ACTION;
    /**
     * Specifies if the action should be applied to the whole series of a recurring item. If the item is not recurring, set `series` to `false`.
     */
    series: boolean;
    /**
     * Specifies the `dataItem` being edited.
     */
    dataItem: DataItem;
}

/**
 * Represents the items which the [`data`]({% slug api_scheduler_schedulerprops %}#toc-data) property accepts.
 * The `data` has no strict type. However, to visualize it correctly,
 * use it in combination with the [`modelFields`]({% slug api_scheduler_schedulerprops %}#toc-modelfields) property.
 * For more information, refer to the article on
 * [binding the Scheduler to data]({% slug data_binding_scheduler %}).
 */
export declare type DataItem = any;

/**
 * Represents the DateHeaderCell component.
 */
export declare const DateHeaderCell: React_2.ForwardRefExoticComponent<DateHeaderCellProps & React_2.RefAttributes<DateHeaderCellHandle | null>>;

export declare const dateHeaderCellDefaultProps: {
    as: React_2.ForwardRefExoticComponent<DateHeaderCellProps & React_2.RefAttributes<unknown>>;
    format: string;
};

/**
 * Represents the target(element and props).
 */
export declare interface DateHeaderCellHandle {
    /**
     * The current element or `null` if there is no one.
     */
    element: HTMLElement | null;
    /**
     * The props values of the DateHeaderCell.
     */
    props: DateHeaderCellProps;
}

/**
 * Represents the properties of [DateHeaderCell]({% slug api_scheduler_dateheadercell %}) component.
 */
export declare interface DateHeaderCellProps extends React_2.HTMLAttributes<HTMLDivElement> {
    /** @hidden */
    as?: React_2.ComponentType<DateHeaderCellProps>;
    /**
     * Represents the date format.
     */
    format?: string | DateFormatOptions;
    /**
     * Represents the current date.
     */
    date: Date;
    /**
     * Represents the start date.
     */
    start: Date;
    /**
     * Represents the end date.
     */
    end: Date;
}

/** @hidden */
export declare interface DateRange {
    start: Date;
    end: Date;
    zonedStart: ZonedDate;
    zonedEnd: ZonedDate;
}

/**
 * Represents the KendoReact [DayView]({% slug day_view_scheduler %}) Component.
 */
export declare const DayView: React_2.FunctionComponent<DayViewProps>;

/** @hidden */
export declare const dayViewDefaultProps: {
    name: string;
    title: (localization: any) => any;
    numberOfDays: number;
    slotDuration: number;
    slotDivisions: number;
    selectedDateFormat: string;
    selectedShortDateFormat: string;
    currentTimeMarker: boolean;
    dateRange: ({ date, numberOfDays, timezone }: SchedulerViewDateRangeArgs_2) => DateRange_2;
    startTime: string;
    endTime: string;
    isWorkDayStart: string;
    isWorkDayEnd: string;
    workWeekStart: Day;
    workWeekEnd: Day;
    showCurrentTime: boolean;
    defaultShowWorkHours: boolean;
};

/**
 * Represents the properties of the [DayView]({% slug api_scheduler_dayviewprops %}) Component.
 */
export declare interface DayViewProps extends MultiDayViewProps {
}

/**
 * Represents the available `action` types for the `SchedulerItemDragItemAction` objects.
 *
 * The available types are:
 * - `DRAG_ITEM_SET'`
 * - `DRAG_ITEM_START'`
 * - `DRAG_ITEM_DRAG'`
 * - `DRAG_ITEM_COMPLETE'`
 * - `DRAG_ITEM_COMPLETE_OCCURRENCE'`
 * - `DRAG_ITEM_COMPLETE_SERIES'`
 * - `DRAG_ITEM_RESET'`
 * - `DRAG_ITEM_DRAG_SELECTED`
 */
export declare enum DRAG_ITEM_ACTION {
    set = "DRAG_ITEM_SET",
    start = "DRAG_ITEM_START",
    drag = "DRAG_ITEM_DRAG",
    complete = "DRAG_ITEM_COMPLETE",
    completeOccurrence = "DRAG_ITEM_COMPLETE_OCCURRENCE",
    completeSeries = "DRAG_ITEM_COMPLETE_SERIES",
    reset = "DRAG_ITEM_RESET",
    dragSelected = "DRAG_ITEM_DRAG_SELECTED"
}

/**
 * The editable settings of the Scheduler.
 */
export declare interface EditableProp {
    /**
     * Specifies if the events can be removed by using a **Remove** icon.
     */
    remove: boolean;
    /**
     * Specifies if the events can be dragged.
     */
    drag: boolean;
    /**
     * Specifies if the events can be resized.
     */
    resize: boolean;
    /**
     * Specifies if new events can be added on `slot double click`.
     */
    add: boolean;
    /**
     * Specifies if the events can be edited on `item double click`.
     */
    edit: boolean;
    /**
     * Specifies if the events can be edited on `item double click`.
     */
    select: boolean;
}

/**
 * Represents the combined object of the default and custom [modelFields]({% slug api_scheduler_schedulerprops %}#toc)
 */
export declare interface Fields {
    id: string;
    start: string;
    startTimezone: string;
    originalStart: string;
    end: string;
    endTimezone: string;
    isAllDay: string;
    title: string;
    description: string;
    recurrenceRule: string;
    recurrenceId: string;
    recurrenceExceptions: string;
}

/** @hidden */
declare enum FORM_ITEM_ACTION {
    set = "FORM_ITEM_SET",
    setMaster = "FORM_ITEM_SET_MASTER",
    reset = "FORM_ITEM_RESET",
    complete = "FORM_ITEM_COMPLETE"
}

/**
 * Represents the Scheduler `Group` object, calculated based on the [group]({% slug api_scheduler_schedulerprops %}#toc-group) and [resources]({% slug api_scheduler_schedulerprops %}#toc-resources)
 */
export declare interface Group {
    index: number;
    resources: SchedulerResource[];
}

/** @hidden */
declare interface Item extends Occurrence {
    /** @hidden */
    _ref: React.RefObject<SchedulerItemHandle | SchedulerTaskHandle | null>;
    /**
     * Represents the `ref` of the actual `item`.
     */
    itemRef: React.RefObject<SchedulerItemHandle | SchedulerTaskHandle | null>;
    /**
     * Represents if the `end` of the item is outside the current visual range.
     */
    head: boolean;
    /**
     * Represents if the `start` of the item is outside the current visual range.
     */
    tail: boolean;
    /**
     * Represents the order of the item among its siblings.
     */
    order: number | null;
    /**
     * Represents the `start` Date in the provided timezone.
     *
     * For more information about timezones, refer to the [Scheduler TImezones]({% slug timezones_scheduler %}) article.
     */
    zonedStart: ZonedDate;
    /**
     * Represents the `end` Date in the provided timezone.
     *
     * For more information about timezones, refer to the [Scheduler TImezones]({% slug timezones_scheduler %}) article.
     */
    zonedEnd: ZonedDate;
    /**
     * A collection of all `slots` in which the current item fits.
     */
    slots: Slot[];
    /**
     * Represents the current group in which the item is rendered.
     */
    group: Group;
    /**
     * Represents the current range in which the item is rendered.
     */
    range: Range_2;
    /**
     * Represents if the item is an exception to a recurrence rule.
     */
    isException: boolean;
    /**
     * Represents if the item is a single occurrence of a recurring `DataItem`.
     */
    isRecurring: boolean;
    /**
     * Represents if the item durations is through the whole day.
     */
    isAllDay: boolean;
}

/**
 * @hidden
 */
export declare interface ItemDragEvent {
    pageX: number;
    pageY: number;
    clientX: number;
    clientY: number;
    offsetX: number;
    offsetY: number;
    type: string;
    ctrlKey: boolean;
    shiftKey: boolean;
    altKey: boolean;
    originalEvent: PointerEvent;
}

/**
 * Represents the available `action` types for the `SchedulerItemsFocusAction` objects.
 *
 * The available types are:
 * - `ITEMS_FOCUS_NEXT`
 * - `ITEMS_FOCUS_PREV`
 */
export declare enum ITEMS_FOCUS_ACTION {
    next = "ITEMS_FOCUS_NEXT",
    prev = "ITEMS_FOCUS_PREV"
}

/**
 * Represents the available `action` types for the `SchedulerItemsSelectAction` objects.
 *
 * The available types are:
 * - 'ITEMS_SELECT_SELECT`
 * - 'ITEMS_SELECT_SELECT_NEXT`
 * - 'ITEMS_SELECT_SELECT_PREV`
 * - 'ITEMS_SELECT_RESET`
 * - 'ITEMS_SELECT_ADD`
 * - 'ITEMS_SELECT_REMOVE`
 */
export declare enum ITEMS_SELECT_ACTION {
    select = "ITEMS_SELECT_SELECT",
    selectNext = "ITEMS_SELECT_SELECT_NEXT",
    selectPrev = "ITEMS_SELECT_SELECT_PREV",
    reset = "ITEMS_SELECT_RESET",
    add = "ITEMS_SELECT_ADD",
    remove = "ITEMS_SELECT_REMOVE"
}

/**
 * Represents the KendoReact [MonthView]({% slug month_view_scheduler %}) Component.
 */
export declare const MonthView: React_2.FunctionComponent<MonthViewProps>;

/** @hidden */
export declare const monthViewDefaultProps: {
    name: string;
    dateRange: ({ intl, date, timezone }: SchedulerViewDateRangeArgs) => DateRange;
    slotDuration: number;
    slotDivision: number;
    itemsPerSlot: number;
    numberOfDays: number;
    title: (localization: any) => any;
    selectedDateFormat: string;
    selectedShortDateFormat: string;
};

/**
 * Represents the props of the KendoReact [MonthView]({% slug api_scheduler_monthview %}) Component.
 */
export declare interface MonthViewProps extends Omit<SchedulerViewProps, 'numberOfDays' | 'step'> {
    /**
     * Sets the maximum number of `items` to be rendered in a single `slot`, before adding the `show-more` button.
     */
    itemsPerSlot?: number;
    /**
     * The long-date format for displaying the
     * selected date in the Scheduler toolbar.
     * Defaults to `{0:Y}`
     * ([more information](https://www.github.com/telerik/kendo-intl/blob/develop/docs/date-formatting/index.md))
     */
    selectedDateFormat?: string;
    /**
     * The short-date format for displaying the
     * selected date in the Scheduler toolbar.
     * Defaults to `{0:Y}`
     * ([more information](https://www.github.com/telerik/kendo-intl/blob/develop/docs/date-formatting/index.md))
     */
    selectedShortDateFormat?: string;
    /**
     * Overrides the general `editable` prop of the Scheduler for the specified view only.
     */
    editable?: boolean;
    /**
     * Sets a custom `className` to the wrapping element of the `DayView`.
     */
    className?: string;
    /**
     * Sets a custom `id` to the wrapping element of the `DayView`.
     */
    id?: string;
    /**
     * Sets a custom `style` property to the wrapping element of the `DayView`.
     */
    style?: React_2.CSSProperties;
    /**
     * Overrides the `item` prop of the Scheduler for the specified view only.
     */
    item?: React_2.ComponentType<SchedulerItemProps>;
    /**
     * Overrides the `viewItem` prop of the Scheduler for the specified view only.
     */
    viewItem?: React_2.ComponentType<SchedulerViewItemProps>;
    /**
     * Overrides the `editableItem` prop of the Scheduler for the specified view only.
     */
    editItem?: React_2.ComponentType<SchedulerEditItemProps>;
    /**
     * Overrides the `slot` prop of the Scheduler for the specified view only.
     */
    slot?: React_2.ComponentType<SchedulerSlotProps>;
    /**
     * Overrides the `viewSlot` prop of the Scheduler for the specified view only.
     */
    viewSlot?: React_2.ComponentType<SchedulerViewSlotProps>;
    /**
     * Overrides the `editSlot` prop of the Scheduler for the specified view only.
     */
    editSlot?: React_2.ComponentType<SchedulerEditSlotProps>;
    /**
     * Represents component based on the DateHeaderCellProps.
     */
    dateHeaderCell?: React_2.ComponentType<DateHeaderCellProps>;
    form?: React_2.ComponentType<SchedulerFormProps>;
}

/**
 * @hidden
 */
declare interface MultiDayTimelineViewProps extends SchedulerViewProps {
    /**
     * Specifies the step by which the currently rendered days will be changed, when using the back and forwards buttons in the toolbar navigation.
     */
    step?: number;
    /**
     * Specifies the number of days that the view will render.
     * Defaults to `1`.
     */
    numberOfDays?: number;
    /**
     * The long-date format for displaying the
     * selected date in the Scheduler toolbar.
     * Defaults to `{0:D} - {1:D}`
     * ([more information](https://www.github.com/telerik/kendo-intl/blob/develop/docs/date-formatting/index.md))
     */
    selectedDateFormat?: string;
    /**
     * The short-date format for displaying the
     * selected date in the Scheduler toolbar.
     * Defaults to `{0:d} - {1-d}`
     * ([more information](https://www.github.com/telerik/kendo-intl/blob/develop/docs/date-formatting/index.md))
     */
    selectedShortDateFormat?: string;
    /**
     * Overrides the general `editable` prop of the Scheduler for the specified view only.
     */
    editable?: boolean | EditableProp;
    /**
     * The start time of the view. The TimelineView displays events which are visible after the start time.
     * Accepts string values in the `HH:mm` format.
     */
    startTime?: string;
    /**
     * The end time of the view. The TimelineView displays events which are visible before the end time.
     * Accepts string values in the `HH:mm` format.
     */
    endTime?: string;
    /**
     * The start time of the view when `showWorkHours` is set to `true`.
     * Accepts string values in the `HH:mm` format.
     */
    workDayStart?: string;
    /** @hidden */
    isWorkDayStart?: string;
    /**
     * The end time of the view when `showWorkHours` is set to `true`.
     * Accepts string values in the `HH:mm` format.
     */
    workDayEnd?: string;
    /** @hidden */
    isWorkDayEnd?: string;
    /**
     * The start of the work week.
     */
    workWeekStart?: Day;
    /**
     * The end of the work week.
     */
    workWeekEnd?: Day;
    /**
     * The number of divisions of the time slots.
     */
    slotDivisions?: number;
    /**
     * The duration (in minutes) of the time slots.
     */
    slotDuration?: number;
    /**
     * The width of a single time slot in pixels. Default is 100px.
     */
    columnWidth?: number;
    /**
     * If set to `true`, the view will be shown in the business-hours mode only.
     *
     * This will always override the internal `showWorkHours` state.
     */
    showWorkHours?: boolean;
    /**
     * Sets the initial business-hour mode. Default `true`.
     *
     * This option applies only the initial `showWorkHours` state.
     */
    defaultShowWorkHours?: boolean;
    /**
     * Sets a custom `className` to the wrapping element of the `TimelineView`.
     */
    className?: string;
    /**
     * Sets a custom `id` to the wrapping element of the `TimelineView`.
     */
    id?: string;
    /**
     * Sets a custom `style` property to the wrapping element of the `TimelineView`.
     */
    style?: React_2.CSSProperties;
    /**
     * Overrides the `item` prop of the Scheduler for the specified view only.
     */
    item?: React_2.ComponentType<SchedulerItemProps>;
    /**
     * Overrides the `viewItem` prop of the Scheduler for the specified view only.
     */
    viewItem?: React_2.ComponentType<SchedulerViewItemProps>;
    /**
     * Overrides the `editableItem` prop of the Scheduler for the specified view only.
     */
    editItem?: React_2.ComponentType<SchedulerEditItemProps>;
    /**
     * Overrides the `slot` prop of the Scheduler for the specified view only.
     */
    slot?: React_2.ComponentType<SchedulerSlotProps>;
    /**
     * Overrides the `viewSlot` prop of the Scheduler for the specified view only.
     */
    viewSlot?: React_2.ComponentType<SchedulerViewSlotProps>;
    /**
     * Overrides the `editSlot` prop of the Scheduler for the specified view only.
     */
    editSlot?: React_2.ComponentType<SchedulerEditSlotProps>;
    form?: React_2.ComponentType<SchedulerFormProps>;
    /**
     * If set to `false` the "current time" marker of the scheduler would not be displayed.
     */
    currentTimeMarker?: boolean;
    /**
     * Represents component based on the DateHeaderCellProps.
     */
    dateHeaderCell?: React_2.ComponentType<DateHeaderCellProps>;
    /**
     * Represents component based on the TimeHeaderCellProps.
     */
    timeHeaderCell?: React_2.ComponentType<TimeHeaderCellProps>;
}

/**
 * @hidden
 */
declare interface MultiDayViewProps extends SchedulerViewProps {
    /**
     * The long-date format for displaying the
     * selected date in the Scheduler toolbar.
     * Defaults to `{0:D} - {1:D}`
     * ([more information](https://www.github.com/telerik/kendo-intl/blob/develop/docs/date-formatting/index.md))
     */
    selectedDateFormat?: string;
    /**
     * The short-date format for displaying the
     * selected date in the Scheduler toolbar.
     * Defaults to `{0:d} - {1-d}`
     * ([more information](https://www.github.com/telerik/kendo-intl/blob/develop/docs/date-formatting/index.md))
     */
    selectedShortDateFormat?: string;
    /**
     * Overrides the general `editable` prop of the Scheduler for the specified view only.
     */
    editable?: boolean;
    /**
     * Specifies the number of days that the view will render.
     * Defaults to `1`.
     */
    numberOfDays?: number;
    /**
     * The start time of the view. The MultiDayView displays events which are visible after the start time.
     * Accepts string values in the `HH:mm` format.
     */
    startTime?: string;
    /**
     * The end time of the view. The MultiDayView displays events which are visible before the end time.
     * Accepts string values in the `HH:mm` format.
     */
    endTime?: string;
    /**
     * Specifies the step by which the currently rendered days will be changed, when using the back and forwards buttons in the toolbar navigation.
     */
    step?: number;
    /**
     * The start time of the view when `showWorkHours` is set to `true`.
     * Accepts string values in the `HH:mm` format.
     */
    workDayStart?: string;
    /** @hidden */
    isWorkDayStart?: string;
    /**
     * The end time of the view when `showWorkHours` is set to `true`.
     * Accepts string values in the `HH:mm` format.
     */
    workDayEnd?: string;
    /** @hidden */
    isWorkDayEnd?: string;
    /**
     * The start of the work week.
     */
    workWeekStart?: Day;
    /**
     * The end of the work week.
     */
    workWeekEnd?: Day;
    /**
     * The number of divisions of the time slots.
     */
    slotDivisions?: number;
    /**
     * The duration (in minutes) of the time slots.
     */
    slotDuration?: number;
    /**
     * If set to `true`, the view will be shown in the business-hours mode only.
     *
     * This will always override the internal `showWorkHours` state.
     */
    showWorkHours?: boolean;
    /**
     * Sets the initial business-hour mode. Default `true`.
     *
     * This option applies only the initial `showWorkHours` state.
     */
    defaultShowWorkHours?: boolean;
    /**
     * Sets a custom `className` to the wrapping element of the `DayView`.
     */
    className?: string;
    /**
     * Sets a custom `id` to the wrapping element of the `DayView`.
     */
    id?: string;
    /**
     * Sets a custom `style` property to the wrapping element of the `DayView`.
     */
    style?: React_2.CSSProperties;
    /**
     * Overrides the `item` prop of the Scheduler for the specified view only.
     */
    item?: React_2.ComponentType<SchedulerItemProps>;
    /**
     * Overrides the `viewItem` prop of the Scheduler for the specified view only.
     */
    viewItem?: React_2.ComponentType<SchedulerViewItemProps>;
    /**
     * Overrides the `editableItem` prop of the Scheduler for the specified view only.
     */
    editItem?: React_2.ComponentType<SchedulerEditItemProps>;
    /**
     * Overrides the `slot` prop of the Scheduler for the specified view only.
     */
    slot?: React_2.ComponentType<SchedulerSlotProps>;
    /**
     * Overrides the `viewSlot` prop of the Scheduler for the specified view only.
     */
    viewSlot?: React_2.ComponentType<SchedulerViewSlotProps>;
    /**
     * Overrides the `editSlot` prop of the Scheduler for the specified view only.
     */
    editSlot?: React_2.ComponentType<SchedulerEditSlotProps>;
    form?: React_2.ComponentType<SchedulerFormProps>;
    /**
     * If set to `false` the "current time" marker of the scheduler would not be displayed.
     */
    currentTimeMarker?: boolean;
    /**
     * Represents component based on the DateHeaderCellProps.
     */
    dateHeaderCell?: React_2.ComponentType<DateHeaderCellProps>;
    /**
     * Represents component based on the TimeHeaderCellProps.
     */
    timeHeaderCell?: React_2.ComponentType<TimeHeaderCellProps>;
}

/** @hidden */
export declare interface Occurrence {
    /** @hidden */
    uid: string | number;
    /**
     * The `start` date of the item.
     */
    start: Date;
    /**
     * The `end` date of the item.
     */
    end: Date;
    /**
     * Represents the original start of the item.
     *
     * This property is being used when only a single occurrence of a recurring item is being edited.
     */
    originalStart: Date | null;
    /**
     * The timezone name for the `start` date.
     */
    startTimezone: string | null;
    /**
     * The timezone name for the `end` date.
     */
    endTimezone: string | null;
    /** @hidden */
    isAllDay: boolean | null;
    /**
     * The `title` of the item.
     */
    title: string | null;
    /**
     * The `description` of the item.
     */
    description: string | null;
    /** @hidden */
    occurrenceId: string | null;
    /** @hidden */
    recurrenceExceptions: Date[] | null;
    /** @hidden */
    recurrenceRule: string | null;
    /** @hidden */
    recurrenceId: string | number | null;
    /**
     * Represents the original `DataItem` from which the item was created.
     *
     * For more information about the `data` collection, refer to the [Scheduler Data Binding]({% slug data_binding_scheduler %}) article.
     */
    dataItem: DataItem;
}

/**
 * @hidden
 */
declare type Omit_2<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;

/** @hidden */
declare type Orientation = 'horizontal' | 'vertical' | null;

/** @hidden */
declare interface Range_2 {
    index: number;
    start: Date;
    end: Date;
    zonedStart: ZonedDate;
    zonedEnd: ZonedDate;
    isAllDay?: boolean;
}
export { Range_2 as Range }

/**
 * Represents the available `action` types for the `SchedulerItemRemoveItemAction` objects.
 *
 * The available types are:
 * - `REMOVE_ITEM_SET`
 * - `REMOVE_ITEM_RESET`
 * - `REMOVE_ITEM_COMPLETE`
 */
export declare enum REMOVE_ITEM_ACTION {
    set = "REMOVE_ITEM_SET",
    reset = "REMOVE_ITEM_RESET",
    complete = "REMOVE_ITEM_COMPLETE"
}

/**
 * Represents the available `action` types for the `SchedulerItemResizeItemAction` objects.
 *
 * The available types are:
 * - `RESIZE_ITEM_SET`
 * - `RESIZE_ITEM_START`
 * - `RESIZE_ITEM_START_DRAG`
 * - `RESIZE_ITEM_START_DRAG_SELECTED`
 * - `RESIZE_ITEM_END_DRAG`
 * - `RESIZE_ITEM_END_DRAG_SELECTED`
 * - `RESIZE_ITEM_COMPLETE`
 * - `RESIZE_ITEM_COMPLETE_OCCURRENCE`
 * - `RESIZE_ITEM_COMPLETE_SERIES`
 * - `RESIZE_ITEM_RESET`
 */
export declare enum RESIZE_ITEM_ACTION {
    set = "RESIZE_ITEM_SET",
    start = "RESIZE_ITEM_START",
    startDrag = "RESIZE_ITEM_START_DRAG",
    startDragSelected = "RESIZE_ITEM_START_DRAG_SELECTED",
    endDrag = "RESIZE_ITEM_END_DRAG",
    endDragSelected = "RESIZE_ITEM_END_DRAG_SELECTED",
    complete = "RESIZE_ITEM_COMPLETE",
    completeOccurrence = "RESIZE_ITEM_COMPLETE_OCCURRENCE",
    completeSeries = "RESIZE_ITEM_COMPLETE_SERIES",
    reset = "RESIZE_ITEM_RESET"
}

/** @hidden */
export declare interface Resource {
    field: string;
    valueField: string;
    textField?: string;
    colorField?: string;
    multiple?: boolean;
}

/**
 * Represents the [KendoReact Scheduler component]({% slug overview_scheduler %})
 *
 * @remarks
 * Supported children components are: {@link TimelineView}, {@link DayView}, {@link WeekView}, {@link MonthView}, {@link AgendaView}.
 *
 * @example
 * ```jsx
 *   const currentYear = new Date().getFullYear();
 *   const parseAdjust = (eventDate) => {
 *   const date = new Date(eventDate);
 *   date.setFullYear(currentYear);
 *   return date;
 *   };
 *
 *   const baseData = [
 *   {
 *   TaskID: 4,
 *   OwnerID: 2,
 *   Title: 'Bowling tournament',
 *   Description: '',
 *   StartTimezone: null,
 *   Start: '2013-06-09T21:00:00.000Z',
 *   End: '2013-06-10T00:00:00.000Z',
 *   EndTimezone: null,
 *   RecurrenceRule: null,
 *   RecurrenceID: null,
 *   RecurrenceException: null,
 *   isAllDay: false,
 *   },
 *   {
 *   TaskID: 5,
 *   OwnerID: 2,
 *   Title: 'Take the dog to the vet',
 *   Description: '',
 *   StartTimezone: null,
 *   Start: '2013-06-10T07:00:00.000Z',
 *   End: '2013-06-10T08:00:00.000Z',
 *   EndTimezone: null,
 *   RecurrenceRule: null,
 *   RecurrenceID: null,
 *   RecurrenceException: null,
 *   isAllDay: false,
 *    },
 *  ];
 *
 *   const sampleData = baseData.map((dataItem) => ({
 *   id: dataItem.TaskID,
 *   start: parseAdjust(dataItem.Start),
 *   startTimezone: dataItem.startTimezone,
 *   end: parseAdjust(dataItem.End),
 *   endTimezone: dataItem.endTimezone,
 *   isAllDay: dataItem.isAllDay,
 *   title: dataItem.Title,
 *   description: dataItem.Description,
 *   recurrenceRule: dataItem.RecurrenceRule,
 *   recurrenceExceptions: dataItem.RecurrenceException,
 *   roomId: dataItem.RoomID,
 *   ownerID: dataItem.OwnerID,
 *   personId: dataItem.OwnerID,
 *   }));
 *
 *   const App = () => {
 *   return (
 *   <Scheduler data={sampleData}>
 *   <AgendaView />
 *   <DayView />
 *   <WeekView />
 *   <MonthView />
 *   </Scheduler>
 *    );
 *   };
 *   ReactDOM.render(<App />, document.querySelector('my-app'));
 * ```
 */
export declare const Scheduler: React_2.ForwardRefExoticComponent<SchedulerProps & React_2.RefAttributes<SchedulerHandle | null>>;

/**
 * A [React Context](https://react.dev/reference/react/hooks#context-hooks) providing access to the Scheduler internal `activeView` state.
 *
 * For more information, refer to the [Scheduler Context]({% slug context_scheduler %}) article.
 */
export declare const SchedulerActiveViewContext: React_2.Context<SchedulerActiveViewContextType>;

/**
 * Specifies the result of the [useSchedulerActiveViewContext]({% slug api_scheduler_usescheduleractiveviewcontext %}) and [SchedulerActiveViewContext]({% slug api_scheduler_scheduleractiveviewcontext %}).
 */
export declare type SchedulerActiveViewContextType = [string, (activeView: string, event?: any) => void];

/**
 * Called every time the user changes the provided `data`.
 *
 * For more information, refer to the [Scheduler Data Binding]({% slug data_binding_scheduler %}) article.
 */
export declare interface SchedulerDataChangeEvent {
    created: DataItem[];
    updated: DataItem[];
    deleted: DataItem[];
}

/**
 * A [React Context](https://react.dev/reference/react/hooks#context-hooks) providing access to the Scheduler internal `data` reducer.
 *
 * For more information, refer to the [Scheduler Context]({% slug context_scheduler %}) article.
 */
export declare const SchedulerDataContext: React_2.Context<SchedulerDataContextType>;

/**
 * Specifies the result of the [useSchedulerDataContext]({% slug api_scheduler_useschedulerdatacontext %}) and [SchedulerDataContext]({% slug api_scheduler_schedulerdatacontext %}).
 */
export declare type SchedulerDataContextType = [DataItem[], (action: DataAction, event?: any) => void];

/**
 * Called every time the user changes the selected `date`.
 * The value is a JavaScript `Date` object.
 * For more information, refer to the article on
 * [date selection]({% slug date_selection_scheduler %}).
 */
export declare interface SchedulerDateChangeEvent {
    value: Date;
}

/**
 * A [React Context](https://react.dev/reference/react/hooks#context-hooks) providing access to the Scheduler internal `date` state.
 *
 * For more information, refer to the [Scheduler Context]({% slug context_scheduler %}) article.
 */
export declare const SchedulerDateContext: React_2.Context<SchedulerDateContextType>;

/**
 * Specifies the result of the [useSchedulerDateContext]({% slug api_scheduler_useschedulerdatecontext %}) and [SchedulerDateContext]({% slug api_scheduler_schedulerdatecontext %}).
 */
export declare type SchedulerDateContextType = [Date, (date: Date, event?: any) => void];

/**
 * A [React Context](https://react.dev/reference/react/hooks#context-hooks) providing access to the `dateRange` of the current view.
 *
 * For more information, refer to the [Scheduler Context]({% slug context_scheduler %}) article.
 */
export declare const SchedulerDateRangeContext: React_2.Context<DateRange>;

/**
 * Specifies the result of the [useSchedulerDateRangeContext]({% slug api_scheduler_useschedulerdaterangecontext %}) and [SchedulerDateRangeContext]({% slug api_scheduler_schedulerdaterangecontext %}).
 */
export declare type SchedulerDateRangeContextType = DateRange;

export declare const schedulerDefaultProps: {
    data: never[];
    height: number;
    tabIndex: number;
    editable: boolean;
    defaultDate: Date;
    header: React_2.ForwardRefExoticComponent<SchedulerHeaderProps & React_2.RefAttributes<SchedulerHeaderHandle_2>>;
    footer: React_2.ForwardRefExoticComponent<SchedulerFooterProps & React_2.RefAttributes<SchedulerFooterHandle_2>>;
    navigation: React_2.ForwardRefExoticComponent<SchedulerNavigationProps & React_2.RefAttributes<SchedulerNavigationHandle>>;
    viewSelector: React_2.ForwardRefExoticComponent<SchedulerViewSelectorProps & React_2.RefAttributes<SchedulerViewSelectorHandle>>;
};

/**
 * Represents the default `drag` component rendered by the [KendoReact SchedulerEditItem component].
 */
export declare const SchedulerDrag: React_2.FunctionComponent<SchedulerDragProps>;

export declare const schedulerDragDefaultProps: {
    viewItem: React_2.ForwardRefExoticComponent<SchedulerViewItemProps & React_2.RefAttributes<SchedulerViewItemHandle_2>>;
    item: React_2.ForwardRefExoticComponent<SchedulerItemProps & React_2.RefAttributes<SchedulerItemHandle_2>>;
};

/**
 * Represents the props of the KendoReact [SchedulerDrag] component.
 */
export declare interface SchedulerDragProps {
    /** @hidden */
    ignoreIsAllDay?: boolean;
    /**
     * Specifies the `DataItem` to be visualized as a Drag item.
     */
    dataItem: DataItem;
    /**
     * Specifies the orientation of the SchedulerItem inside the Drag.
     */
    vertical?: boolean;
    /**
     * Overrides the default component responsible for visualizing a single item.
     *
     * The default Component is: [SchedulerItem].
     */
    item?: React_2.ComponentType<SchedulerItemProps>;
    /**
     * Overrides the default component responsible for positioning the item inside the view.
     *
     * The default Component is: [SchedulerViewItem]().
     */
    viewItem?: React_2.ComponentType<SchedulerViewItemProps>;
}

/**
 * Represents the default `editItem` component rendered by the [KendoReact Scheduler component]({% slug overview_scheduler %}).
 *
 * This is a composite component of the [`SchedulerViewItem`]({% slug api_scheduler_schedulerviewitem %}), extending it to provide editing through drag, resize and external form.
 */
export declare const SchedulerEditItem: React_2.ForwardRefExoticComponent<SchedulerEditItemProps & React_2.RefAttributes<SchedulerEditItemHandle>>;

/**
 * Represents the available SchedulerEditItem` actions.
 *
 * Can be one of:
 * - [SchedulerItemDragItemAction]({% slug api_scheduler_scheduleritemdragitemaction %})
 * - [SchedulerItemResizeItemAction]({% slug api_scheduler_scheduleritemresizeitemaction %})
 * - [SchedulerItemRemoveItemAction]({% slug api_scheduler_scheduleritemremoveitemaction %})
 * - [SchedulerItemShowRemoveDialogAction]({% slug api_scheduler_scheduleritemshowremovedialogaction %})
 * - [SchedulerItemShowOccurrenceDialogAction]({% slug api_scheduler_scheduleritemshowoccurrencedialogaction %})
 * - [SchedulerItemSeriesAction]({% slug api_scheduler_scheduleritemseriesaction %})
 * - [SchedulerItemsFocusAction]({% slug api_scheduler_scheduleritemsfocusaction %})
 * - [SchedulerItemsSelectAction]({% slug api_scheduler_scheduleritemsselectaction %})
 * - [SchedulerSlotsFocusAction]({% slug api_scheduler_schedulerslotsfocusaction %})
 * - [SchedulerSlotsSelectAction]({% slug api_scheduler_schedulerslotsselectaction %})
 *
 * The following `falsy` values will be ignored:
 * - `null`
 * - `false`
 * - `undefined`
 */
export declare type SchedulerEditItemAction = SchedulerItemFormItemAction | SchedulerItemDragItemAction | SchedulerItemResizeItemAction | SchedulerItemRemoveItemAction | SchedulerItemShowRemoveDialogAction | SchedulerItemShowOccurrenceDialogAction | SchedulerItemSeriesAction | SchedulerItemsFocusAction | SchedulerItemsSelectAction | SchedulerSlotsFocusAction | SchedulerSlotsSelectAction | null | false | undefined;

export declare const schedulerEditItemDefaultProps: {
    viewItem: React_2.ForwardRefExoticComponent<SchedulerViewItemProps & React_2.RefAttributes<SchedulerViewItemHandle_3>>;
    drag: React_2.FunctionComponent<SchedulerDragProps>;
    resize: React_2.FunctionComponent<SchedulerResizeProps>;
    form: React_2.ForwardRefExoticComponent<SchedulerFormProps & React_2.RefAttributes<SchedulerFormHandle_2 | null>>;
    occurrenceDialog: React_2.ForwardRefExoticComponent<SchedulerOccurrenceDialogProps & React_2.RefAttributes<SchedulerOccurrenceDialogHandle_2 | null>>;
    removeDialog: React_2.ForwardRefExoticComponent<SchedulerRemoveDialogProps & React_2.RefAttributes<SchedulerRemoveDialogHandle_2 | null>>;
    onClickAction: (event: SchedulerItemMouseEvent, _: SchedulerEditItemProps, state: SchedulerEditItemState) => SchedulerEditItemAction[];
    onDoubleClickAction: (_: any, props: SchedulerEditItemProps) => (false | {
        type: FORM_ITEM_ACTION;
        payload: any;
    } | {
        type: SHOW_OCCURRENCE_DIALOG_ACTION;
        payload?: undefined;
    })[];
    onRemoveClickAction: (_: any, props: SchedulerEditItemProps) => ({
        type: REMOVE_ITEM_ACTION;
        payload: any;
    } | {
        type: SHOW_OCCURRENCE_DIALOG_ACTION;
        payload?: undefined;
    } | {
        type: SHOW_REMOVE_DIALOG_ACTION;
        payload?: undefined;
    })[];
    onPressAction: (event: SchedulerItemDragEvent, props: SchedulerEditItemProps) => never[] | {
        type: DRAG_ITEM_ACTION;
        payload: {
            x: number;
            y: number;
        };
    };
    onDragAction: (event: SchedulerItemDragEvent, props: SchedulerEditItemProps) => never[] | {
        type: DRAG_ITEM_ACTION;
        payload: {
            x: number;
            y: number;
        };
    };
    onReleaseAction: (event: SchedulerItemDragEvent, props: SchedulerEditItemProps, state: SchedulerEditItemState) => never[] | {
        type: SHOW_OCCURRENCE_DIALOG_ACTION;
        payload?: undefined;
    } | {
        type: DRAG_ITEM_ACTION;
        payload: {
            x: number;
            y: number;
        };
    };
    onResizePressAction: (event: SchedulerItemDragEvent, props: SchedulerEditItemProps) => never[] | {
        type: RESIZE_ITEM_ACTION;
        payload: {
            x: number;
            y: number;
        };
    };
    onResizeStartDragAction: (event: SchedulerItemDragEvent, props: SchedulerEditItemProps) => never[] | {
        type: RESIZE_ITEM_ACTION;
        payload: {
            x: number;
            y: number;
        };
    };
    onResizeEndDragAction: (event: SchedulerItemDragEvent, props: SchedulerEditItemProps) => never[] | {
        type: RESIZE_ITEM_ACTION;
        payload: {
            x: number;
            y: number;
        };
    };
    onResizeReleaseAction: (event: SchedulerItemDragEvent, props: SchedulerEditItemProps, state: SchedulerEditItemState) => never[] | {
        type: SHOW_OCCURRENCE_DIALOG_ACTION;
        payload?: undefined;
    } | {
        type: RESIZE_ITEM_ACTION;
        payload: {
            x: number;
            y: number;
        };
    };
    onOccurrenceClickAction: (_event: SchedulerOccurrenceDialogStateChangeEvent<any>, props: SchedulerEditItemProps, state: SchedulerEditItemState) => SchedulerEditItemAction[];
    onSeriesClickAction: (_event: SchedulerOccurrenceDialogStateChangeEvent<any>, props: SchedulerEditItemProps, state: SchedulerEditItemState) => SchedulerEditItemAction[];
    onKeyDownAction: (event: SchedulerItemKeyboardEvent, props: SchedulerEditItemProps) => SchedulerEditItemAction | SchedulerEditItemAction[];
    onFormSubmitAction: (event: SchedulerFormStateChangeEvent<DataItem | null>) => SchedulerEditItemAction[];
    onRemoveConfirmAction: () => SchedulerEditItemAction[];
    onCancelAction: () => SchedulerEditItemAction[];
};

/**
 * A [React Context](https://react.dev/reference/react/hooks#context-hooks) providing access to the [SchedulerEditItem]({% slug edit-item_items_scheduler %}) internal `dragItem` state.
 *
 * For more information, refer to the [Items Context]({% slug state-update_items_scheduler %}) article.
 */
export declare const SchedulerEditItemDragItemContext: React_2.Context<SchedulerEditItemDragItemContextType>;

/**
 * Specifies the result of the [useSchedulerEditItemDragItemContext]({% slug api_scheduler_usescheduleredititemdragitemcontext %}) and [SchedulerEditItemDragItemContext]({% slug api_scheduler_scheduleredititemdragitemcontext %}).
 */
export declare type SchedulerEditItemDragItemContextType = [
DataItem | null,
(newValue?: DataItem | null, event?: React_2.SyntheticEvent | BaseEvent_2<any> | {
    preventDefault: any;
}) => void,
(action: SchedulerItemFormItemAction, event?: React_2.SyntheticEvent | BaseEvent_2<any> | {
    preventDefault: any;
}) => void
];

/**
 * A [React Context](https://react.dev/reference/react/hooks#context-hooks) providing access to the [SchedulerEditItem]({% slug edit-item_items_scheduler %}) internal `formItem` state.
 *
 * For more information, refer to the [Items Context]({% slug state-update_items_scheduler %}) article.
 */
export declare const SchedulerEditItemFormItemContext: React_2.Context<SchedulerEditItemFormItemContextType>;

/**
 * Specifies the result of the [useSchedulerEditItemFormItemContext]({% slug api_scheduler_usescheduleredititemformitemcontext %}) and [SchedulerEditItemFormItemContext]({% slug api_scheduler_scheduleredititemformitemcontext %}).
 */
export declare type SchedulerEditItemFormItemContextType = [
DataItem | null,
(newValue: DataItem | null, event?: React_2.SyntheticEvent | BaseEvent_2<any> | {
    preventDefault: any;
}) => void,
(action: SchedulerItemFormItemAction, event?: React_2.SyntheticEvent | BaseEvent_2<any> | {
    preventDefault: any;
}) => void
];

/**
 * Represents the object which is returned from the `ref` callback of the [SchedulerEditItem]({% slug api_scheduler_scheduleredititem %}).
 *
 * For more information about Refs, refer to the [React Refs & Dom](https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom) article.
 */
export declare interface SchedulerEditItemHandle {
    element: HTMLDivElement | null;
    props: SchedulerEditItemProps;
}

/**
 * Represents the props of the KendoReact [SchedulerEditItem]() component.
 */
export declare interface SchedulerEditItemProps extends SchedulerViewItemProps {
    /**
     * Overrides the default component responsible for positioning the item inside the view.
     *
     * The default Component is: [SchedulerViewItem]({% slug api_scheduler_schedulerviewitem %}).
     */
    viewItem?: React_2.ComponentType<SchedulerViewItemProps>;
    /**
     * Overrides the default component responsible for visualizing the `dragItem`.
     *
     * The default Component is: [SchedulerDrag]({% slug api_scheduler_schedulerdrag %}).
     */
    drag?: React_2.ComponentType<SchedulerDragProps>;
    /**
     * Overrides the default component responsible for visualizing the `resizeItem`.
     *
     * The default Component is: [SchedulerResize]({% slug api_scheduler_schedulerresize %}).
     */
    resize?: React_2.ComponentType<SchedulerResizeProps>;
    /**
     * Overrides the default component responsible for visualizing the `formItem`.
     *
     * The default Component is: [SchedulerForm]({% slug api_scheduler_schedulerform %}).
     */
    form?: React_2.ComponentType<SchedulerFormProps>;
    /**
     * Overrides the default component responsible for visualizing the `removeItem` and confirming the `remove` action.
     *
     * The default Component is: [SchedulerRemoveDialog]({% slug api_scheduler_schedulerremovedialog %}).
     */
    removeDialog?: React_2.ComponentType<SchedulerRemoveDialogProps>;
    /**
     * Overrides the default component responsible for the selection between `occurrence` and `series` edit.
     *
     * The default Component is: [SchedulerOccurrenceDialog]({% slug api_scheduler_scheduleroccurrencedialog %}).
     */
    occurrenceDialog?: React_2.ComponentType<SchedulerOccurrenceDialogProps>;
    /**
     * Called when the item has been removed or manipulated though dragging, resizing or an external form.
     */
    onDataAction?: (action: DataAction, event?: any) => void;
    /**
     * Setting this property will force the `formItem` to be in controlled state, allowing further customization.
     */
    formItem?: DataItem | null;
    /**
     * Called every time the `formItem` changes.
     */
    onFormItemChange?: (event: SchedulerEditItemStateChangeEvent<DataItem | null>) => void;
    /**
     * Setting this property will force the `dragItem` to be in controlled state, allowing further customization.
     */
    dragItem?: DataItem | null;
    /**
     * Called every time the `dragItem` changes.
     */
    onDragItemChange?: (event: SchedulerEditItemStateChangeEvent<DataItem | null>) => void;
    /**
     * Setting this property will force the `resizeItem` to be in controlled state, allowing further customization.
     */
    resizeItem?: DataItem | null;
    /**
     * Called every time the `resize` changes.
     */
    onResizeItemChange?: (event: SchedulerEditItemStateChangeEvent<DataItem | null>) => void;
    /**
     * Setting this property will force the `removeItem` to be in controlled state, allowing further customization.
     *
     * Specifies the DataItem which should be removed from the `data` set.
     * The `removeItem` is passed as property to the `removeDialog` and `occurrenceDialog` component;
     */
    removeItem?: DataItem | null;
    /**
     * Called every time the `removeItem` changes.
     */
    onRemoveItemChange?: (event: SchedulerEditItemStateChangeEvent<DataItem | null>) => void;
    /**
     * Setting this property will force the `showOccurrenceDialog` to be in controlled state, allowing further control over the display of the `occurrenceDialog` component.
     */
    showOccurrenceDialog?: boolean;
    /**
     * Called every time the `showOccurrenceDialog` changes.
     */
    onShowOccurrenceDialogChange?: (event: SchedulerEditItemStateChangeEvent<boolean>) => void;
    /**
     * Setting this property will force the `showRemoveDialog` to be in controlled state, allowing further control over the display of the `removeDialog` component.
     */
    showRemoveDialog?: boolean;
    /**
     * Called every time the `showRemoveDialog` changes.
     */
    onShowRemoveDialogChange?: (event: SchedulerEditItemStateChangeEvent<boolean>) => void;
    /**
     * Indicates if the editing should be applied to the whole `series` or to a single `occurrence` when the item is recurring.
     *
     * By default, the `series` prop is set to `null` and additional selection is done through the `occurrence` dialog.
     * If set ot either `true` or `false`:
     * - `true` &mdash; indicates that the editing should always be applied to the whole `series`
     * - `false` &mdash; indicates that the editing should always be applied to a single `occurrence`.
     */
    series?: boolean | null;
    /**
     * Called every time the `series` changes.
     */
    onSeriesChange?: (event: SchedulerEditItemStateChangeEvent<boolean | null>) => void;
    /**
     * Called whenever the `occurence` option is selected from the `OccurrenceDialog`.
     */
    onOccurrenceClick?: (event: SchedulerOccurrenceDialogStateChangeEvent<any>) => void;
    /**
     * An action callback. Used to define the component behavior on occurrence click.
     *
     * Internal state change will be triggered depending on the specific action types.
     */
    onOccurrenceClickAction?: (event: SchedulerOccurrenceDialogStateChangeEvent<any>, props: SchedulerEditItemProps, state: SchedulerEditItemState) => SchedulerEditItemAction | SchedulerEditItemAction[];
    /**
     * Called whenever the `series` option is selected from the `OccurrenceDialog`.
     */
    onSeriesClick?: (event: SchedulerOccurrenceDialogStateChangeEvent<any>) => void;
    /**
     * An action callback. Used to define the component behavior on series click.
     *
     * Internal state change will be triggered depending on the specific action types.
     */
    onSeriesClickAction?: (event: SchedulerOccurrenceDialogStateChangeEvent<any>, props: SchedulerEditItemProps, state: SchedulerEditItemState) => SchedulerEditItemAction | SchedulerEditItemAction[];
    /**
     * Called whenever the `confirm` option is selected from the `RemoveDialog`.
     */
    onRemoveConfirm?: (event: SchedulerRemoveDialogStateChangeEvent<any>) => void;
    /**
     * An action callback. Used to define the component behavior on remove confirm click.
     *
     * Internal state change will be triggered depending on the specific action types.
     */
    onRemoveConfirmAction?: (event: SchedulerRemoveDialogStateChangeEvent<any>, props: SchedulerEditItemProps, state: SchedulerEditItemState) => SchedulerEditItemAction | SchedulerEditItemAction[];
    /**
     * Called whenever the `form` is submitted.
     */
    onFormSubmit?: (event: SchedulerFormStateChangeEvent<DataItem | null>) => void;
    /**
     * An action callback. Used to define the component behavior on form submit.
     *
     * Internal state change will be triggered depending on the specific action types.
     */
    onFormSubmitAction?: (event: SchedulerFormStateChangeEvent<DataItem | null>, props: SchedulerEditItemProps, state: SchedulerEditItemState) => SchedulerEditItemAction | SchedulerEditItemAction[];
    /**
     * Called whenever the current edit is canceled.
     */
    onCancel?: (event: SchedulerFormStateChangeEvent<null> | SchedulerOccurrenceDialogStateChangeEvent<null>) => void;
    /**
     * An action callback. Used to define the component behavior on cancel.
     *
     * Internal state change will be triggered depending on the specific action types.
     */
    onCancelAction?: (event: SchedulerFormStateChangeEvent<null> | SchedulerOccurrenceDialogStateChangeEvent<null>, props: SchedulerEditItemProps, state: SchedulerEditItemState) => SchedulerEditItemAction | SchedulerEditItemAction[];
    /**
     * An action callback. Used to define the component behavior on click.
     *
     * Internal state change will be triggered depending on the specific action types.
     */
    onClickAction?: (event: SchedulerItemMouseEvent, props: SchedulerEditItemProps, state: SchedulerEditItemState) => SchedulerEditItemAction | SchedulerEditItemAction[];
    /**
     * An action callback. Used to define the component behavior on mouse down.
     *
     * Internal state change will be triggered depending on the specific action types.
     */
    onMouseDownAction?: (event: SchedulerItemMouseEvent, props: SchedulerEditItemProps, state: SchedulerEditItemState) => SchedulerEditItemAction | SchedulerEditItemAction[];
    /**
     * An action callback. Used to define the component behavior on mouse up.
     *
     * Internal state change will be triggered depending on the specific action types.
     */
    onMouseUpAction?: (event: SchedulerItemMouseEvent, props: SchedulerEditItemProps, state: SchedulerEditItemState) => SchedulerEditItemAction | SchedulerEditItemAction[];
    /**
     * An action callback. Used to define the component behavior on double click.
     *
     * Internal state change will be triggered depending on the specific action types.
     */
    onDoubleClickAction?: (event: SchedulerItemMouseEvent, props: SchedulerEditItemProps, state: SchedulerEditItemState) => SchedulerEditItemAction | SchedulerEditItemAction[];
    /**
     * An action callback. Used to define the component behavior on remove click.
     *
     * Internal state change will be triggered depending on the specific action types.
     */
    onRemoveClickAction?: (event: SchedulerItemMouseEvent, props: SchedulerEditItemProps, state: SchedulerEditItemState) => SchedulerEditItemAction | SchedulerEditItemAction[];
    /**
     * An action callback. Used to define the component behavior on key down.
     *
     * Internal state change will be triggered depending on the specific action types.
     */
    onKeyDownAction?: (event: SchedulerItemKeyboardEvent, props: SchedulerEditItemProps, state: SchedulerEditItemState) => SchedulerEditItemAction | SchedulerEditItemAction[];
    /**
     * An action callback. Used to define the component behavior on key up.
     *
     * Internal state change will be triggered depending on the specific action types.
     */
    onKeyUpAction?: (event: SchedulerItemKeyboardEvent, props: SchedulerEditItemProps, state: SchedulerEditItemState) => SchedulerEditItemAction | SchedulerEditItemAction[];
    /**
     * An action callback. Used to define the component behavior on focus.
     *
     * Internal state change will be triggered depending on the specific action types.
     */
    onFocusAction?: (event: SchedulerItemFocusEvent, props: SchedulerEditItemProps, state: SchedulerEditItemState) => SchedulerEditItemAction | SchedulerEditItemAction[];
    /**
     * An action callback. Used to define the component behavior on blur.
     *
     * Internal state change will be triggered depending on the specific action types.
     */
    onBlurAction?: (event: SchedulerItemFocusEvent, props: SchedulerEditItemProps, state: SchedulerEditItemState) => SchedulerEditItemAction | SchedulerEditItemAction[];
    /**
     * An action callback. Used to define the component behavior on press.
     *
     * Internal state change will be triggered depending on the specific action types.
     */
    onPressAction?: (event: SchedulerItemDragEvent, props: SchedulerEditItemProps, state: SchedulerEditItemState) => SchedulerEditItemAction | SchedulerEditItemAction[];
    /**
     * An action callback. Used to define the component behavior on drag.
     *
     * Internal state change will be triggered depending on the specific action types.
     */
    onDragAction?: (event: SchedulerItemDragEvent, props: SchedulerEditItemProps, state: SchedulerEditItemState) => SchedulerEditItemAction | SchedulerEditItemAction[];
    /**
     * An action callback. Used to define the component behavior on release.
     *
     * Internal state change will be triggered depending on the specific action types.
     */
    onReleaseAction?: (event: SchedulerItemDragEvent, props: SchedulerEditItemProps, state: SchedulerEditItemState) => SchedulerEditItemAction | SchedulerEditItemAction[];
    /**
     * An action callback. Used to define the component behavior on resize press.
     *
     * Internal state change will be triggered depending on the specific action types.
     */
    onResizePressAction?: (event: SchedulerItemDragEvent, props: SchedulerEditItemProps, state: SchedulerEditItemState) => SchedulerEditItemAction | SchedulerEditItemAction[];
    /**
     * An action callback. Used to define the component behavior on resize start drag.
     *
     * Internal state change will be triggered depending on the specific action types.
     */
    onResizeStartDragAction?: (event: SchedulerItemDragEvent, props: SchedulerEditItemProps, state: SchedulerEditItemState) => SchedulerEditItemAction | SchedulerEditItemAction[];
    /**
     * An action callback. Used to define the component behavior on resize end drag.
     *
     * Internal state change will be triggered depending on the specific action types.
     */
    onResizeEndDragAction?: (event: SchedulerItemDragEvent, props: SchedulerEditItemProps, state: SchedulerEditItemState) => SchedulerEditItemAction | SchedulerEditItemAction[];
    /**
     * An action callback. Used to define the component behavior on resize release.
     *
     * Internal state change will be triggered depending on the specific action types.
     */
    onResizeReleaseAction?: (event: SchedulerItemDragEvent, props: SchedulerEditItemProps, state: SchedulerEditItemState) => SchedulerEditItemAction | SchedulerEditItemAction[];
}

/**
 * A [React Context](https://react.dev/reference/react/hooks#context-hooks) providing access to the [SchedulerEditItem]({% slug edit-item_items_scheduler %}) `props`.
 *
 * For more information, refer to the [Items Context]({% slug state-update_items_scheduler %}) article.
 */
export declare const SchedulerEditItemPropsContext: React_2.Context<SchedulerEditItemProps>;

/**
 * Specifies the result of the [useSchedulerEditItemPropsContext]({% slug api_scheduler_usescheduleredititempropscontext %}) and [SchedulerEditItemPropsContext]({% slug api_scheduler_scheduleredititempropscontext %}).
 */
export declare type SchedulerEditItemPropsContextType = SchedulerEditItemProps;

/**
 * A [React Context](https://react.dev/reference/react/hooks#context-hooks) providing access to the [SchedulerEditItem]({% slug edit-item_items_scheduler %}) internal `removeItem` state.
 *
 * For more information, refer to the [Items Context]({% slug state-update_items_scheduler %}) article.
 */
export declare const SchedulerEditItemRemoveItemContext: React_2.Context<SchedulerEditItemRemoveItemContextType>;

/**
 * Specifies the result of the [useSchedulerEditItemRemoveItemContext]({% slug api_scheduler_usescheduleredititemremoveitemcontext %}) and [SchedulerEditItemRemoveItemContext]({% slug api_scheduler_scheduleredititemremoveitemcontext %}).
 */
export declare type SchedulerEditItemRemoveItemContextType = [
DataItem | null,
(newValue?: any, event?: React_2.SyntheticEvent | BaseEvent_2<any> | {
    preventDefault: any;
}) => void,
(action: SchedulerItemFormItemAction, event?: React_2.SyntheticEvent | BaseEvent_2<any> | {
    preventDefault: any;
}) => void
];

/**
 * A [React Context](https://react.dev/reference/react/hooks#context-hooks) providing access to the [SchedulerEditItem]({% slug edit-item_items_scheduler %}) internal `resizeItem` state.
 *
 * For more information, refer to the [Items Context]({% slug state-update_items_scheduler %}) article.
 */
export declare const SchedulerEditItemResizeItemContext: React_2.Context<SchedulerEditItemResizeItemContextType>;

/**
 * Specifies the result of the [useSchedulerEditItemResizeItemContext]({% slug api_scheduler_usescheduleredititemresizeitemcontext %}) and [SchedulerEditItemResizeItemContext]({% slug api_scheduler_scheduleredititemresizeitemcontext %}).
 */
export declare type SchedulerEditItemResizeItemContextType = [
DataItem | null,
(newValue?: DataItem | null, event?: React_2.SyntheticEvent | BaseEvent_2<any> | {
    preventDefault: any;
}) => void,
(action: SchedulerItemFormItemAction, event?: React_2.SyntheticEvent | BaseEvent_2<any> | {
    preventDefault: any;
}) => void
];

/**
 * A [React Context](https://react.dev/reference/react/hooks#context-hooks) providing access to the [SchedulerEditItem]({% slug edit-item_items_scheduler %}) internal `showOccurrenceDialog` state.
 *
 * For more information, refer to the [Items Context]({% slug state-update_items_scheduler %}) article.
 */
export declare const SchedulerEditItemShowOccurrenceDialogContext: React_2.Context<SchedulerEditItemShowOccurrenceDialogContextType>;

/**
 * Specifies the result of the [useSchedulerEditItemShowOccurrenceDialogContext]({% slug api_scheduler_usescheduleredititemshowoccurrencedialogcontext %}) and [SchedulerEditItemShowOccurrenceDialogContext]({% slug api_scheduler_scheduleredititemshowoccurrencedialogcontext %}).
 */
export declare type SchedulerEditItemShowOccurrenceDialogContextType = [
boolean,
(newValue?: boolean, event?: React_2.SyntheticEvent | BaseEvent_2<any> | {
    preventDefault: any;
}) => void,
(action: SchedulerItemFormItemAction, event?: React_2.SyntheticEvent | BaseEvent_2<any> | {
    preventDefault: any;
}) => void
];

/**
 * A [React Context](https://react.dev/reference/react/hooks#context-hooks) providing access to the [SchedulerEditItem]({% slug edit-item_items_scheduler %}) internal `showRemoveDialog` state.
 *
 * For more information, refer to the [Items Context]({% slug state-update_items_scheduler %}) article.
 */
export declare const SchedulerEditItemShowRemoveDialogContext: React_2.Context<SchedulerEditItemShowRemoveDialogContextType>;

/**
 * Specifies the result of the [useSchedulerEditItemShowRemoveDialogContext]({% slug api_scheduler_usescheduleredititemshowremovedialogcontext %}) and [SchedulerEditItemShowRemoveDialogContext]({% slug api_scheduler_scheduleredititemshowremovedialogcontext %}).
 */
export declare type SchedulerEditItemShowRemoveDialogContextType = [
boolean,
(newValue?: boolean, event?: React_2.SyntheticEvent | BaseEvent_2<any> | {
    preventDefault: any;
}) => void,
(action: SchedulerItemFormItemAction, event?: React_2.SyntheticEvent | BaseEvent_2<any> | {
    preventDefault: any;
}) => void
];

/**
 * Represents the internal `state` of the `SchedulerEditItem`.
 */
export declare interface SchedulerEditItemState {
    selected: boolean;
    series: boolean | null;
    formItem: DataItem | null;
    dragItem: DataItem | null;
    resizeItem: DataItem | null;
    removeItem: DataItem | null;
    showRemoveDialog: DataItem | null;
    showOccurrenceDialog: DataItem | null;
}

export declare interface SchedulerEditItemStateChangeEvent<T> {
    value: T;
}

/**
 * Represents the default `editSlot` component rendered by the [KendoReact Scheduler component]({% slug overview_scheduler %}).
 *
 * This is a composite component of the [`SchedulerViewSlot`]({% slug api_scheduler_schedulerviewslot %}), extending it to allow creating an item inside the slot.
 */
export declare const SchedulerEditSlot: React_2.ForwardRefExoticComponent<SchedulerEditSlotProps & React_2.RefAttributes<SchedulerEditSlotHandle>>;

export declare const schedulerEditSlotDefaultProps: {
    viewSlot: React_2.ForwardRefExoticComponent<SchedulerViewSlotProps & React_2.RefAttributes<SchedulerViewSlotHandle_2>>;
    form: React_2.ForwardRefExoticComponent<SchedulerFormProps & React_2.RefAttributes<SchedulerFormHandle_2 | null>>;
};

/**
 * A [React Context](https://react.dev/reference/react/hooks#context-hooks) providing access to the [SchedulerEditSlot]({% slug api_scheduler_schedulereditslot %}) internal `formItem` state.
 *
 * For more information, refer to the [Slots Context]({% slug state-update_slots_scheduler %}) article.
 */
export declare const SchedulerEditSlotFormItemContext: React_2.Context<SchedulerEditSlotFormItemContextType>;

/**
 * Specifies the result of the [useSchedulerEditSlotFormItemContext]({% slug api_scheduler_useschedulereditslotformitemcontext %}) and [SchedulerEditSlotFormItemContext]({% slug api_scheduler_schedulereditslotformitemcontext %}).
 */
export declare type SchedulerEditSlotFormItemContextType = [DataItem | null, (event?: any) => void];

/**
 * Represents the object which is returned from the `ref` callback of the [SchedulerEditSlot]({% slug api_scheduler_schedulereditslot %}).
 *
 * For more information about Refs, refer to the [React Refs & Dom](https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom) article.
 */
export declare interface SchedulerEditSlotHandle {
    props: SchedulerEditSlotProps;
}

/**
 * Represents the props of the KendoReact [SchedulerEditSlot]({% slug api_scheduler_schedulereditslot %}) component.
 */
export declare interface SchedulerEditSlotProps extends SchedulerViewSlotProps {
    /**
     * Overrides the default component responsible for view-specific functionality.
     *
     * The default Component is: [SchedulerViewSlot]({% slug api_scheduler_schedulerviewslot %}).
     */
    viewSlot?: React_2.ComponentType<SchedulerViewSlotProps>;
    /**
     * Overrides the default component responsible for visualizing the `formItem`.
     *
     * The default Component is: [SchedulerForm]({% slug api_scheduler_schedulerform %}).
     */
    form?: React_2.ComponentType<SchedulerFormProps>;
    /**
     * Setting this property will force the `formItem` to be in controlled state, allowing further customization.
     */
    formItem?: DataItem | null;
    /**
     * Called every time the `formItem` changes.
     */
    onFormItemChange?: (event: any) => void;
    /**
     * Called when new item has been created in the slot.
     */
    onDataAction?: (action: DataAction, event: any) => void;
}

/**
 * A [React Context](https://react.dev/reference/react/hooks#context-hooks) providing access to the [SchedulerEditSlot]({% slug api_scheduler_schedulereditslot %}) `props`.
 *
 * For more information, refer to the [Items Context]({% slug state-update_items_scheduler %}) article.
 */
export declare const SchedulerEditSlotPropsContext: React_2.Context<SchedulerEditSlotProps>;

/**
 * Specifies the result of the [useSchedulerEditSlotPropsContext]({% slug api_scheduler_useschedulereditslotpropscontext %}) and [SchedulerEditSlotPropsContext]({% slug api_scheduler_schedulereditslotpropscontext %}).
 */
export declare type SchedulerEditSlotPropsContextType = SchedulerEditSlotProps;

/**
 * Represents the default `editTask` component rendered by the [KendoReact Scheduler component]({% slug overview_scheduler %}).
 *
 * This is a composite component of the [`SchedulerViewTask`]({% slug api_scheduler_schedulerviewtask %}), extending it to provide the `remove` editing functionality.
 */
export declare const SchedulerEditTask: React_2.ForwardRefExoticComponent<SchedulerEditTaskProps & React_2.RefAttributes<SchedulerEditTaskHandle>>;

export declare const schedulerEditTaskDefaultProps: {
    viewTask: React_2.ForwardRefExoticComponent<SchedulerViewTaskProps & React_2.RefAttributes<SchedulerViewTaskHandle_2>>;
    occurrenceDialog: React_2.ForwardRefExoticComponent<SchedulerOccurrenceDialogProps & React_2.RefAttributes<SchedulerOccurrenceDialogHandle_2 | null>>;
    removeDialog: React_2.ForwardRefExoticComponent<SchedulerRemoveDialogProps & React_2.RefAttributes<SchedulerRemoveDialogHandle_2 | null>>;
};

/**
 * Represents the object which is returned from the `ref` callback of the [SchedulerEditTask]({% slug api_scheduler_scheduleredittask %}).
 *
 * For more information about Refs, refer to the [React Refs & Dom](https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom) article.
 */
export declare interface SchedulerEditTaskHandle {
    element: HTMLDivElement | null;
    props: SchedulerEditTaskProps;
}

/**
 * Represents the props of the KendoReact [SchedulerEditTask]({% slug api_scheduler_scheduleredittask %}) component.
 */
export declare interface SchedulerEditTaskProps extends SchedulerViewTaskProps {
    /**
     * Overrides the default component responsible for positioning the task inside the view.
     *
     * The default Component is: [SchedulerViewTask]({% slug api_scheduler_schedulerviewtask %}).
     */
    viewTask?: React_2.ComponentType<SchedulerViewTaskProps>;
    /**
     * Overrides the default component responsible for visualizing the `removeItem` and confirming the `remove` action.
     *
     * The default Component is: [SchedulerRemoveDialog]({% slug api_scheduler_schedulerremovedialog %}).
     */
    removeDialog?: React_2.ComponentType<SchedulerRemoveDialogProps>;
    /**
     * Setting this property will force the `showRemoveDialog` to be in controlled state, allowing further control over the display of the `removeDialog` component.
     */
    showRemoveDialog?: boolean;
    /**
     * Called every time the `showRemoveDialog` changes.
     */
    onShowRemoveDialogChange?: (event: any) => void;
    /**
     * Setting this property will force the `removeItem` to be in controlled state, allowing further customization.
     *
     * Specifies the DataItem which should be removed from the `data` set.
     * The `removeItem` is passed as property to the `removeDialog` component;
     */
    removeItem?: DataItem | null;
    /**
     * Called every time the `removeItem` changes.
     */
    onRemoveItemChange?: (event: any) => void;
    /**
     * Overrides the default component responsible for the selection between `occurrence` and `series` delete.
     *
     * The default Component is: [SchedulerOccurrenceDialog]({% slug api_scheduler_scheduleroccurrencedialog %}).
     */
    occurrenceDialog?: React_2.ComponentType<SchedulerOccurrenceDialogProps>;
    /**
     * Setting this property will force the `showOccurrenceDialog` to be in controlled state, allowing further control over the display of the `occurrenceDialog` component.
     */
    showOccurrenceDialog?: boolean;
    /**
     * Called every time the `showOccurrenceDialog` changes.
     */
    onShowOccurrenceDialogChange?: (event: any) => void;
    /**
     * Called when the item has been removed.
     */
    onDataAction?: (action: DataAction, event?: any) => void;
}

/**
 * A [React Context](https://react.dev/reference/react/hooks#context-hooks) providing access to the combined default and custom [modelFields]({% slug api_scheduler_schedulerprops %}#toc-modelfields) of the Scheduler.
 *
 * For more information, refer to the [Scheduler Context]({% slug context_scheduler %}) article.
 */
export declare const SchedulerFieldsContext: React_2.Context<Fields>;

/**
 * Specifies the result of the [useSchedulerFieldsContext]({% slug api_scheduler_useschedulerfieldscontext %}) and [SchedulerFieldsContext]({% slug api_scheduler_schedulerfieldscontext %}).
 */
export declare type SchedulerFieldsContextType = Fields;

/**
 * Represents the default `footer` component rendered by the [KendoReact Scheduler component]({% slug overview_scheduler %}).
 */
export declare const SchedulerFooter: React_2.ForwardRefExoticComponent<SchedulerFooterProps & React_2.RefAttributes<SchedulerFooterHandle>>;

/**
 * Represents the object which is returned from the `ref` callback of the [SchedulerFooter]({% slug api_scheduler_schedulerfooter %}).
 *
 * For more information about Refs, refer to the [React Refs & Dom](https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom) article.
 */
export declare interface SchedulerFooterHandle {
    element: HTMLDivElement | null;
    props: SchedulerFooterProps;
}

/**
 * Represents the props of the KendoReact [SchedulerFooter]({% slug api_scheduler_schedulerfooter %}) component.
 */
export declare interface SchedulerFooterProps extends ToolbarProps {
    children?: React_2.ReactNode;
}

/**
 * Represents the default `form` component rendered by the [SchedulerEditItem]({% slug api_scheduler_scheduleredititem %}) and [SchedulerEditSlot]({% slug api_scheduler_schedulereditslot %}) components.
 *
 * Accepts [SchedulerFormProps]({ slug api_scheduler_schedulerformprops }) properties and provide [SchedulerFormHandle]({% slug api_scheduler_schedulerformhandle %}) `ref` callback.
 */
export declare const SchedulerForm: React_2.ForwardRefExoticComponent<SchedulerFormProps & React_2.RefAttributes<SchedulerFormHandle | null>>;

export declare const schedulerFormDefaultProps: {
    dialog: React_2.ForwardRefExoticComponent<DialogProps & React_2.RefAttributes<DialogHandle | null>>;
    validator: () => {};
};

/**
 * The default `editor` used inside the [`SchedulerForm`]({% slug api_scheduler_schedulerform %}) component.
 *
 * For the full list of the props available for this component, please refer to the [SchedulerFormEditorProps]({% slug api_scheduler_schedulerformeditorprops %}).
 */
export declare const SchedulerFormEditor: React_2.ForwardRefExoticComponent<globalThis.Omit<SchedulerFormEditorProps, "ref"> & React_2.RefAttributes<SchedulerFormEditorHandle | null>>;

export declare const schedulerFormEditorDefaultProps: {
    as: React_2.ForwardRefExoticComponent<globalThis.Omit<FormElementProps, "ref"> & React_2.RefAttributes<FormElementHandle>>;
    titleLabel: {
        (props: LabelProps): JSX.Element;
        propTypes: {
            id: Requireable<string>;
            editorId: Requireable<string>;
            editorRef: Requireable<NonNullable<((...args: any[]) => any) | InferProps<    {
            current: Requireable<any>;
            }> | null | undefined>>;
            editorValid: Requireable<boolean>;
            editorDisabled: Requireable<boolean>;
            style: Requireable<object>;
            className: Requireable<string>;
            optional: Requireable<boolean>;
        };
        displayName: string;
    };
    titleError: {
        (props: ErrorProps): JSX.Element;
        propTypes: {
            id: Requireable<string>;
            direction: Requireable<string>;
            children: Requireable<NonNullable<ReactNodeLike>>;
            style: Requireable<object>;
            className: Requireable<string>;
        };
        displayName: string;
    };
    titleEditor: React_2.ForwardRefExoticComponent<InputProps & React_2.RefAttributes<InputHandle | null>>;
    startLabel: {
        (props: LabelProps): JSX.Element;
        propTypes: {
            id: Requireable<string>;
            editorId: Requireable<string>;
            editorRef: Requireable<NonNullable<((...args: any[]) => any) | InferProps<    {
            current: Requireable<any>;
            }> | null | undefined>>;
            editorValid: Requireable<boolean>;
            editorDisabled: Requireable<boolean>;
            style: Requireable<object>;
            className: Requireable<string>;
            optional: Requireable<boolean>;
        };
        displayName: string;
    };
    startError: {
        (props: ErrorProps): JSX.Element;
        propTypes: {
            id: Requireable<string>;
            direction: Requireable<string>;
            children: Requireable<NonNullable<ReactNodeLike>>;
            style: Requireable<object>;
            className: Requireable<string>;
        };
        displayName: string;
    };
    startEditor: (props: ZonedDateTimeProps) => JSX.Element;
    startTimezoneLabel: {
        (props: LabelProps): JSX.Element;
        propTypes: {
            id: Requireable<string>;
            editorId: Requireable<string>;
            editorRef: Requireable<NonNullable<((...args: any[]) => any) | InferProps<    {
            current: Requireable<any>;
            }> | null | undefined>>;
            editorValid: Requireable<boolean>;
            editorDisabled: Requireable<boolean>;
            style: Requireable<object>;
            className: Requireable<string>;
            optional: Requireable<boolean>;
        };
        displayName: string;
    };
    startTimezoneError: {
        (props: ErrorProps): JSX.Element;
        propTypes: {
            id: Requireable<string>;
            direction: Requireable<string>;
            children: Requireable<NonNullable<ReactNodeLike>>;
            style: Requireable<object>;
            className: Requireable<string>;
        };
        displayName: string;
    };
    startTimezoneEditor: (props: FieldRenderProps & ComboBoxProps) => JSX.Element;
    startTimezoneCheckedLabel: {
        (props: LabelProps): JSX.Element;
        propTypes: {
            id: Requireable<string>;
            editorId: Requireable<string>;
            editorRef: Requireable<NonNullable<((...args: any[]) => any) | InferProps<    {
            current: Requireable<any>;
            }> | null | undefined>>;
            editorValid: Requireable<boolean>;
            editorDisabled: Requireable<boolean>;
            style: Requireable<object>;
            className: Requireable<string>;
            optional: Requireable<boolean>;
        };
        displayName: string;
    };
    startTimezoneCheckedEditor: React_2.ForwardRefExoticComponent<CheckboxProps & React_2.RefAttributes<CheckboxHandle | null>>;
    endLabel: {
        (props: LabelProps): JSX.Element;
        propTypes: {
            id: Requireable<string>;
            editorId: Requireable<string>;
            editorRef: Requireable<NonNullable<((...args: any[]) => any) | InferProps<    {
            current: Requireable<any>;
            }> | null | undefined>>;
            editorValid: Requireable<boolean>;
            editorDisabled: Requireable<boolean>;
            style: Requireable<object>;
            className: Requireable<string>;
            optional: Requireable<boolean>;
        };
        displayName: string;
    };
    endError: {
        (props: ErrorProps): JSX.Element;
        propTypes: {
            id: Requireable<string>;
            direction: Requireable<string>;
            children: Requireable<NonNullable<ReactNodeLike>>;
            style: Requireable<object>;
            className: Requireable<string>;
        };
        displayName: string;
    };
    endEditor: (props: ZonedDateTimeProps) => JSX.Element;
    endTimezoneLabel: {
        (props: LabelProps): JSX.Element;
        propTypes: {
            id: Requireable<string>;
            editorId: Requireable<string>;
            editorRef: Requireable<NonNullable<((...args: any[]) => any) | InferProps<    {
            current: Requireable<any>;
            }> | null | undefined>>;
            editorValid: Requireable<boolean>;
            editorDisabled: Requireable<boolean>;
            style: Requireable<object>;
            className: Requireable<string>;
            optional: Requireable<boolean>;
        };
        displayName: string;
    };
    endTimezoneError: {
        (props: ErrorProps): JSX.Element;
        propTypes: {
            id: Requireable<string>;
            direction: Requireable<string>;
            children: Requireable<NonNullable<ReactNodeLike>>;
            style: Requireable<object>;
            className: Requireable<string>;
        };
        displayName: string;
    };
    endTimezoneEditor: (props: FieldRenderProps & ComboBoxProps) => JSX.Element;
    endTimezoneCheckedLabel: {
        (props: LabelProps): JSX.Element;
        propTypes: {
            id: Requireable<string>;
            editorId: Requireable<string>;
            editorRef: Requireable<NonNullable<((...args: any[]) => any) | InferProps<    {
            current: Requireable<any>;
            }> | null | undefined>>;
            editorValid: Requireable<boolean>;
            editorDisabled: Requireable<boolean>;
            style: Requireable<object>;
            className: Requireable<string>;
            optional: Requireable<boolean>;
        };
        displayName: string;
    };
    endTimezoneCheckedEditor: React_2.ForwardRefExoticComponent<CheckboxProps & React_2.RefAttributes<CheckboxHandle | null>>;
    allDayLabel: {
        (props: LabelProps): JSX.Element;
        propTypes: {
            id: Requireable<string>;
            editorId: Requireable<string>;
            editorRef: Requireable<NonNullable<((...args: any[]) => any) | InferProps<    {
            current: Requireable<any>;
            }> | null | undefined>>;
            editorValid: Requireable<boolean>;
            editorDisabled: Requireable<boolean>;
            style: Requireable<object>;
            className: Requireable<string>;
            optional: Requireable<boolean>;
        };
        displayName: string;
    };
    allDayEditor: React_2.ForwardRefExoticComponent<CheckboxProps & React_2.RefAttributes<CheckboxHandle | null>>;
    recurrenceEditor: React_2.FunctionComponent<RecurrenceEditorProps>;
    descriptionLabel: {
        (props: LabelProps): JSX.Element;
        propTypes: {
            id: Requireable<string>;
            editorId: Requireable<string>;
            editorRef: Requireable<NonNullable<((...args: any[]) => any) | InferProps<    {
            current: Requireable<any>;
            }> | null | undefined>>;
            editorValid: Requireable<boolean>;
            editorDisabled: Requireable<boolean>;
            style: Requireable<object>;
            className: Requireable<string>;
            optional: Requireable<boolean>;
        };
        displayName: string;
    };
    descriptionEditor: React_2.ForwardRefExoticComponent<TextAreaProps & React_2.RefAttributes<TextAreaHandle | null>>;
    descriptionError: {
        (props: ErrorProps): JSX.Element;
        propTypes: {
            id: Requireable<string>;
            direction: Requireable<string>;
            children: Requireable<NonNullable<ReactNodeLike>>;
            style: Requireable<object>;
            className: Requireable<string>;
        };
        displayName: string;
    };
    resourceLabel: {
        (props: LabelProps): JSX.Element;
        propTypes: {
            id: Requireable<string>;
            editorId: Requireable<string>;
            editorRef: Requireable<NonNullable<((...args: any[]) => any) | InferProps<    {
            current: Requireable<any>;
            }> | null | undefined>>;
            editorValid: Requireable<boolean>;
            editorDisabled: Requireable<boolean>;
            style: Requireable<object>;
            className: Requireable<string>;
            optional: Requireable<boolean>;
        };
        displayName: string;
    };
    resourceEditor: (props: ResourceEditorProps) => JSX.Element;
};

/**
 * Represents the `ref` of the SchedulerFormEditor component.
 */
export declare interface SchedulerFormEditorHandle {
    element: any;
    props: SchedulerFormEditorProps;
}

/**
 * Represents the props of the KendoReact `SchedulerFormEditor` component.
 */
export declare interface SchedulerFormEditorProps extends Omit_2<FormElementProps, 'children'>, FormRenderProps {
    /** @hidden */
    as?: React_2.ComponentType<SchedulerFormEditorProps>;
    /**
     * Specifies the `id` attribute of the root element.
     */
    id?: string;
    /**
     * Specifies the `tabIndex` attribute of the root element.
     */
    tabIndex?: number;
    /**
     * Overrides the component used for visualizing the `title` field label.
     * The [KendoReact Label]({% slug label_labels %}) component is used, by default.
     *
     * For more information, please refer to the [`Scheduler Form Editor Customization`]({% slug overview_customization_form_editor_scheduler %}) article.
     */
    titleLabel?: React_2.ComponentType<LabelProps & FieldProps>;
    /**
     * Overrides the component used for visualizing the `title` field error.
     * The [KendoReact Error]({% slug error_labels %}) component is used, by default.
     *
     * For more information, please refer to the [`Scheduler Form Editor Customization`]({% slug overview_customization_form_editor_scheduler %}) article.
     */
    titleError?: React_2.ComponentType<LabelProps & FieldProps>;
    /**
     * Overrides the component used for visualizing the `title` field editor.
     * The [KendoReact Input]({% slug overview_input %}) component is used, by default.
     *
     * For more information, please refer to the [`Scheduler Form Editor Customization`]({% slug overview_customization_form_editor_scheduler %}) article.
     */
    titleEditor?: React_2.ComponentType<TargetlessChangeEvent<InputProps & FieldProps, string>>;
    /**
     * Overrides the component used for visualizing the `start` field label.
     * The [KendoReact Label]({% slug label_labels %}) component is used, by default.
     *
     * For more information, please refer to the [`Scheduler Form Editor Customization`]({% slug overview_customization_form_editor_scheduler %}) article.
     */
    startLabel?: React_2.ComponentType<LabelProps & FieldProps>;
    /**
     * Overrides the component used for visualizing the `start` field error.
     * The [KendoReact Error]({% slug error_labels %}) component is used, by default.
     *
     * For more information, please refer to the [`Scheduler Form Editor Customization`]({% slug overview_customization_form_editor_scheduler %}) article.
     */
    startError?: React_2.ComponentType<ErrorProps & FieldProps>;
    /**
     * Overrides the component used for visualizing the `start` field editor.
     * The [KendoReact DatePicker]({% slug overview_datepicker %}) or [KendoReact DateTimePicker]({% slug overview_datetimepicker %}) component is used by default depending on the `allDay` field value.
     *
     * For more information, please refer to the [`Scheduler Form Editor Customization`]({% slug overview_customization_form_editor_scheduler %}) article.
     */
    startEditor?: React_2.ComponentType<TargetlessChangeEvent<ZonedDateTimeProps & FieldProps, Date>>;
    /**
     * Overrides the component used for visualizing the `start timezone` field label.
     * The [KendoReact Label]({% slug label_labels %}) component is used, by default.
     *
     * For more information, please refer to the [`Scheduler Form Editor Customization`]({% slug overview_customization_form_editor_scheduler %}) article.
     */
    startTimezoneLabel?: React_2.ComponentType<LabelProps & FieldProps>;
    /**
     * Overrides the component used for visualizing the `start timezone` field error.
     * The [KendoReact Error]({% slug error_labels %}) component is used, by default.
     *
     * For more information, please refer to the [`Scheduler Form Editor Customization`]({% slug overview_customization_form_editor_scheduler %}) article.
     */
    startTimezoneError?: React_2.ComponentType<ErrorProps & FieldProps>;
    /**
     * Overrides the component used for visualizing the `start timezone` field editor.
     * An extended [KendoReact ComboBox]({% slug overview_combobox %}) component is used, by default.
     *
     * For more information, please refer to the [`Scheduler Form Editor Customization`]({% slug overview_customization_form_editor_scheduler %}) article.
     */
    startTimezoneEditor?: React_2.ComponentType<TargetlessChangeEvent<ComboBoxProps & FieldProps, string>>;
    /**
     * Overrides the component used for visualizing the `start timezone checked` label.
     * The [KendoReact Label]({% slug label_labels %}) component is used, by default.
     *
     * For more information, please refer to the [`Scheduler Form Editor Customization`]({% slug overview_customization_form_editor_scheduler %}) article.
     */
    startTimezoneCheckedLabel?: React_2.ComponentType<LabelProps>;
    /**
     * Overrides the component used for visualizing the `start timezone checked` editor.
     * The [KendoReact Checkbox]({% slug overview_checkbox %}) component is used, by default.
     *
     * For more information, please refer to the [`Scheduler Form Editor Customization`]({% slug overview_customization_form_editor_scheduler %}) article.
     */
    startTimezoneCheckedEditor?: React_2.ComponentType<TargetlessChangeEvent<CheckboxProps, boolean>>;
    /**
     * Overrides the component used for visualizing the `end` field label.
     * The [KendoReact Label]({% slug label_labels %}) component is used, by default.
     *
     * For more information, please refer to the [`Scheduler Form Editor Customization`]({% slug overview_customization_form_editor_scheduler %}) article.
     */
    endLabel?: React_2.ComponentType<LabelProps & FieldProps>;
    /**
     * Overrides the component used for visualizing the `end` field error.
     * The [KendoReact Error]({% slug error_labels %}) component is used, by default.
     *
     * For more information, please refer to the [`Scheduler Form Editor Customization`]({% slug overview_customization_form_editor_scheduler %}) article.
     */
    endError?: React_2.ComponentType<ErrorProps & FieldProps>;
    /**
     * Overrides the component used for visualizing the `end` field editor.
     * The [KendoReact DatePicker]({% slug overview_datepicker %}) or [KendoReact DateTimePicker]({% slug overview_datetimepicker %}) component is used by default depending on the `allDay` field value.
     *
     * For more information, please refer to the [`Scheduler Form Editor Customization`]({% slug overview_customization_form_editor_scheduler %}) article.
     */
    endEditor?: React_2.ComponentType<TargetlessChangeEvent<ZonedDateTimeProps & FieldProps, Date>>;
    /**
     * Overrides the component used for visualizing the `end timezone` field label.
     * The [KendoReact Label]({% slug label_labels %}) component is used, by default.
     *
     * For more information, please refer to the [`Scheduler Form Editor Customization`]({% slug overview_customization_form_editor_scheduler %}) article.
     */
    endTimezoneLabel?: React_2.ComponentType<LabelProps>;
    /**
     * Overrides the component used for visualizing the `end timezone` field error.
     * The [KendoReact Error]({% slug error_labels %}) component is used, by default.
     *
     * For more information, please refer to the [`Scheduler Form Editor Customization`]({% slug overview_customization_form_editor_scheduler %}) article.
     */
    endTimezoneError?: React_2.ComponentType<ErrorProps>;
    /**
     * Overrides the component used for visualizing the `end timezone` field editor.
     * An extended [KendoReact ComboBox]({% slug overview_combobox %}) component is used, by default.
     *
     * For more information, please refer to the [`Scheduler Form Editor Customization`]({% slug overview_customization_form_editor_scheduler %}) article.
     */
    endTimezoneEditor?: React_2.ComponentType<TargetlessChangeEvent<ComboBoxProps, string>>;
    /**
     * Overrides the component used for visualizing the `start timezone checked` label.
     * The [KendoReact Label]({% slug label_labels %}) component is used, by default.
     *
     * For more information, please refer to the [`Scheduler Form Editor Customization`]({% slug overview_customization_form_editor_scheduler %}) article.
     */
    endTimezoneCheckedLabel?: React_2.ComponentType<LabelProps>;
    /**
     * Overrides the component used for visualizing the `end timezone checked` editor.
     * The [KendoReact Checkbox]({% slug overview_checkbox %}) component is used, by default.
     *
     * For more information, please refer to the [`Scheduler Form Editor Customization`]({% slug overview_customization_form_editor_scheduler %}) article.
     */
    endTimezoneCheckedEditor?: React_2.ComponentType<TargetlessChangeEvent<CheckboxProps, boolean>>;
    /**
     * Overrides the component used for visualizing the `allDay` field label.
     * The [KendoReact Label]({% slug label_labels %}) component is used, by default.
     *
     * For more information, please refer to the [`Scheduler Form Editor Customization`]({% slug overview_customization_form_editor_scheduler %}) article.
     */
    allDayLabel?: React_2.ComponentType<LabelProps & FieldProps>;
    /**
     * Overrides the component used for visualizing the `allDay` field editor.
     * The [KendoReact Checkbox]({% slug overview_checkbox %}) component is used, by default.
     *
     * For more information, please refer to the [`Scheduler Form Editor Customization`]({% slug overview_customization_form_editor_scheduler %}) article.
     */
    allDayEditor?: React_2.ComponentType<TargetlessChangeEvent<CheckboxProps & FieldProps, boolean>>;
    /**
     * Overrides the component used for visualizing the `recurrenceRule` field editor.
     * A custom made RecurrenceEditor component is used, by default.
     *
     * > We're planing on releasing the `RecurrenceEditor` as a standalone component in the future.
     *
     * For more information, please refer to the [`Scheduler Form Editor Customization`]({% slug overview_customization_form_editor_scheduler %}) article.
     */
    recurrenceEditor?: React_2.ComponentType<TargetlessChangeEvent<FieldProps, string>>;
    /**
     * Overrides the component used for visualizing the `description` field label.
     * The [KendoReact Label]({% slug label_labels %}) component is used, by default.
     *
     * For more information, please refer to the [`Scheduler Form Editor Customization`]({% slug overview_customization_form_editor_scheduler %}) article.
     */
    descriptionLabel?: React_2.ComponentType<LabelProps & FieldProps>;
    /**
     * Overrides the component used for visualizing the `description` field error.
     * The [KendoReact Error]({% slug error_labels %}) component is used, by default.
     *
     * For more information, please refer to the [`Scheduler Form Editor Customization`]({% slug overview_customization_form_editor_scheduler %}) article.
     */
    descriptionError?: React_2.ComponentType<ErrorProps & FieldProps>;
    /**
     * Overrides the component used for visualizing the `description` field editor.
     * The [KendoReact TextArea]({% slug overview_textarea %}) component is used, by default.
     *
     * For more information, please refer to the [`Scheduler Form Editor Customization`]({% slug overview_customization_form_editor_scheduler %}) article.
     */
    descriptionEditor?: React_2.ComponentType<TargetlessChangeEvent<TextAreaProps & FieldProps, string>>;
    /**
     * Overrides the component used for visualizing the `start timezone checked` field label.
     * The [KendoReact Label]({% slug label_labels %}) component is used, by default.
     *
     * For more information, please refer to the [`Scheduler Form Editor Customization`]({% slug overview_customization_form_editor_scheduler %}) article.
     */
    resourceLabel?: React_2.ComponentType<LabelProps & FieldProps>;
    /**
     * Overrides the component used for visualizing each `resources` field error.
     * The [KendoReact Error]({% slug error_labels %}) component is used, by default.
     *
     * For more information, please refer to the [`Scheduler Form Editor Customization`]({% slug overview_customization_form_editor_scheduler %}) article.
     */
    resourcesError?: React_2.ComponentType<ErrorProps & FieldProps>;
    /**
     * Overrides the component used for visualizing each `resource` field editor.
     * An extended KendoReact [MultiSelect]({% slug overview_multiselect %}) or [DropDownList]({% slug overview_dropdownlist %}) component is used by default, depending on the `multiple` field of each individual `resource`.
     *
     * For more information, please refer to the [`Scheduler Form Editor Customization`]({% slug overview_customization_form_editor_scheduler %}) article.
     */
    resourceEditor?: React_2.ComponentType<TargetlessChangeEvent<(MultiSelectProps | DropDownListProps) & FieldProps, any>>;
}

/**
 * Represent the `ref` of the SchedulerForm component.
 */
export declare interface SchedulerFormHandle {
    /**
     * Represents the properties passed to the current instance of the `SchedulerForm`.
     */
    props: SchedulerFormProps;
}

/**
 * Represents the props of the KendoReact [SchedulerForm]({% slug api_scheduler_schedulerform %}) component.
 */
export declare interface SchedulerFormProps extends Omit_2<FormProps, 'render' | 'onSubmit'> {
    /**
     * Specifies the `dataItem` to be visualized inside the form.
     */
    dataItem: DataItem;
    /**
     * The Form content that will be rendered. The default rendering includes a `dialog` and `editor`.
     *
     * For more information about customizing some parts of the default rendering please refer to the [SchedulerForm Customization]({% slug overview_customization_form_scheduler %}) article.
     */
    render?: (props: FormRenderProps) => any;
    /**
     * Called when the `cancel` button is clicked.
     */
    onCancel?: (event: SchedulerFormStateChangeEvent<null>) => void;
    /**
     * Called when the `close` button is clicked.
     */
    onClose?: (event: SchedulerFormStateChangeEvent<null>) => void;
    /**
     * Called when the `submit` button is clicked.
     */
    onSubmit: (event: SchedulerFormStateChangeEvent<any>) => void;
    /**
     * Overrides the component used for visualizing the `editor`.
     * The [SchedulerFormEditor]({% slug api_scheduler_schedulerformeditor %}) component is used, by default.
     *
     * For more information, please refer to the [`Scheduler Form Customization`]({% slug overview_customization_form_scheduler %}) article.
     */
    editor?: React_2.ComponentType<SchedulerFormEditorProps>;
    /**
     * Overrides the component used for visualizing the `dialog`.
     * The [KendoReact Dialog]({% slug api_dialogs_dialog %}) component is used, by default.
     *
     * For more information, please refer to the [`Scheduler Form Customization`]({% slug overview_customization_form_scheduler %}) article.
     */
    dialog?: React_2.ComponentType<DialogProps>;
}

export declare interface SchedulerFormStateChangeEvent<T> {
    target: SchedulerFormHandle;
    value: T;
    syntheticEvent: React_2.SyntheticEvent;
}

/**
 * An interface for the Scheduler groups.
 */
export declare interface SchedulerGroup {
    /**
     * An array of the resource names that will be grouped.
     */
    resources: string[];
    /**
     * Specifies the orientation of the groups.
     */
    orientation: 'horizontal' | 'vertical';
}

/**
 * A [React Context](https://react.dev/reference/react/hooks#context-hooks) providing access to the Scheduler `Group` object, calculated based on the [group]({% slug api_scheduler_schedulerprops %}#toc-group) and [resources]({% slug api_scheduler_schedulerprops %}#toc-resources).
 *
 * For more information, refer to the [Scheduler Context]({% slug context_scheduler %}) article.
 */
export declare const SchedulerGroupsContext: React_2.Context<SchedulerGroupsContextType>;

/**
 * Specifies the result of the [useSchedulerGroupsContext]({% slug api_scheduler_useschedulergroupscontext %}) and [SchedulerGroupsContext]({% slug api_scheduler_schedulergroupscontext %}).
 */
export declare type SchedulerGroupsContextType = Group[];

/**
 * Represents the Object which is passed to the [`ref`](https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom) callback of the Scheduler component.
 */
export declare interface SchedulerHandle {
    props: SchedulerProps;
    element: HTMLDivElement | null;
}

/**
 * Represents the default `header` component rendered by the [KendoReact Scheduler component]({% slug overview_scheduler %}).
 */
export declare const SchedulerHeader: React_2.ForwardRefExoticComponent<SchedulerHeaderProps & React_2.RefAttributes<SchedulerHeaderHandle>>;

/**
 * Represents the object which is returned from the `ref` callback of the [SchedulerHeader]({% slug api_scheduler_schedulerheader %}).
 *
 * For more information about Refs, refer to the [React Refs & Dom](https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom) article.
 */
export declare interface SchedulerHeaderHandle {
    element: HTMLDivElement | null;
    props: SchedulerHeaderProps;
}

export declare interface SchedulerHeaderProps extends ToolbarProps {
    children?: React_2.ReactNode;
}

/**
 * Represents the default `item` component rendered by the [KendoReact Scheduler component]({% slug overview_scheduler %}).
 */
export declare const SchedulerItem: React_2.ForwardRefExoticComponent<SchedulerItemProps & React_2.RefAttributes<SchedulerItemHandle>>;

/**
 * A component which applies the necessary `className` for correct styling of child elements inside the [SchedulerItem]({% slug api_scheduler_scheduleritem %})
 */
export declare const SchedulerItemContent: React_2.ForwardRefExoticComponent<SchedulerItemContentProps & React_2.RefAttributes<HTMLDivElement>>;

/**
 * Represents the props of the [SchedulerItemContent]({% slug api_scheduler_scheduleritemcontent %}) component.
 * Extends the [native `div` props`](https://developer.mozilla.org/en-US/docs/Web/API/HTMLDivElement).
 */
export declare interface SchedulerItemContentProps extends React_2.HTMLAttributes<HTMLDivElement> {
}

/**
 * @hidden
 */
export declare interface SchedulerItemDragEvent {
    target: SchedulerItemHandle;
    dragEvent: ItemDragEvent;
}

/**
 * Represents the object passed to the `drag-item` reducer.
 */
export declare interface SchedulerItemDragItemAction {
    type: DRAG_ITEM_ACTION;
    payload?: DataItem;
}

/**
 * @hidden
 */
export declare interface SchedulerItemFocusEvent {
    target: SchedulerItemHandle;
    syntheticEvent: React.FocusEvent;
}

/** @hidden */
declare type SchedulerItemFormItemAction = {
    type: FORM_ITEM_ACTION;
    payload?: DataItem;
};

/**
 * Represents the object which is returned from the `ref` callback of the [SchedulerItem]({% slug api_scheduler_scheduleritem %}).
 *
 * For more information about Refs, refer to the [React Refs & Dom](https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom) article.
 */
export declare interface SchedulerItemHandle {
    element: HTMLDivElement | null;
    props: SchedulerItemProps;
    /** @hidden */
    _maxSiblingsPerSlot?: number | null;
    /** @hidden */
    _siblings?: SchedulerItemHandle[] | null;
    /** @hidden */
    _order?: number | null;
}

/**
 * @hidden
 */
export declare interface SchedulerItemKeyboardEvent {
    target: SchedulerItemHandle;
    syntheticEvent: React.KeyboardEvent;
}

/**
 * @hidden
 */
export declare interface SchedulerItemMouseEvent {
    target: SchedulerItemHandle;
    syntheticEvent: React.MouseEvent;
}

/**
 * Represents the props of the KendoReact [SchedulerItem]({% slug api_scheduler_scheduleritem %}) component.
 */
export declare interface SchedulerItemProps extends Item {
    /**
     * Specifies the `id` of the wrapping element of the SchedulerItem.
     */
    id?: string;
    /**
     * Specifies the `tabIndex` attribute of the wrapping element of the SchedulerItem.
     *
     * Providing `null` will not apply any `tabIndex` to the element.
     */
    tabIndex?: number | null;
    /**
     * Specifies the `className` attribute of the wrapping element of the SchedulerItem.
     *
     * The SchedulerItem applies the following default className:
     * - `k-event`
     * - `k-selected` - if `props.selected` is set to `true`
     * - `k-event-drag-hint` - if `props.dragHint` is set to `true`
     * - `k-scheduler-marquee` - if `props.resizeHint` is set to `true`
     * - `k-marquee`: if `props.resizeHint` is set to `true`
     * - `k-first`: if `props.resizeHint` is set to `true` and `props.tail` is set to `false`
     * - `k-last`: if `props.resizeHint` is set to `true` and `props.head` is set to `false`
     */
    className?: string;
    /**
     * Specifies the `style` object of the wrapping element of the SchedulerItem.
     *
     * The SchedulerItem applies the following default styles:
     *  - `cursor`: `pointer`
     *  - `userSelect`: `none`
     *  - `borderColor`: `props.color`
     *  - `borderColor`: `props.color`
     *  - `pointerEvents`: `none` - if `props.dragHint` or `props.resizeHint` is set to `true`
     */
    style?: React_2.CSSProperties;
    /**
     * Specifies the `children` of the SchedulerItem.
     *
     * Setting this property will override the default elements rendered by the SchedulerItem.
     */
    children?: React_2.ReactNode;
    /**
     * Overrides the `editable` prop of the `Scheduler` and the active view.
     */
    editable?: EditableProp | boolean;
    /**
     * Sets the selected state of the SchedulerSlot. By default the `k-selected` className is added if `props.selected` is `true`.
     */
    selected?: boolean;
    /**
     * Specifies the orientation of the SchedulerItem.
     */
    vertical?: boolean;
    /**
     * Returns true if it is the last item rendered in the current view.
     */
    isLast?: boolean;
    /**
     * Specifies if the current SchedulerItem is used as a DragHint.
     */
    dragHint?: boolean;
    /**
     * Specifies if the current SchedulerItem is used as a ResizeHint.
     */
    resizeHint?: boolean;
    /**
     * Specifies the `format` in which the `zonedStart` and `zonedEnd` properties are displayed.
     *
     * For more information, refer to the [formatDate]({% slug api_intl_intlservice %}#toc-formatdate) method of the [IntlService]({% slug overview_globalization %}).
     */
    format?: string;
    /**
     * Called each time the element, or any of its child elements, receive focus.
     */
    onFocus?: (event: SchedulerItemFocusEvent) => void;
    /**
     * Called each time the element, or any of its child elements, lose focus.
     */
    onBlur?: (event: SchedulerItemFocusEvent) => void;
    /**
     * Called each time the element, or any of its child elements resceives `mousedown` event.
     */
    onMouseDown?: (event: SchedulerItemMouseEvent) => void;
    /**
     * Called each time the element, or any of its child elements resceives `mouseup` event.
     */
    onMouseUp?: (event: SchedulerItemMouseEvent) => void;
    /**
     * Called each time the element, or any of its child elements, is clicked.
     */
    onClick?: (event: SchedulerItemMouseEvent) => void;
    /**
     * Called each time the element, or any of its child elements receives `mouseenter` event.
     */
    onMouseEnter?: (event: SchedulerItemMouseEvent) => void;
    /**
     * Called each time the element, or any of its child elements receives `mouseleave` event.
     */
    onMouseLeave?: (event: SchedulerItemMouseEvent) => void;
    /**
     * Called each time the element, or any of its child elements receives `mouseover` event.
     */
    onMouseOver?: (event: SchedulerItemMouseEvent) => void;
    /**
     * Called each time the element, or any of its child elements receives `mouseout` event.
     */
    onMouseOut?: (event: SchedulerItemMouseEvent) => void;
    /**
     * Called each time the element, or any of its child elements, is double-clicked.
     */
    onDoubleClick?: (event: SchedulerItemMouseEvent) => void;
    /**
     * Called when the `delete` icon is clicked.
     *
     * The `delete` icon is rendered only when `props.editable` or `props.editable.remove` is `true`
     */
    onRemoveClick?: (event: SchedulerItemMouseEvent) => void;
    /**
     * Called each time a `keydown` event propagates to the wrapping element.
     */
    onKeyDown?: (event: SchedulerItemKeyboardEvent) => void;
    /**
     * Called each time a `keypress` event propagates to the wrapping element.
     */
    onKeyPress?: (event: SchedulerItemKeyboardEvent) => void;
    /**
     * Called each time a `keyup` event propagates to the wrapping element.
     */
    onKeyUp?: (event: SchedulerItemKeyboardEvent) => void;
    /**
     * Called each time the element receives a `press` event.
     *
     * This event is used by the [`Drag & Drop`]({% slug editing_scheduler %}) functionality of the SchedulerItem.
     * The SchedulerItem is using the [KendoReactDraggable]({% slug draggable_drag-and-drop %}) instead of the `onDragStart` callback.
     */
    onPress?: (event: SchedulerItemDragEvent) => void;
    /**
     * Called each time the element is dragged.
     *
     * This event is used by the [`Drag & Drop`]({% slug editing_scheduler %}) functionality of the SchedulerItem.
     * The SchedulerItem is using the [KendoReactDraggable]({% slug draggable_drag-and-drop %}) instead of the `onDrag` callback.
     */
    onDrag?: (event: SchedulerItemDragEvent) => void;
    /**
     * Called when the dragged element is being `released`.
     *
     * This event is used by the [`Drag & Drop`]({% slug editing_scheduler %}) functionality of the SchedulerItem.
     * The SchedulerItem is using the [KendoReactDraggable]({% slug draggable_drag-and-drop %}) instead of the `onDragEnd` callback.
     */
    onRelease?: (event: SchedulerItemDragEvent) => void;
    /**
     * Called each time the any of the resize handlers receives a `press` event.
     *
     * This event is used by the [`Resize`]({% slug editing_scheduler %}) functionality of the SchedulerItem.
     * The SchedulerItem is using the [KendoReactDraggable]({% slug draggable_drag-and-drop %}) instead of the `onDragStart` callback.
     */
    onResizePress?: (event: SchedulerItemDragEvent) => void;
    /**
     * Called each time the the resize handler responsible for the item `start` is being dragged.
     *
     * This event is used by the [`Resize`]({% slug editing_scheduler %}) functionality of the SchedulerItem.
     * The SchedulerItem is using the [KendoReactDraggable]({% slug draggable_drag-and-drop %}) instead of the `onDrag` callback.
     */
    onResizeStartDrag?: (event: SchedulerItemDragEvent) => void;
    /**
     * Called each time the the resize handler responsible for the item `end` is being dragged.
     *
     * This event is used by the [`Resize`]({% slug editing_scheduler %}) functionality of the SchedulerItem.
     * The SchedulerItem is using the [KendoReactDraggable]({% slug draggable_drag-and-drop %}) instead of the `onDrag` callback.
     */
    onResizeEndDrag?: (event: SchedulerItemDragEvent) => void;
    /**
     * Called when the dragged resize handler is being `released`
     *
     * This event is used by the [`Resize`]({% slug editing_scheduler %}) functionality of the SchedulerItem.
     * The SchedulerItem is using the [KendoReactDraggable]({% slug draggable_drag-and-drop %}) instead of the `onDragEnd` callback.
     */
    onResizeRelease?: (event: SchedulerItemDragEvent) => void;
    /** @hidden */
    _maxSiblingsPerSlot?: React_2.MutableRefObject<number | null>;
    /** @hidden */
    _siblings?: React_2.MutableRefObject<SchedulerItemHandle[] | null>;
    /** @hidden */
    _order?: React_2.MutableRefObject<number | null>;
}

/**
 * Represents the object passed to the `remove-item` reducer.
 */
export declare type SchedulerItemRemoveItemAction = {
    type: REMOVE_ITEM_ACTION;
    payload?: DataItem;
};

/**
 * Represents the object passed to the `resize-item` reducer.
 */
export declare interface SchedulerItemResizeItemAction {
    type: RESIZE_ITEM_ACTION;
    payload?: DataItem;
    event?: any;
}

/**
 * Represents the object passed to the `series` reducer.
 */
export declare type SchedulerItemSeriesAction = {
    type: SERIES_ACTION;
    payload?: boolean;
};

/**
 * Represents the object passed to the `items-focus` reducer.
 */
export declare interface SchedulerItemsFocusAction {
    type: ITEMS_FOCUS_ACTION;
    item?: React_2.RefObject<SchedulerItemHandle | null>;
    ignoreIsAllDay?: boolean;
}

/**
 * Represents the object passed to the `show-occurrence-dialog` reducer.
 */
export declare type SchedulerItemShowOccurrenceDialogAction = {
    type: SHOW_OCCURRENCE_DIALOG_ACTION;
    payload?: boolean;
};

/**
 * Represents the object passed to the `show-remove-dialog` reducer.
 */
export declare type SchedulerItemShowRemoveDialogAction = {
    type: SHOW_REMOVE_DIALOG_ACTION;
    payload?: boolean;
};

/**
 * Represents the object passed to the `items-select` reducer.
 */
export declare interface SchedulerItemsSelectAction {
    type: ITEMS_SELECT_ACTION;
    item?: React_2.RefObject<SchedulerItemHandle | null>;
    ignoreIsAllDay?: boolean;
}

/**
 * Defines the model fields that will be used for creating `SchedulerEvent` instances.
 */
export declare interface SchedulerModelFields {
    /**
     * The name of the `ID` model field.
     * Defaults to `"id"`.
     */
    id?: string;
    /**
     * The name of the start date model field.
     * Defaults to `"start"`.
     */
    start?: string;
    /**
     * The name of the start timezone model field.
     * Defaults to `"startTimezone"`.
     */
    startTimezone?: string;
    /** @hidden */
    originalStart?: string;
    /**
     * The name of the end date model field.
     * Defaults to `"end"`.
     */
    end?: string;
    /**
     * The name of the end timezone model field.
     * Defaults to `"endTimezone"`.
     */
    endTimezone?: string;
    /**
     * The name of the all-day flag model field.
     * Defaults to `"isAllDay"`.
     */
    isAllDay?: string;
    /**
     * The name of the title model field.
     * Defaults to `"title"`.
     */
    title?: string;
    /**
     * The name of the description model field.
     * Defaults to `"title"`.
     */
    description?: string;
    /**
     * The name of the recurrence model field.
     * Defaults to `"recurrenceRule"`.
     */
    recurrenceRule?: string;
    /**
     * The name of the recurrence ID model field.
     * Defaults to `"recurrenceId"`.
     */
    recurrenceId?: string;
    /**
     * The name of the recurrence exceptions model field.
     * Defaults to `"recurrenceExceptions"`.
     */
    recurrenceExceptions?: string;
}

/**
 * Represents the default `occurrenceDialog` component rendered by the [KendoReact SchedulerEditItem component]({% slug api_scheduler_scheduleredititem  %}).
 */
export declare const SchedulerOccurrenceDialog: React_2.ForwardRefExoticComponent<SchedulerOccurrenceDialogProps & React_2.RefAttributes<SchedulerOccurrenceDialogHandle | null>>;

/**
 * Represent the `ref` of the SchedulerOccurrenceDialog component.
 */
export declare type SchedulerOccurrenceDialogHandle = {
    props: SchedulerOccurrenceDialogProps;
};

/**
 * Represents the props of the KendoReact [SchedulerOccurrenceDialog]({% slug api_scheduler_scheduleroccurrencedialog %}) component.
 */
export declare interface SchedulerOccurrenceDialogProps {
    /**
     * Specifies the `DataItem` currently being edited.
     */
    dataItem: DataItem;
    /**
     * Specifies if the dialog is for `remove` or `edit` action.
     */
    isRemove?: boolean;
    /**
     * Called when the `close` button is clicked.
     */
    onClose: (event: SchedulerOccurrenceDialogStateChangeEvent<DataItem | null>) => void;
    /**
     * Called when the `series` button is clicked.
     */
    onSeriesClick: (event: SchedulerOccurrenceDialogStateChangeEvent<DataItem | null>) => void;
    /**
     * Called when the `occurrence` button is clicked.
     */
    onOccurrenceClick: (event: SchedulerOccurrenceDialogStateChangeEvent<DataItem | null>) => void;
}

export declare interface SchedulerOccurrenceDialogStateChangeEvent<T> {
    target: SchedulerOccurrenceDialogHandle;
    value: T;
    syntheticEvent: React_2.SyntheticEvent;
}

/**
 * A [React Context](https://react.dev/reference/react/hooks#context-hooks) providing access to the grouping orientation of the Scheduler.
 *
 * For more information, refer to the [Scheduler Context]({% slug context_scheduler %}) article.
 */
export declare const SchedulerOrientationContext: React_2.Context<Orientation>;

/**
 * Specifies the result of the [useSchedulerOrientationContext]({% slug api_scheduler_useschedulerorientationcontext %}) and [SchedulerOrientationContext]({% slug api_scheduler_schedulerorientationcontext %}).
 */
export declare type SchedulerOrientationContextType = Orientation;

/**
 * Represents a customized `viewItem` component which position itself proportionally to the duration of the item.
 *
 * This is a composite component of the [`SchedulerItem`]({% slug api_scheduler_scheduleritem %}), extending it to provide extended positioning inside a view.
 */
export declare const SchedulerProportionalViewItem: React_2.ForwardRefExoticComponent<SchedulerViewItemProps & React_2.RefAttributes<SchedulerViewItemHandle>>;

export declare const schedulerProportionalViewItemDefaultProps: {
    item: React_2.ForwardRefExoticComponent<SchedulerItemProps & React_2.RefAttributes<SchedulerItemHandle>>;
};

/**
 * Represents the props of the [KendoReact Scheduler component]({% slug overview_scheduler %}).
 */
export declare interface SchedulerProps {
    /**
     * Specifies the `id` of the wrapping element of the Scheduler.
     *
     * @example
     * ```jsx
     * <Scheduler id="my-scheduler" />
     * ```
     */
    id?: string;
    /**
     * Specifies the `tabIndex` attribute of the wrapping element of the Scheduler.
     *
     * @example
     * ```jsx
     * <Scheduler tabIndex={0} />
     * ```
     */
    tabIndex?: number;
    /**
     * Specifies the `role` attribute of the Scheduler wrapping element.
     *
     * For more information, refer to the [Scheduler Accessibility Compliance]({% slug accessibility_scheduler %}) article.
     *
     * @example
     * ```jsx
     * <Scheduler role="application" />
     * ```
     */
    role?: string;
    /**
     * The `aria-labelledby` attribute to be applied to the Scheduler component.
     *
     * For more information, refer to the [Scheduler Accessibility Compliance]({% slug accessibility_scheduler %}) article.
     *
     * @example
     * ```jsx
     * <Scheduler ariaLabelledby="scheduler-label" />
     * ```
     */
    ariaLabelledby?: string;
    /**
     * The `aria-label` attribute to be applied to the Scheduler component.
     *
     * For more information, refer to the [Scheduler Accessibility Compliance]({% slug accessibility_scheduler %}) article.
     *
     * @example
     * ```jsx
     * <Scheduler ariaLabel="Scheduler component" />
     * ```
     */
    ariaLabel?: string;
    /**
     * Specifies the `style` object of the wrapping element of the Scheduler.
     *
     * @example
     * ```jsx
     * <Scheduler style={{ height: '500px' }} />
     * ```
     */
    style?: React_2.CSSProperties;
    /**
     * Specifies the `className` attribute of the wrapping element of the Scheduler.
     *
     * @example
     * ```jsx
     * <Scheduler className="custom-scheduler" />
     * ```
     */
    className?: string;
    /**
     * Overrides the default item. Specifying the `item` property of a specific view will override this property.
     *
     * The default component is: [SchedulerItem]({% slug api_scheduler_scheduleritem %}).
     *
     * For more information on customizing the scheduler items, refer to the [Item Customization]({% slug overview_items_scheduler %}) article.
     *
     * @example
     * ```jsx
     * const CustomItem = (props) => <div>{props.title}</div>;
     * <Scheduler item={CustomItem} />
     * ```
     */
    item?: React_2.ComponentType<SchedulerItemProps>;
    /**
     * Overrides the default viewItem. Specifying the `viewItem` property of a specific view will override this property.
     *
     * The default component is: [SchedulerViewItem]({% slug api_scheduler_schedulerviewitem %}).
     *
     * For more information on customizing the scheduler items, refer to the [Item Customization]({% slug overview_items_scheduler %}) article.
     *
     * @example
     * ```jsx
     * const CustomViewItem = (props) => <div>{props.title}</div>;
     * <Scheduler viewItem={CustomViewItem} />
     * ```
     */
    viewItem?: React_2.ComponentType<SchedulerViewItemProps>;
    /**
     * Overrides the default editItem. Specifying the `editItem` property of a specific view will override this property.
     *
     * The default component is: [SchedulerEditItem]({% slug api_scheduler_scheduleredititem %}).
     *
     * For more information on customizing the scheduler items, refer to the [Item Customization]({% slug overview_items_scheduler %}) article.
     *
     * @example
     * ```jsx
     * const CustomEditItem = (props) => <div>{props.title}</div>;
     * <Scheduler editItem={CustomEditItem} />
     * ```
     */
    editItem?: React_2.ComponentType<SchedulerEditItemProps>;
    /**
     * Overrides the default task. Specifying the `task` property of a specific view will override this property.
     * Currently, the `task` is being used in the [AgendaView]({% slug agenda_view_scheduler %}) only.
     *
     * The default component is: [SchedulerTask]({% slug api_scheduler_schedulertask %}).
     *
     * For more information on customizing the scheduler tasks, refer to the [Task Customization]({% slug overview_tasks_scheduler %}) article.
     *
     * @example
     * ```jsx
     * const CustomTask = (props) => <div>{props.title}</div>;
     * <Scheduler task={CustomTask} />
     * ```
     */
    task?: React_2.ComponentType<SchedulerTaskProps>;
    /**
     * Overrides the default viewTask. Specifying the `viewTask` property of a specific view will override this property.
     * Currently, the `viewTask` is being used in the [AgendaView]({% slug agenda_view_scheduler %}) only.
     *
     * The default component is: [SchedulerViewTask]({% slug api_scheduler_schedulerviewtask %}).
     *
     * For more information on customizing the scheduler tasks, refer to the [Task Customization]({% slug overview_tasks_scheduler %}) article.
     *
     * @example
     * ```jsx
     * const CustomViewTask = (props) => <div>{props.title}</div>;
     * <Scheduler viewTask={CustomViewTask} />
     * ```
     */
    viewTask?: React_2.ComponentType<SchedulerTaskProps>;
    /**
     * Overrides the default editTask. Specifying the `editTask` property of a specific view will override this property.
     * Currently, the `editTask` is being used in the [AgendaView]({% slug agenda_view_scheduler %}) only.
     *
     * The default component is: [SchedulerEditTask]({% slug api_scheduler_scheduleredittask %}).
     *
     * For more information on customizing the scheduler tasks, refer to the [Task Customization]({% slug overview_tasks_scheduler %}) article.
     *
     * @example
     * ```jsx
     * const CustomEditTask = (props) => <div>{props.title}</div>;
     * <Scheduler editTask={CustomEditTask} />
     * ```
     */
    editTask?: React_2.ComponentType<SchedulerTaskProps>;
    /**
     * Overrides the default header component of the Scheduler.
     *
     * The default component is: [SchedulerHeader]({% slug api_scheduler_schedulerheader %}).
     *
     * For more information on customizing the scheduler header, refer to the [Header Customization]({% slug overview_header_footer_scheduler %}) article.
     *
     * @example
     * ```jsx
     * const CustomHeader = (props) => <div>Custom Header</div>;
     * <Scheduler header={CustomHeader} />
     * ```
     */
    header?: React_2.ComponentType<SchedulerHeaderProps>;
    /**
     * Overrides the default footer component of the Scheduler.
     *
     * The default component is: [SchedulerFooter]({% slug api_scheduler_schedulerfooter %}).
     *
     * For more information on customizing the scheduler footer, refer to the [Footer Customization]({% slug overview_header_footer_scheduler %}) article.
     *
     * @example
     * ```jsx
     * const CustomFooter = (props) => <div>Custom Footer</div>;
     * <Scheduler footer={CustomFooter} />
     * ```
     */
    footer?: React_2.ComponentType<SchedulerFooterProps>;
    /**
     * Overrides the default slot component. Specifying the `slot` property of a specific view will override this property.
     *
     * The default component is: [SchedulerSlot]({% slug api_scheduler_schedulerslot %}).
     *
     * For more information on customizing the scheduler slots, refer to the [Slot Customization]({% slug overview_slots_scheduler %}) article.
     *
     * @example
     * ```jsx
     * const CustomSlot = (props) => <div>{props.title}</div>;
     * <Scheduler slot={CustomSlot} />
     * ```
     */
    slot?: React_2.ComponentType<SchedulerSlotProps>;
    /**
     * Overrides the default viewSlot component. Specifying the `viewSlot` property of a specific view will override this property.
     *
     * The default component is: [SchedulerViewSlot]({% slug api_scheduler_schedulerviewslot %}).
     *
     * For more information on customizing the scheduler slots, refer to the [Slot Customization]({% slug overview_slots_scheduler %}) article.
     *
     * @example
     * ```jsx
     * const CustomViewSlot = (props) => <div>{props.title}</div>;
     * <Scheduler viewSlot={CustomViewSlot} />
     * ```
     */
    viewSlot?: React_2.ComponentType<SchedulerViewSlotProps>;
    /**
     * Overrides the default editSlot component. Specifying the `editSlot` property of a specific view will override this property.
     *
     * The default component is: [SchedulerEditSlot]({% slug api_scheduler_schedulereditslot %}).
     *
     * For more information on customizing the scheduler slots, refer to the [Slot Customization]({% slug overview_slots_scheduler %}) article.
     *
     * @example
     * ```jsx
     * const CustomEditSlot = (props) => <div>{props.title}</div>;
     * <Scheduler editSlot={CustomEditSlot} />
     * ```
     */
    editSlot?: React_2.ComponentType<SchedulerEditSlotProps>;
    /** @hidden */
    form?: React_2.ComponentType<SchedulerFormProps>;
    /**
     * Sets the currently selected view. The value is matched with the `name` property of the view.
     *
     * Sets the initially selected view. The available values are:
     * * `day`
     * * `week`
     * * `month`
     * * `agenda`
     * * `timeline`
     *
     * @example
     * ```jsx
     * <Scheduler view="day" />
     * ```
     */
    view?: string;
    /**
     * Sets the data of the Scheduler component. The data is then parsed and rendered as visual Scheduler items.
     *
     * @example
     * ```jsx
     * const data = [{ id: 1, title: 'Event', start: new Date(), end: new Date() }];
     * <Scheduler data={data} />
     * ```
     */
    data?: DataItem[];
    /**
     * Sets if the Scheduler component is editable. The value can be either a `boolean` or an Object to specify different types of editing.
     *
     * @example
     * ```jsx
     * <Scheduler editable={true} />
     * ```
     */
    editable?: EditableProp | boolean;
    /**
     * Sets the initially selected view.
     *
     * For more information refer to the [Scheduler Views]({% slug views_scheduler %}) article.
     *
     * Sets the initially selected view. The available values are:
     * * `day`
     * * `week`
     * * `month`
     * * `agenda`
     * * `timeline`
     *
     * @example
     * ```jsx
     * <Scheduler defaultView="week" />
     * ```
     */
    defaultView?: string;
    /**
     * Sets the current selected `Date`. The current selected date is passed to the selected view and transformed into a range.
     *
     * @example
     * ```jsx
     * <Scheduler date={new Date()} />
     * ```
     */
    date?: Date;
    /**
     * Sets a default selected `Date`. The `defaultDate` property is used to specify the initial rendered date, while still remaining in an uncontrolled mode.
     *
     * @example
     * ```jsx
     * <Scheduler defaultDate={new Date()} />
     * ```
     */
    defaultDate?: Date;
    /**
     * Force a `rtl` mode. For more information refer to [RTL Support]({% slug globalization_scheduler %}#toc-right-to-left-support).
     *
     * @example
     * ```jsx
     * <Scheduler rtl={true} />
     * ```
     */
    rtl?: boolean;
    /**
     * Sets the `height` of the Scheduler.
     *
     * @example
     * ```jsx
     * <Scheduler height={600} />
     * ```
     */
    height?: number | string;
    /**
     * Specify the available `view` components as `children` and the Scheduler will match the currently selected view and render it.
     *
     * @example
     * ```jsx
     * <Scheduler>
     *   <DayView />
     *   <WeekView />
     * </Scheduler>
     * ```
     */
    children?: SchedulerView[] | SchedulerView;
    /**
     * Specifies the id of the timezone that will be displayed in the Scheduler.
     * For example, `Europe/Sofia`.
     *
     * Defaults to `Etc/UTC`.
     *
     * @example
     * ```jsx
     * <Scheduler timezone="Europe/Sofia" />
     * ```
     */
    timezone?: string;
    /**
     * Specifies the groups of the Scheduler.
     *
     * @example
     * ```jsx
     * const group = { resources: ['Rooms'], orientation: 'horizontal' };
     * <Scheduler group={group} />
     * ```
     */
    group?: SchedulerGroup;
    /**
     * Specifies the resources of the Scheduler.
     *
     * @example
     * ```jsx
     * const resources = [{ name: 'Rooms', data: [{ text: 'Room 1', value: 1 }] }];
     * <Scheduler resources={resources} />
     * ```
     */
    resources?: SchedulerResource[];
    /**
     * The names of the model fields from which the Scheduler will read its data
     * ([see example]({% slug data_binding_scheduler %})).
     *
     * @example
     * ```jsx
     * const modelFields = { id: 'TaskID', start: 'Start', end: 'End' };
     * <Scheduler modelFields={modelFields} />
     * ```
     */
    modelFields?: SchedulerModelFields;
    /**
     * Called when new `date` is selected.
     *
     * @example
     * ```jsx
     * const handleDateChange = (args) => console.log(args.value);
     * <Scheduler onDateChange={handleDateChange} />
     * ```
     */
    onDateChange?: (args: SchedulerDateChangeEvent) => void;
    /**
     * Called when new `view` is selected. [(see example)]({% slug views_scheduler %}#toc-controlling-the-selected-view).
     *
     * @example
     * ```jsx
     * const handleViewChange = (args) => console.log(args.value);
     * <Scheduler onViewChange={handleViewChange} />
     * ```
     */
    onViewChange?: (args: SchedulerViewChangeEvent) => void;
    /**
     * Called each time when editing occurs.
     * To enable editing set the `editable` property to `true` or an [`EditableProp`]({% slug api_scheduler_editableprop %}).
     *
     * For more information refer to the [Scheduler Editing]({% slug editing_scheduler %}) article.
     *
     * @example
     * ```jsx
     * const handleDataChange = (event) => console.log(event);
     * <Scheduler onDataChange={handleDataChange} />
     * ```
     */
    onDataChange?: (event: SchedulerDataChangeEvent) => void;
}

/**
 * A [React Context](https://react.dev/reference/react/hooks#context-hooks) providing access to the [Scheduler]({% slug api_scheduler_scheduler %}) props.
 *
 * For more information, refer to the [Scheduler Context]({% slug context_scheduler %}) article.
 */
export declare const SchedulerPropsContext: React_2.Context<SchedulerProps>;

/**
 * Specifies the result of the [useSchedulerPropsContext]({% slug api_scheduler_useschedulerpropscontext %}) and [SchedulerPropsContext]({% slug api_scheduler_schedulerpropscontext %}).
 */
export declare type SchedulerPropsContextType = SchedulerProps;

/** @hidden */
export declare type SchedulerRange = (args: SchedulerRangeArgs) => DateRange;

/** @hidden */
export declare interface SchedulerRangeArgs {
    intl: IntlService;
    date: Date;
    numberOfDays?: any;
    timezone?: string;
}

/**
 * Represents the default `removeDialog` component rendered by the [KendoReact SchedulerEditItem component]({% slug api_scheduler_scheduleredititem  %}).
 */
export declare const SchedulerRemoveDialog: React_2.ForwardRefExoticComponent<SchedulerRemoveDialogProps & React_2.RefAttributes<SchedulerRemoveDialogHandle | null>>;

/**
 * Represent the `ref` of the SchedulerOccurrenceDialog component.
 */
export declare type SchedulerRemoveDialogHandle = {
    props: SchedulerRemoveDialogProps;
};

/**
 * Represents the props of the KendoReact [SchedulerRemoveDialog]({% slug api_scheduler_schedulerremovedialog %}) component.
 */
export declare interface SchedulerRemoveDialogProps {
    /**
     * Specifies the `DataItem` currently being deleted.
     */
    dataItem: DataItem;
    /**
     * Called when the `close` button is clicked.
     */
    onClose?: (event: SchedulerRemoveDialogStateChangeEvent<null>) => void;
    /**
     * Called when the `cancel` button is clicked.
     */
    onCancel?: (event: SchedulerRemoveDialogStateChangeEvent<null>) => void;
    /**
     * Called when the `confirm` button is clicked.
     */
    onConfirm?: (event: SchedulerRemoveDialogStateChangeEvent<DataItem | null>) => void;
}

export declare interface SchedulerRemoveDialogStateChangeEvent<T> {
    target: SchedulerRemoveDialogHandle;
    value: T;
    syntheticEvent: React_2.SyntheticEvent;
}

/**
 * Represents the default `resize` component rendered by the [KendoReact SchedulerEditItem component]().
 */
export declare const SchedulerResize: React_2.FunctionComponent<SchedulerResizeProps>;

export declare const schedulerResizeDefaultProps: {
    viewItem: React_2.ForwardRefExoticComponent<SchedulerViewItemProps & React_2.RefAttributes<SchedulerViewItemHandle_2>>;
    item: React_2.ForwardRefExoticComponent<SchedulerItemProps & React_2.RefAttributes<SchedulerItemHandle_2>>;
};

/**
 * Represents the props of the KendoReact [SchedulerResize]() component.
 */
export declare interface SchedulerResizeProps {
    /** @hidden */
    format?: string;
    /** @hidden */
    ignoreIsAllDay?: boolean;
    /**
     * Specifies the `DataItem` to be visualized as a Resize item.
     */
    dataItem: DataItem;
    /**
     * Specifies the orientation of the SchedulerItem inside the Drag.
     */
    vertical?: boolean;
    /**
     * Overrides the default component responsible for visualizing a single item.
     *
     * The default Component is: [SchedulerItem].
     */
    item?: React_2.ComponentType<SchedulerItemProps>;
    /**
     * Overrides the default component responsible for positioning the item inside the view.
     *
     * The default Component is: [SchedulerViewItem]().
     */
    viewItem?: React_2.ComponentType<SchedulerViewItemProps>;
}

/**
 * An interface for the resources of the Scheduler.
 */
export declare interface SchedulerResource {
    /**
     * The resource name. If not set, the value of the `field` option is used.
     */
    name?: string;
    /**
     * The field name of the event that contains the resource value.
     */
    field: string;
    /**
     * The resource data.
     */
    data: any[];
    /**
     * The field name from the data that contains the resource value.
     */
    valueField: string;
    /**
     * The field name from the data that contains the resource text.
     */
    textField: string;
    /**
     * The field name from the data that contains the resource color.
     */
    colorField?: string;
    /**
     * Specifies if the events have multiple resource values.
     */
    multiple?: boolean;
}

/**
 * Represents the default `slot` component rendered by the [KendoReact Scheduler component]({% slug overview_scheduler %}).
 */
export declare const SchedulerSlot: React_2.ForwardRefExoticComponent<SchedulerSlotProps & React_2.RefAttributes<SchedulerSlotHandle>>;

export declare const schedulerSlotDefaultProps: {
    isWorkHour: boolean;
    isWorkDay: boolean;
};

/**
 * Represents the extended `expandable` configuration of a `SchedulerSlot`.
 *
 * Settings `offsetTop` or `offsetBottom` would provide an extra space in addition to the space taken by the `items` inside the `slot`.
 */
export declare type SchedulerSlotExpandableConfig = {
    offsetTop?: number;
    offsetBottom?: number;
};

/**
 * @hidden
 */
export declare interface SchedulerSlotFocusEvent {
    target: SchedulerSlotHandle;
    syntheticEvent: React.FocusEvent;
}

/**
 * Represents the object which is returned from the `ref` callback of the [SchedulerSlot]({% slug api_scheduler_schedulerslot %}).
 *
 * For more information about Refs, refer to the [React Refs & Dom](https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom) article.
 */
export declare interface SchedulerSlotHandle {
    element: HTMLDivElement | null;
    props: SchedulerSlotProps;
}

/** @hidden */
export declare interface SchedulerSlotKeyboardEvent {
    target: SchedulerSlotHandle;
    syntheticEvent: React.KeyboardEvent;
}

/**
 * @hidden
 */
export declare interface SchedulerSlotMouseEvent {
    target: SchedulerSlotHandle;
    syntheticEvent: React.MouseEvent;
}

/**
 * Represents the props of the KendoReact [SchedulerSlot]({% slug api_scheduler_schedulerslot %}) component.
 */
export declare interface SchedulerSlotProps extends Slot {
    /** @hidden */
    _ref: React_2.RefObject<SchedulerSlotHandle | null>;
    /**
     * Specifies the `id` of the wrapping element of the SchedulerSlot.
     */
    id?: string;
    /**
     * Specifies the `tabIndex` attribute of the wrapping element of the SchedulerSlot.
     *
     * Providing `null` will not apply any `tabIndex` to the element.
     */
    tabIndex?: number;
    /**
     * Specifies the `className` attribute of the wrapping element of the SchedulerSlot.
     *
     * The SchedulerSlot applies the following default className:
     * - `k-scheduler-cell`
     * - `k-slot-cell`
     * - `k-nonwork-hour` - if either `props.isWorkHour` or `props.isWorkDay` is `false`
     * - `k-selected` - if `props.selected` is set to `true`
     */
    className?: string;
    /**
     * Specifies the `style` object of the wrapping element of the SchedulerSlot.
     *
     * The SchedulerSlot applies the following default styles:
     *  - `userSelect`: `none`
     */
    style?: React_2.CSSProperties;
    /**
     * Specifies the `children` of the SchedulerSlot. By default, no child elements are rendered.
     */
    children?: React_2.ReactNode;
    /**
     * Overrides the `editable` prop of the `Scheduler` and the active view.
     */
    editable?: EditableProp | boolean;
    /**
     * Specifies if the `day` of the SchedulerSlot(in the current timezone) is between the `workDayStart` and `workDayEnd` of the active view.
     */
    isWorkDay?: boolean;
    /**
     * Specifies if the `time` of the SchedulerSlot(in the current timezone) is between the `workDayStart` and `workDayEnd` of the active view.
     */
    isWorkHour?: boolean;
    /**
     * Sets the selected state of the SchedulerSlot. By default the `k-selected` className is added if `props.selected` is `true`.
     */
    selected?: boolean;
    /**
     * Sets the `row` in the context of the current active view.
     * This property is being used to provide keyboard navigation between the SchedulerSlot components.
     */
    row: number;
    /**
     * Sets the `col` in the context of the current active view.
     * This property is being used to provide keyboard navigation between the SchedulerSlot components.
     */
    col: number;
    /**
     * Called each time the element, or any of its child elements, receive focus.
     */
    onFocus?: (event: SchedulerSlotFocusEvent) => void;
    /**
     * Called each time the element, or any of its child elements, lose focus.
     */
    onBlur?: (event: SchedulerSlotFocusEvent) => void;
    /**
     * Called each time the element, or any of its child elements, is clicked.
     */
    onClick?: (event: SchedulerSlotMouseEvent) => void;
    /**
     * Called each time the element, or any of its child elements receives `mouseenter` event.
     */
    onMouseEnter?: (event: SchedulerSlotMouseEvent) => void;
    /**
     * Called each time the element, or any of its child elements receives `mouseleave` event.
     */
    onMouseLeave?: (event: SchedulerSlotMouseEvent) => void;
    /**
     * Called each time the element, or any of its child elements receives `mouseover` event.
     */
    onMouseOver?: (event: SchedulerSlotMouseEvent) => void;
    /**
     * Called each time the element, or any of its child elements receives `mouseout` event.
     */
    onMouseOut?: (event: SchedulerSlotMouseEvent) => void;
    /**
     * Called each time the element, or any of its child elements, is double-clicked.
     */
    onDoubleClick?: (event: SchedulerSlotMouseEvent) => void;
    /**
     * Called each time a `keydown` event propagates to the wrapping element.
     */
    onKeyDown?: (event: SchedulerSlotKeyboardEvent) => void;
    /**
     * Called each time a `keypress` event propagates to the wrapping element.
     */
    onKeyPress?: (event: SchedulerSlotKeyboardEvent) => void;
    /**
     * Called each time a `keyup` event propagates to the wrapping element.
     */
    onKeyUp?: (event: SchedulerSlotKeyboardEvent) => void;
}

/**
 * Represents the object passed to the `slots-focus` reducer.
 */
export declare interface SchedulerSlotsFocusAction {
    type: SLOTS_FOCUS_ACTION;
    slot: React_2.RefObject<SchedulerSlotHandle | null>;
}

/**
 * Represents the object passed to the `slots-select` reducer.
 */
export declare interface SchedulerSlotsSelectAction {
    type: SLOTS_SELECT_ACTION;
    slot?: React_2.RefObject<SchedulerSlotHandle | null>;
}

/**
 * Represents the default `task` component rendered by the [KendoReact Scheduler component]({% slug overview_scheduler %}).
 *
 * The SchedulerTask is the default representation of an event inside the [`AgendaView`]({% slug agenda_view_scheduler %}).
 */
export declare const SchedulerTask: React_2.ForwardRefExoticComponent<SchedulerTaskProps & React_2.RefAttributes<SchedulerTaskHandle>>;

/**
 * Represents the props of the KendoReact [SchedulerTask]({% slug api_scheduler_schedulertask %}) component.
 */
export declare interface SchedulerTaskHandle {
    element: HTMLDivElement | null;
    props: SchedulerTaskProps;
}

export declare interface SchedulerTaskMouseEvent {
    target: SchedulerTaskHandle;
    syntheticEvent: React.MouseEvent;
}

/**
 * Represents the props of the KendoReact [SchedulerTask]({% slug api_scheduler_schedulertask %}) component.
 */
export declare interface SchedulerTaskProps extends Item {
    /** @hidden */
    _ref: React_2.RefObject<SchedulerTaskHandle | null>;
    /**
     * Specifies the `id` of the wrapping element of the SchedulerTask.
     */
    id?: string;
    /**
     * Specifies the `tabIndex` attribute of the wrapping element of the SchedulerTask.
     */
    tabIndex?: number | null;
    /**
     * Specifies the `className` attribute of the wrapping element of the SchedulerTask.
     *
     * The SchedulerSlot applies the following default className:
     * - `k-task`
     */
    className?: string;
    /**
     * Specifies the `style` object of the wrapping element of the SchedulerTask.
     */
    style?: React_2.CSSProperties;
    /**
     * Specifies the `children` of the SchedulerTask.
     *
     * Setting this property will override the default elements rendered by the SchedulerTask.
     */
    children?: React_2.ReactNode;
    /**
     * Overrides the `editable` prop of the `Scheduler` and the active view.
     */
    editable?: EditableProp | boolean;
    /**
     * Called when the `delete` icon is clicked.
     *
     * The `delete` icon is rendered only when `props.editable` or `props.editable.remove` is `true`
     */
    onRemoveClick?: (event: SchedulerTaskMouseEvent) => void;
}

/**
 * Represents a single Scheduler view.
 */
export declare type SchedulerView = React.ReactElement<SchedulerViewProps>;

/**
 * Called every time the user changes the active `view`.
 *
 * For more information, refer to the [Scheduler Views]({% slug views_scheduler %}) article.
 */
export declare interface SchedulerViewChangeEvent {
    value: string;
}

/**
 * Represents the arguments which are passed to the [dateRange]({% slug api_scheduler_schedulerviewprops %}#toc-daterange) function.
 */
export declare interface SchedulerViewDateRangeArgs {
    date: Date;
    intl: IntlService;
    timezone?: string;
    numberOfDays?: number;
    workWeekStart?: Day;
    workWeekEnd?: Day;
}

export declare type SchedulerViewDateRangeFunction = (args: SchedulerViewDateRangeArgs) => DateRange;

/**
 * Represents the default `viewItem` component rendered by the [KendoReact Scheduler component]({% slug overview_scheduler %}).
 *
 * This is a composite component of the [`SchedulerItem`]({% slug api_scheduler_scheduleritem %}), extending it to provide proper positioning inside a view.
 */
export declare const SchedulerViewItem: React_2.ForwardRefExoticComponent<SchedulerViewItemProps & React_2.RefAttributes<SchedulerViewItemHandle>>;

export declare const schedulerViewItemDefaultProps: {
    item: React_2.ForwardRefExoticComponent<SchedulerItemProps & React_2.RefAttributes<SchedulerItemHandle>>;
};

/**
 * Represents the object which is returned from the `ref` callback of the [SchedulerViewItem]({% slug api_scheduler_schedulerviewitem %}).
 *
 * For more information about Refs, refer to the [React Refs & Dom](https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom) article.
 */
export declare interface SchedulerViewItemHandle {
    element: HTMLDivElement | null;
    props: SchedulerViewItemProps;
}

/**
 * Represents the props of the KendoReact [SchedulerViewItem]({% slug api_scheduler_schedulerviewitem %}) component.
 */
export declare interface SchedulerViewItemProps extends SchedulerItemProps {
    /** @hidden */
    ignoreIsAllDay?: boolean;
    /**
     * Overrides the default component responsible for visualizing a single item.
     *
     * The default Component is: [SchedulerItem]({% slug api_scheduler_scheduleritem %}).
     */
    item?: React_2.ComponentType<SchedulerItemProps>;
}

/**
 * Represents the required props which every [SchedulerView]({% slug api_scheduler_schedulerview %}) must accept.
 */
export declare interface SchedulerViewProps {
    /**
     * The name property is used by the Scheduler to match which view is selected. Every view has a default name.
     */
    name?: string;
    /**
     * The title to be displayed in the view selection list in the Toolbar.
     * If a function is passed, it will receive a [LocalizationService]({ slug api_intl_localizationservice }) as an argument
     */
    title?: string | ((localization: LocalizationService) => string);
    /**
     * Called every time any of the SchedulerView Slots or Items trigger a data action, through editing, deleting or creating new `DataItem`.
     */
    onDataAction?: (action: DataAction) => void;
    /**
     * Specifies the number of days to be shown in the current view.
     */
    numberOfDays?: number;
    /**
     * The long-date format for displaying the
     * selected date in the Scheduler toolbar.
     * Defaults to `{0:Y}`
     * ([more information](https://www.github.com/telerik/kendo-intl/blob/develop/docs/date-formatting/index.md))
     */
    selectedDateFormat?: string;
    /**
     * The short-date format for displaying the
     * selected date in the Scheduler toolbar.
     * Defaults to `{0:Y}`
     * ([more information](https://www.github.com/telerik/kendo-intl/blob/develop/docs/date-formatting/index.md))
     */
    selectedShortDateFormat?: string;
    /**
     * Overrides the `dateRange` calculated by the `Scheduler` component.
     *
     * If a function is passed, an object of type [SchedulerViewDateRangeArgs]({% slug api_scheduler_schedulerviewdaterangeargs %}) will be passed.
     */
    dateRange?: DateRange | ((args: SchedulerViewDateRangeArgs) => DateRange);
    /** @hidden */
    header?: React.ComponentType<SchedulerHeaderProps>;
    /** @hidden */
    footer?: React.ComponentType<SchedulerFooterProps>;
    /** @hidden */
    slotDivisions?: number;
    /** @hidden */
    slotDuration?: number;
    /** @hidden */
    workWeekStart?: Day;
    /** @hidden */
    workWeekEnd?: Day;
    /** @hidden */
    step?: number;
}

/**
 * A [React Context](https://react.dev/reference/react/hooks#context-hooks) providing access to the available Scheduler [views]({% slug views_scheduler %}).
 *
 * For more information, refer to the [Scheduler Context]({% slug context_scheduler %}) article.
 */
export declare const SchedulerViewsContext: React_2.Context<SchedulerViewsContextType>;

/**
 * Specifies the result of the [useSchedulerViewsContext]({% slug api_scheduler_useschedulerviewscontext %}) and [SchedulerViewsContext]({% slug api_scheduler_schedulerviewscontext %}).
 */
export declare type SchedulerViewsContextType = SchedulerView[];

/**
 * Represents the default `viewSlot` component rendered by the [KendoReact Scheduler component]({% slug overview_scheduler %}).
 *
 * This is a composite component of the [`SchedulerSlot`]({% slug api_scheduler_schedulerslot %}), extending it to provide additional functionality depending on the view.
 */
export declare const SchedulerViewSlot: React_2.ForwardRefExoticComponent<SchedulerViewSlotProps & React_2.RefAttributes<SchedulerViewSlotHandle>>;

export declare const schedulerViewSlotDefaultProps: {
    slot: React_2.ForwardRefExoticComponent<SchedulerSlotProps & React_2.RefAttributes<SchedulerSlotHandle>>;
    expandable: boolean;
};

/**
 * Represents the object which is returned from the `ref` callback of the [SchedulerViewItem]({% slug api_scheduler_schedulerviewitem %}).
 *
 * For more information about Refs, refer to the [React Refs & Dom](https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom) article.
 */
export declare interface SchedulerViewSlotHandle {
    props: SchedulerViewSlotProps;
}

/**
 * Represents the props of the KendoReact [SchedulerViewSlot]({% slug api_scheduler_schedulerviewslot %}) component.
 */
export declare interface SchedulerViewSlotProps extends SchedulerSlotProps {
    /**
     * Overrides the default component responsible for view-specific functionality.
     *
     * The default Component is: [SchedulerSlot]({% slug api_scheduler_schedulerslot %}).
     */
    slot?: React_2.ComponentType<SchedulerSlotProps>;
    /**
     * Set to `false` will render the `slot` as is, without expanding depending on the `items` inside it.
     *
     * For more information, please refer to the [Adaptive Slot Height]({% slug recurring_events_scheduler %}) article.
     */
    expandable?: boolean | SchedulerSlotExpandableConfig;
}

/**
 * Represents the default `viewTask` component rendered by the [KendoReact Scheduler component]({% slug overview_scheduler %}).
 *
 * This is a composite component of the [`SchedulerTask`]({% slug api_scheduler_schedulertask %}).
 */
export declare const SchedulerViewTask: React_2.ForwardRefExoticComponent<SchedulerViewTaskProps & React_2.RefAttributes<SchedulerViewTaskHandle>>;

export declare const schedulerViewTaskDefaultProps: {
    task: React_2.ForwardRefExoticComponent<SchedulerTaskProps & React_2.RefAttributes<SchedulerTaskHandle_2>>;
};

/**
 * Represents the object which is returned from the `ref` callback of the [SchedulerViewTask]({% slug api_scheduler_schedulerviewtask %}).
 *
 * For more information about Refs, refer to the [React Refs & Dom](https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom) article.
 */
export declare interface SchedulerViewTaskHandle {
    element: HTMLDivElement | null;
    props: SchedulerViewTaskProps;
}

/**
 * Represents the props of the KendoReact [SchedulerViewTask]({% slug api_scheduler_schedulerviewtask %}) component.
 */
export declare interface SchedulerViewTaskProps extends SchedulerTaskProps {
    /**
     * Overrides the default component responsible for visualizing a single task.
     *
     * The default Component is: [SchedulerTask]({% slug api_scheduler_schedulertask %}).
     */
    task?: React_2.ComponentType<SchedulerTaskProps>;
}

/**
 * Represents the available `action` types for the `SchedulerItemSeriesAction` objects.
 *
 * The available actions are:
 * - `SERIES_RESET`
 * - `SERIES_SET`
 * - `SERIES_TOGGLE`
 */
export declare enum SERIES_ACTION {
    reset = "SERIES_RESET",
    set = "SERIES_SET",
    toggle = "SERIES_TOGGLE"
}

/**
 * Represents the available `action` types for the `SchedulerItemShowOccurrenceDialogAction` objects.
 *
 * The available actions are:
 * - `SHOW_OCCURRENCE_DIALOG_SET`
 * - `SHOW_OCCURRENCE_DIALOG_OPEN`
 * - `SHOW_OCCURRENCE_DIALOG_CLOSE`
 * - `SHOW_OCCURRENCE_DIALOG_RESET`
 * - `SHOW_OCCURRENCE_DIALOG_TOGGLE`
 */
export declare enum SHOW_OCCURRENCE_DIALOG_ACTION {
    set = "SHOW_OCCURRENCE_DIALOG_SET",
    open = "SHOW_OCCURRENCE_DIALOG_OPEN",
    close = "SHOW_OCCURRENCE_DIALOG_CLOSE",
    reset = "SHOW_OCCURRENCE_DIALOG_RESET",
    toggle = "SHOW_OCCURRENCE_DIALOG_TOGGLE"
}

/**
 * Represents the available `action` types for the `SchedulerItemShowRemoveDialogAction` objects.
 *
 * The available actions are:
 * - `SHOW_REMOVE_DIALOG_SET`
 * - `SHOW_REMOVE_DIALOG_OPEN`
 * - `SHOW_REMOVE_DIALOG_CLOSE`
 * - `SHOW_REMOVE_DIALOG_RESET`
 * - `SHOW_REMOVE_DIALOG_TOGGLE`
 */
export declare enum SHOW_REMOVE_DIALOG_ACTION {
    set = "SHOW_REMOVE_DIALOG_SET",
    open = "SHOW_REMOVE_DIALOG_OPEN",
    close = "SHOW_REMOVE_DIALOG_CLOSE",
    reset = "SHOW_REMOVE_DIALOG_RESET",
    toggle = "SHOW_REMOVE_DIALOG_TOGGLE"
}

/** @hidden */
export declare interface Slot {
    /** @hidden */
    _ref: React.RefObject<SchedulerSlotHandle | null>;
    /**
     * Represents the consecutive number of the slot in the current range.
     */
    index: number;
    /**
     * The `end` date of the slot.
     */
    start: Date;
    /**
     * The `end` date of the slot.
     */
    end: Date;
    /**
     * Represents the `start` Date in the provided timezone.
     *
     * For more information about timezones, refer to the [Scheduler TImezones]({% slug timezones_scheduler %}) article.
     */
    zonedStart: ZonedDate;
    /**
     * Represents the `end` Date in the provided timezone.
     *
     * For more information about timezones, refer to the [Scheduler TImezones]({% slug timezones_scheduler %}) article.
     */
    zonedEnd: ZonedDate;
    /**
     * A collection of all `items` which fits in the current slot.
     */
    items: Item[];
    /**
     * Represents the current group in which the slot is rendered.
     */
    group: Group;
    /**
     * Represents the current range in which the slot is rendered.
     */
    range: Range_2;
    /**
     * Represents if the slot is an `All-day` slot.
     */
    isAllDay?: boolean;
}

/**
 * Represents the available `action` types for the `SchedulerSlotsFocusAction` objects.
 *
 * The available actions are:
 * - `SLOT_FOCUS_UP`
 * - `SLOT_FOCUS_DOWN`
 * - `SLOT_FOCUS_LEFT`
 * - `SLOT_FOCUS_RIGHT`
 */
export declare enum SLOTS_FOCUS_ACTION {
    up = "SLOT_FOCUS_UP",
    down = "SLOT_FOCUS_DOWN",
    left = "SLOT_FOCUS_LEFT",
    right = "SLOT_FOCUS_RIGHT"
}

/**
 * Represents the available `action` types for the `SchedulerSlotsSelectAction` objects.
 *
 * The available actions are:
 * - `SLOTS_SELECT_SELECT`
 * - `SLOTS_SELECT_RESET`
 * - `SLOTS_SELECT_ADD`
 */
export declare enum SLOTS_SELECT_ACTION {
    select = "SLOTS_SELECT_SELECT",
    reset = "SLOTS_SELECT_RESET",
    add = "SLOTS_SELECT_ADD"
}

/** @hidden */
declare type TargetlessChangeEvent<E extends {
    onChange?: any;
}, T> = Omit_2<E, 'onChange'> & {
    onChange?: (args: {
        value: T;
    }) => void;
};

/**
 * Represents the TimeHeaderCell component.
 */
export declare const TimeHeaderCell: React_2.ForwardRefExoticComponent<TimeHeaderCellProps & React_2.RefAttributes<TimeHeaderCellHandle | null>>;

export declare const timeHeaderCellDefaultProps: {
    as: React_2.ForwardRefExoticComponent<TimeHeaderCellProps & React_2.RefAttributes<unknown>>;
    format: string;
};

/**
 * Represents the target(element and props).
 */
export declare interface TimeHeaderCellHandle {
    /**
     * The current element or `null` if there is no one.
     */
    element: HTMLElement | null;
    /**
     * The props values of the TimeHeaderCell.
     */
    props: TimeHeaderCellProps;
}

/**
 * Represents the properties of [TimeHeaderCell]({% slug api_scheduler_timeheadercell %}) component.
 */
export declare interface TimeHeaderCellProps extends React_2.HTMLAttributes<HTMLDivElement> {
    /** @hidden */
    as?: React_2.ComponentType<TimeHeaderCellProps>;
    /**
     * Represents the date format.
     */
    format?: string | DateFormatOptions;
    /**
     * Represents the current date.
     */
    date: Date;
    /**
     * Represents the start date.
     */
    start: Date;
    /**
     * Represents the end date.
     */
    end: Date;
}

/**
 * Represents the KendoReact [TimelineView]({% slug timeline_view_scheduler %}) Component.
 */
export declare const TimelineView: React_2.FunctionComponent<TimelineViewProps>;

/** @hidden */
export declare const timeLineViewDefaultProps: {
    name: string;
    title: (localization: any) => any;
    slotDuration: number;
    slotDivisions: number;
    numberOfDays: number;
    selectedDateFormat: string;
    selectedShortDateFormat: string;
    currentTimeMarker: boolean;
    dateRange: ({ date, numberOfDays, timezone }: SchedulerViewDateRangeArgs_2) => DateRange_2;
    startTime: string;
    endTime: string;
    isWorkDayStart: string;
    isWorkDayEnd: string;
    workWeekStart: Day;
    workWeekEnd: Day;
    defaultShowWorkHours: boolean;
    columnWidth: number;
};

/**
 * Represents the properties of the KendoReact [TimelineView]({% slug api_scheduler_timelineview %}) Component.
 */
export declare interface TimelineViewProps extends MultiDayTimelineViewProps {
}

/**
 * A custom [React Hook](https://react.dev/reference/react/hooks) providing access to the Scheduler internal `activeView` state.
 *
 * For more information, refer to the [Scheduler Context]({% slug context_scheduler %}) article.
 *
 * @returns
 */
export declare const useSchedulerActiveViewContext: () => SchedulerActiveViewContextType;

/**
 * A custom [React Hook](https://react.dev/reference/react/hooks) providing access to the Scheduler internal `data` reducer.
 *
 * For more information, refer to the [Scheduler Context]({% slug context_scheduler %}) article.
 *
 * @returns
 */
export declare const useSchedulerDataContext: () => SchedulerDataContextType;

/**
 * A custom [React Hook](https://react.dev/reference/react/hooks) providing access to the Scheduler internal `date` state.
 *
 * For more information, refer to the [Scheduler Context]({% slug context_scheduler %}) article.
 *
 * @returns
 */
export declare const useSchedulerDateContext: () => SchedulerDateContextType;

/**
 * A custom [React Hook](https://react.dev/reference/react/hooks) providing access to the `dateRange` of the current view.
 *
 * For more information, refer to the [Scheduler Context]({% slug context_scheduler %}) article.
 *
 * @returns
 */
export declare const useSchedulerDateRangeContext: () => SchedulerDateRangeContextType;

/**
 * A custom [React Hook](https://react.dev/reference/react/hooks) providing access to the [SchedulerEditItem]({% slug edit-item_items_scheduler %}) internal `dragItem` state.
 *
 * For more information, refer to the [Items Context]({% slug state-update_items_scheduler %}) article.
 *
 * @returns
 */
export declare const useSchedulerEditItemDragItemContext: () => SchedulerEditItemDragItemContextType;

/**
 * A custom [React Hook](https://react.dev/reference/react/hooks) providing access to the [SchedulerEditItem]({% slug edit-item_items_scheduler %}) internal `formItem` state.
 *
 * For more information, refer to the [Items Context]({% slug state-update_items_scheduler %}) article.
 *
 * @returns
 */
export declare const useSchedulerEditItemFormItemContext: () => SchedulerEditItemFormItemContextType;

/**
 * A custom [React Hook](https://react.dev/reference/react/hooks) providing access to the [SchedulerEditItem]({% slug edit-item_items_scheduler %}) `props`.
 *
 * For more information, refer to the [Items Context]({% slug state-update_items_scheduler %}) article.
 *
 * @returns
 */
export declare const useSchedulerEditItemPropsContext: () => SchedulerEditItemPropsContextType;

/**
 * A custom [React Hook](https://react.dev/reference/react/hooks) providing access to the [SchedulerEditItem]({% slug edit-item_items_scheduler %}) internal `removeItem` state.
 *
 * For more information, refer to the [Items Context]({% slug state-update_items_scheduler %}) article.
 *
 * @returns
 */
export declare const useSchedulerEditItemRemoveItemContext: () => SchedulerEditItemRemoveItemContextType;

/**
 * A custom [React Hook](https://react.dev/reference/react/hooks) providing access to the [SchedulerEditItem]({% slug edit-item_items_scheduler %}) internal `resizeItem` state.
 *
 * For more information, refer to the [Items Context]({% slug state-update_items_scheduler %}) article.
 *
 * @returns
 */
export declare const useSchedulerEditItemResizeItemContext: () => SchedulerEditItemResizeItemContextType;

/**
 * A custom [React Hook](https://react.dev/reference/react/hooks) providing access to the [SchedulerEditItem]({% slug edit-item_items_scheduler %}) internal `showOccurrenceDialog` state.
 *
 * For more information, refer to the [Items Context]({% slug state-update_items_scheduler %}) article.
 *
 * @returns
 */
export declare const useSchedulerEditItemShowOccurrenceDialogContext: () => SchedulerEditItemShowOccurrenceDialogContextType;

/**
 * A custom [React Hook](https://react.dev/reference/react/hooks) providing access to the [SchedulerEditItem]({% slug edit-item_items_scheduler %}) internal `showRemoveDialog` state.
 *
 * For more information, refer to the [Items Context]({% slug state-update_items_scheduler %}) article.
 *
 * @returns
 */
export declare const useSchedulerEditItemShowRemoveDialogContext: () => SchedulerEditItemShowRemoveDialogContextType;

/**
 * A custom [React Hook](https://react.dev/reference/react/hooks) providing access to the [SchedulerEditSlot]({% slug api_scheduler_schedulereditslot %}) internal `formItem` state.
 *
 * For more information, refer to the [Slots Context]({% slug state-update_slots_scheduler %}) article.
 *
 * @returns
 */
export declare const useSchedulerEditSlotFormItemContext: () => SchedulerEditSlotFormItemContextType;

/**
 * A custom [React Hook](https://react.dev/reference/react/hooks) providing access to the [SchedulerEditSlot]({% slug api_scheduler_schedulereditslot %}) `props`.
 *
 * For more information, refer to the [Items Context]({% slug state-update_items_scheduler %}) article.
 *
 * @returns
 */
export declare const useSchedulerEditSlotPropsContext: () => SchedulerEditSlotPropsContextType;

/**
 * A custom [React Hook](https://react.dev/reference/react/hooks) providing access to the combined default and custom [modelFields]({% slug api_scheduler_schedulerprops %}#toc-modelfields) of the Scheduler.
 *
 * For more information, refer to the [Scheduler Context]({% slug context_scheduler %}) article.
 *
 * @returns
 */
export declare const useSchedulerFieldsContext: () => SchedulerFieldsContextType;

/**
 * A custom [React Hook](https://react.dev/reference/react/hooks) providing access to the Scheduler `Group` object, calculated based on the [group]({% slug api_scheduler_schedulerprops %}#toc-group) and [resources]({% slug api_scheduler_schedulerprops %}#toc-resources).
 *
 * For more information, refer to the [Scheduler Context]({% slug context_scheduler %}) article.
 *
 * @returns
 */
export declare const useSchedulerGroupsContext: () => SchedulerGroupsContextType;

/**
 * A custom [React Hook](https://react.dev/reference/react/hooks) providing access to the grouping orientation of the Scheduler.
 *
 * For more information, refer to the [Scheduler Context]({% slug context_scheduler %}) article.
 *
 * @returns
 */
export declare const useSchedulerOrientationContext: () => SchedulerOrientationContextType;

/**
 * A custom [React Hook](https://react.dev/reference/react/hooks) providing access to the [Scheduler]({% slug api_scheduler_scheduler %}) props.
 *
 * For more information, refer to the [Scheduler Context]({% slug context_scheduler %}) article.
 *
 * @returns
 */
export declare const useSchedulerPropsContext: () => SchedulerPropsContextType;

/**
 * A custom [React Hook](https://react.dev/reference/react/hooks) providing access to the available Scheduler [views]({% slug views_scheduler %}).
 *
 * For more information, refer to the [Scheduler Context]({% slug context_scheduler %}) article.
 *
 * @returns
 */
export declare const useSchedulerViewsContext: () => SchedulerViewsContextType;

/**
 * @hidden
 */
export declare interface ViewChangeEvent {
    target: any;
    syntheticEvent: React.SyntheticEvent;
}

/**
 * Represents the KendoReact [WeekView]({% slug week_views_scheduler %}) Component.
 */
export declare const WeekView: React_2.FunctionComponent<WeekViewProps>;

/** @hidden */
export declare const weekViewDefaultProps: {
    name: string;
    slotDuration: number;
    slotDivisions: number;
    numberOfDays: number;
    dateRange: ({ intl, date, timezone }: SchedulerViewDateRangeArgs) => DateRange;
    title: (localization: any) => any;
    selectedDateFormat: string;
    selectedShortDateFormat: string;
};

/**
 * Represents the properties of the KendoReact [WeekView]({% slug api_scheduler_weekview %}) Component.
 */
export declare interface WeekViewProps extends Omit<MultiDayViewProps, 'step' | 'numberOfDays'> {
    /**
     * The long-date format for displaying the
     * selected date in the Scheduler toolbar.
     * Defaults to `{0:D} - {1:D}`
     * ([more information](https://www.github.com/telerik/kendo-intl/blob/develop/docs/date-formatting/index.md))
     */
    selectedDateFormat?: string;
    /**
     * The short-date format for displaying the
     * selected date in the Scheduler toolbar.
     * Defaults to `{0:d} - {1-d}`
     * ([more information](https://www.github.com/telerik/kendo-intl/blob/develop/docs/date-formatting/index.md))
     */
    selectedShortDateFormat?: string;
    /**
     * Overrides the general `editable` prop of the Scheduler for the specified view only.
     */
    editable?: boolean;
    /**
     * The start time of the view. The WeekView displays events which are visible after the start time.
     * Accepts string values in the `HH:mm` format.
     */
    startTime?: string;
    /**
     * The end time of the view. The WeekView displays events which are visible before the end time.
     * Accepts string values in the `HH:mm` format.
     */
    endTime?: string;
    /**
     * The start time of the view when `showWorkHours` is set to `true`.
     * Accepts string values in the `HH:mm` format.
     */
    workDayStart?: string;
    /**
     * The end time of the view when `showWorkHours` is set to `true`.
     * Accepts string values in the `HH:mm` format.
     */
    workDayEnd?: string;
    /**
     * The start of the work week.
     */
    workWeekStart?: Day;
    /**
     * The end of the work week.
     */
    workWeekEnd?: Day;
    /**
     * The number of divisions of the time slots.
     */
    slotDivisions?: number;
    /**
     * The duration (in minutes) of the time slots.
     */
    slotDuration?: number;
    /**
     * If set to `true`, the view will be shown in the business-hours mode only.
     *
     * This will always override the internal `showWorkHours` state.
     */
    showWorkHours?: boolean;
    /**
     * Sets the initial business-hour mode. Default `true`.
     *
     * This option applies only the initial `showWorkHours` state.
     */
    defaultShowWorkHours?: boolean;
    /**
     * Sets a custom `className` to the wrapping element of the `DayView`.
     */
    className?: string;
    /**
     * Sets a custom `id` to the wrapping element of the `DayView`.
     */
    id?: string;
    /**
     * Sets a custom `style` property to the wrapping element of the `DayView`.
     */
    style?: React_2.CSSProperties;
}

/** @hidden */
export declare const workWeekDefaultProps: {
    name: string;
    slotDuration: number;
    slotDivisions: number;
    numberOfDays: number;
    dateRange: ({ intl, date, timezone, ...other }: SchedulerViewDateRangeArgs) => DateRange;
    title: (localization: any) => any;
    workWeekStart: Day;
    workWeekEnd: Day;
    selectedDateFormat: string;
    selectedShortDateFormat: string;
};

export declare const WorkWeekView: React_2.FunctionComponent<WorkWeekViewProps>;

export declare interface WorkWeekViewProps extends WeekViewProps {
}

/**
 * @hidden
 */
declare type ZonedDateTimeProps = Omit_2<DatePickerProps | DateTimePickerProps, 'onChange' | 'calendar'> & {
    as?: React_2.ComponentType<DatePickerProps | DateTimePickerProps>;
    onChange?: (args: {
        value: Date | null;
    }) => void;
    onOpen?: (args: DatePickerOpenEvent | DateTimePickerOpenEvent) => void;
    onClose?: (args: DatePickerCloseEvent | DateTimePickerCloseEvent) => void;
};

export { }