/**
 * @license
 *-------------------------------------------------------------------------------------------
 * Copyright © 2025 Progress Software Corporation. All rights reserved.
 * Licensed under commercial license. See LICENSE.md in the package root for more information
 *-------------------------------------------------------------------------------------------
 */
import { ComponentOptionsMixin } from 'vue';
import { ComponentProvideOptions } from 'vue';
import { CreateComponentPublicInstanceWithMixins } from 'vue';
import { DateFormatOptions } from '@progress/kendo-vue-intl';
import { DatePickerChangeEvent } from '@progress/kendo-vue-dateinputs';
import { DateRange as DateRange_2 } from '../../models/DateRange';
import { Day } from '@progress/kendo-date-math';
import { DefineComponent } from 'vue';
import { DialogCloseEvent } from '@progress/kendo-vue-dialogs';
import { DropDownListChangeEvent } from '@progress/kendo-vue-dropdowns';
import { EditableProp as EditableProp_2 } from '../../models/EditableProp';
import { EditableProp as EditableProp_3 } from '../models/EditableProp';
import { EndRule } from '../recurrence/types/EndRule';
import { ExtractPropTypes } from 'vue';
import { Fields } from './models/Fields';
import { FormElementProps } from '@progress/kendo-vue-form';
import { FormProps } from '@progress/kendo-vue-form';
import { FormRenderProps } from '@progress/kendo-vue-form';
import { Frequency } from '../recurrence/types/Frequency';
import { FrequencyEntity } from '../recurrence/types/FrequencyEntity';
import { Group as Group_2 } from '../models/Group';
import { Group as Group_3 } from '../../models/Group';
import { IntlService } from '@progress/kendo-vue-intl';
import { Item } from './models/Item';
import { Item as Item_3 } from '../../models/Item';
import { Item as Item_4 } from '../models/Item';
import { LocalizationService } from '@progress/kendo-vue-intl';
import { MethodOptions } from 'vue';
import { MonthEntity } from '../recurrence/types/MonthEntity';
import { MultiSelectChangeEvent } from '@progress/kendo-vue-dropdowns';
import { NumericTextBoxChangeEvent } from '@progress/kendo-vue-inputs';
import { Occurrence } from './models/Occurrence';
import { Occurrence as Occurrence_3 } from '../../models/Occurrence';
import { OffsetPositionEntity } from '../recurrence/types/OffsetPositionEntity';
import { PropType } from 'vue';
import { PublicProps } from 'vue';
import { RadioGroupChangeEvent } from '@progress/kendo-vue-inputs';
import { Range as Range_2 } from './models/Range';
import { Range as Range_4 } from '../../models/Range';
import { Range as Range_5 } from '../models/Range';
import { RecurrenceRule } from '@progress/kendo-recurrence';
import { Ref } from 'vue';
import { RepeatOnRule } from '../recurrence/types/RepeatOnRule';
import { SchedulerFormStateChangeEvent as SchedulerFormStateChangeEvent_2 } from '../../components/SchedulerForm';
import { SchedulerOccurrenceDialogStateChangeEvent as SchedulerOccurrenceDialogStateChangeEvent_2 } from '../../components/SchedulerOccurrenceDialog';
import { SchedulerResource as SchedulerResource_2 } from '..';
import { SchedulerSlotExpandableConfig as SchedulerSlotExpandableConfig_2 } from './SchedulerViewSlot';
import { SchedulerViewDateRangeArgs as SchedulerViewDateRangeArgs_2 } from './models/SchedulerView';
import { SchedulerViewDateRangeArgs as SchedulerViewDateRangeArgs_3 } from '../../models/SchedulerView';
import { Slot } from './models/Slot';
import { Slot as Slot_3 } from '../../models/Slot';
import { Slot as Slot_4 } from '../models/Slot';
import { ToolbarProps } from '@progress/kendo-vue-buttons';
import { WeekDayEntity } from '../recurrence/types/WeekDayEntity';
import { ZonedDate } from '@progress/kendo-date-math';

/**
 * @hidden
 */
export declare const AgendaView: DefineComponent<ExtractPropTypes<    {
name: {
type: PropType<string>;
default: string;
};
dateRange: {
type: PropType<DateRange | ((args: SchedulerViewDateRangeArgs) => DateRange)>;
default: () => ({ intl, date, numberOfDays, timezone }: SchedulerViewDateRangeArgs) => DateRange;
};
selectedDateFormat: {
type: PropType<string>;
default: string;
};
selectedShortDateFormat: {
type: PropType<string>;
default: string;
};
slotDuration: {
type: PropType<number>;
default: number;
};
slotDivisions: {
type: PropType<number>;
default: number;
};
step: {
type: PropType<number>;
default: number;
};
numberOfDays: {
type: PropType<number>;
default: number;
};
task: PropType<any>;
editable: {
type: PropType<boolean | EditableProp>;
default: boolean;
};
}>, {}, {}, {
ranges(): Range_4[];
agendaSlots(): Slot_3[];
occurrences(): Occurrence_3[];
items(): Item_3[];
}, {
handleDataAction(action: DataAction): void;
}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
name: {
type: PropType<string>;
default: string;
};
dateRange: {
type: PropType<DateRange | ((args: SchedulerViewDateRangeArgs) => DateRange)>;
default: () => ({ intl, date, numberOfDays, timezone }: SchedulerViewDateRangeArgs) => DateRange;
};
selectedDateFormat: {
type: PropType<string>;
default: string;
};
selectedShortDateFormat: {
type: PropType<string>;
default: string;
};
slotDuration: {
type: PropType<number>;
default: number;
};
slotDivisions: {
type: PropType<number>;
default: number;
};
step: {
type: PropType<number>;
default: number;
};
numberOfDays: {
type: PropType<number>;
default: number;
};
task: PropType<any>;
editable: {
type: PropType<boolean | EditableProp>;
default: boolean;
};
}>> & Readonly<{}>, {
name: string;
step: number;
editable: boolean | EditableProp;
numberOfDays: number;
selectedDateFormat: string;
selectedShortDateFormat: string;
dateRange: DateRange | ((args: SchedulerViewDateRangeArgs) => DateRange);
slotDivisions: number;
slotDuration: number;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

/**
 * @hidden
 */
export declare const BusinessHours: DefineComponent<ExtractPropTypes<    {
slotDuration: PropType<number>;
}>, {}, {}, {}, {
handleShowWorkHoursClick(e: any): void;
}, ComponentOptionsMixin, ComponentOptionsMixin, {
click: any;
}, string, PublicProps, Readonly<ExtractPropTypes<    {
slotDuration: PropType<number>;
}>> & Readonly<{
onClick?: (...args: any[] | unknown[]) => any;
}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

/** @hidden */
export declare interface BusinessHoursProps {
    slotDuration?: number;
}

/**
 * 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.
 *
 */
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 [`dataItems`]({% slug api_scheduler_schedulerprops %}#toc-dataitems) 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 %}).
 */
declare type DataItem = any;

/**
 * @hidden
 */
export declare const DateHeaderCell: DefineComponent<ExtractPropTypes<    {
as: PropType<any>;
format: {
type: (ObjectConstructor | StringConstructor)[];
default: string;
};
date: PropType<Date>;
start: PropType<Date>;
end: PropType<Date>;
}>, {
kendoIntlService: {};
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
as: PropType<any>;
format: {
type: (ObjectConstructor | StringConstructor)[];
default: string;
};
date: PropType<Date>;
start: PropType<Date>;
end: PropType<Date>;
}>> & Readonly<{}>, {
format: string | Record<string, any>;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

/** @hidden */
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_dateheadercellprops %}) component.
 */
export declare interface DateHeaderCellProps {
    /** @hidden */
    as?: any;
    /**
     * 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 */
declare interface DateRange {
    start: Date;
    end: Date;
    zonedStart: ZonedDate;
    zonedEnd: ZonedDate;
}

/** @hidden */
export declare const DayView: DefineComponent<ExtractPropTypes<    {
name: {
type: PropType<string>;
default: string;
};
title: PropType<string | ((localization: LocalizationService) => string)>;
dateRange: {
type: PropType<DateRange_2 | ((args: SchedulerViewDateRangeArgs_3) => DateRange_2)>;
default: () => any;
};
showWorkHours: {
type: PropType<boolean>;
default: boolean;
};
step: {
type: PropType<number>;
default: number;
};
numberOfDays: {
type: PropType<number>;
default: number;
};
slotDuration: {
type: PropType<number>;
default: number;
};
slotDivisions: {
type: PropType<number>;
default: number;
};
selectedDateFormat: {
type: PropType<string>;
default: string;
};
selectedShortDateFormat: {
type: PropType<string>;
default: string;
};
currentTimeMarker: {
type: PropType<boolean>;
default: boolean;
};
startTime: {
type: PropType<string>;
default: string;
};
endTime: {
type: PropType<string>;
default: string;
};
workDayStart: {
type: PropType<any>;
default: string;
};
workDayEnd: {
type: PropType<any>;
default: string;
};
workWeekStart: {
type: PropType<Day>;
default: Day;
};
workWeekEnd: {
type: PropType<Day>;
default: Day;
};
defaultShowWorkHours: {
type: PropType<boolean>;
default: boolean;
};
dateHeaderCell: PropType<any>;
timeHeaderCell: PropType<any>;
slotRender: PropType<any>;
viewSlot: PropType<any>;
resizeHint: PropType<any>;
item: PropType<any>;
viewItem: PropType<any>;
editable: {
type: PropType<boolean>;
default: boolean;
};
format: PropType<string>;
}>, {}, {}, {}, {
handleDataAction(action: DataAction): void;
}, ComponentOptionsMixin, ComponentOptionsMixin, {
dataaction: any;
}, string, PublicProps, Readonly<ExtractPropTypes<    {
name: {
type: PropType<string>;
default: string;
};
title: PropType<string | ((localization: LocalizationService) => string)>;
dateRange: {
type: PropType<DateRange_2 | ((args: SchedulerViewDateRangeArgs_3) => DateRange_2)>;
default: () => any;
};
showWorkHours: {
type: PropType<boolean>;
default: boolean;
};
step: {
type: PropType<number>;
default: number;
};
numberOfDays: {
type: PropType<number>;
default: number;
};
slotDuration: {
type: PropType<number>;
default: number;
};
slotDivisions: {
type: PropType<number>;
default: number;
};
selectedDateFormat: {
type: PropType<string>;
default: string;
};
selectedShortDateFormat: {
type: PropType<string>;
default: string;
};
currentTimeMarker: {
type: PropType<boolean>;
default: boolean;
};
startTime: {
type: PropType<string>;
default: string;
};
endTime: {
type: PropType<string>;
default: string;
};
workDayStart: {
type: PropType<any>;
default: string;
};
workDayEnd: {
type: PropType<any>;
default: string;
};
workWeekStart: {
type: PropType<Day>;
default: Day;
};
workWeekEnd: {
type: PropType<Day>;
default: Day;
};
defaultShowWorkHours: {
type: PropType<boolean>;
default: boolean;
};
dateHeaderCell: PropType<any>;
timeHeaderCell: PropType<any>;
slotRender: PropType<any>;
viewSlot: PropType<any>;
resizeHint: PropType<any>;
item: PropType<any>;
viewItem: PropType<any>;
editable: {
type: PropType<boolean>;
default: boolean;
};
format: PropType<string>;
}>> & Readonly<{
onDataaction?: (...args: any[] | unknown[]) => any;
}>, {
name: string;
step: number;
startTime: string;
editable: boolean;
numberOfDays: number;
selectedDateFormat: string;
selectedShortDateFormat: string;
dateRange: DateRange_2 | ((args: SchedulerViewDateRangeArgs_3) => DateRange_2);
slotDivisions: number;
slotDuration: number;
workWeekStart: Day;
workWeekEnd: Day;
currentTimeMarker: boolean;
workDayStart: any;
workDayEnd: any;
showWorkHours: boolean;
endTime: string;
defaultShowWorkHours: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

/**
 * 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.
 */
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;
}

/** @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)
 */
declare interface Group {
    index: number;
    resources: SchedulerResource[];
}

/** @hidden */
declare interface Item_2 extends Occurrence_2 {
    /** @hidden */
    refTo?: any;
    /**
     * Represents the `ref` of the actual `item`.
     */
    itemRef?: any;
    /**
     * 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_2[];
    /**
     * Represents the current group in which the item is rendered.
     */
    group: Group;
    /**
     * Represents the current range in which the item is rendered.
     */
    range: Range_3;
    /**
     * 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
 */
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 {
    current = "ITEMS_FOCUS_CURRENT",
    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"
}

/** @hidden */
export declare const MonthView: DefineComponent<ExtractPropTypes<    {
itemsPerSlot: {
type: PropType<number>;
default: number;
};
name: {
type: PropType<string>;
default: string;
};
dateRange: {
type: PropType<DateRange | ((args: SchedulerViewDateRangeArgs) => DateRange)>;
default: () => ({ intl, date, timezone }: SchedulerViewDateRangeArgs) => DateRange;
};
slotDuration: {
type: PropType<number>;
default: number;
};
slotDivisions: {
type: PropType<number>;
default: number;
};
numberOfDays: {
type: PropType<number>;
default: number;
};
dragItem: {
type: PropType<any>;
default: () => any;
};
resizeItem: {
type: PropType<any>;
default: () => any;
};
title: PropType<string | ((localization: LocalizationService) => string)>;
selectedDateFormat: {
type: PropType<string>;
default: string;
};
selectedShortDateFormat: {
type: PropType<string>;
default: string;
};
dateHeaderCell: PropType<any>;
slotRender: PropType<any>;
viewSlot: PropType<any>;
resizeHint: PropType<any>;
item: PropType<any>;
viewItem: PropType<any>;
editable: {
type: PropType<boolean>;
default: boolean;
};
}>, {}, {
hasMounted: boolean;
currentDragItem: any;
currentResizeItem: any;
}, {
ranges(): Range_4[];
monthSlots(): Slot_3[];
occurrences(): Occurrence_3[];
items(): Item_2[];
compDragItem(): any;
compResizeItem(): any;
}, {
handleDataAction(action: DataAction): void;
handleDragItemChange(item: any): void;
handleResizeItemChange(item: any): void;
}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
itemsPerSlot: {
type: PropType<number>;
default: number;
};
name: {
type: PropType<string>;
default: string;
};
dateRange: {
type: PropType<DateRange | ((args: SchedulerViewDateRangeArgs) => DateRange)>;
default: () => ({ intl, date, timezone }: SchedulerViewDateRangeArgs) => DateRange;
};
slotDuration: {
type: PropType<number>;
default: number;
};
slotDivisions: {
type: PropType<number>;
default: number;
};
numberOfDays: {
type: PropType<number>;
default: number;
};
dragItem: {
type: PropType<any>;
default: () => any;
};
resizeItem: {
type: PropType<any>;
default: () => any;
};
title: PropType<string | ((localization: LocalizationService) => string)>;
selectedDateFormat: {
type: PropType<string>;
default: string;
};
selectedShortDateFormat: {
type: PropType<string>;
default: string;
};
dateHeaderCell: PropType<any>;
slotRender: PropType<any>;
viewSlot: PropType<any>;
resizeHint: PropType<any>;
item: PropType<any>;
viewItem: PropType<any>;
editable: {
type: PropType<boolean>;
default: boolean;
};
}>> & Readonly<{}>, {
name: string;
editable: boolean;
itemsPerSlot: number;
dragItem: any;
resizeItem: any;
numberOfDays: number;
selectedDateFormat: string;
selectedShortDateFormat: string;
dateRange: DateRange | ((args: SchedulerViewDateRangeArgs) => DateRange);
slotDivisions: number;
slotDuration: number;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

/**
 * @hidden
 */
export declare const NavigationDatePicker: DefineComponent<ExtractPropTypes<    {
value: PropType<Date>;
onChange: PropType<(event: DatePickerChangeEvent) => void>;
}>, {}, {
hasMounted: boolean;
show: boolean;
focused: boolean;
media: string;
}, {}, {
handleChange(event: any): void;
handleClick(): void;
onFocus(): void;
onBlur(): void;
onCalendarBlur(): void;
createBlurTimeout(): void;
calendarKeydown(e: any): void;
hideAndFocusButton(): void;
calculateMedia(): void;
}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
value: PropType<Date>;
onChange: PropType<(event: DatePickerChangeEvent) => void>;
}>> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

/** @hidden */
declare interface Occurrence_2 {
    /** @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 interface Range_3 {
    index: number;
    start: Date;
    end: Date;
    zonedStart: ZonedDate;
    zonedEnd: ZonedDate;
    isAllDay?: boolean;
}

/**
 * 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 const Scheduler: DefineComponent<ExtractPropTypes<    {
dataItems: {
type: PropType<any[]>;
default: () => any[];
};
views: {
type: PropType<SchedulerViewProps[]>;
default: () => any[];
};
view: PropType<string>;
defaultView: PropType<string>;
date: PropType<Date>;
rtl: PropType<boolean>;
height: {
type: PropType<string | number>;
default: number;
};
timezone: PropType<string>;
group: PropType<SchedulerGroup>;
resources: PropType<SchedulerResource[]>;
modelFields: PropType<SchedulerModelFields>;
tabIndex: {
type: PropType<number>;
default: number;
};
editable: {
type: PropType<boolean | EditableProp>;
default: boolean;
};
defaultDate: {
type: PropType<Date>;
default: () => Date;
};
validator: {
type: PropType<Function>;
default: () => {};
};
modifyInitialFormValues: {
type: PropType<Function>;
default: (i: any) => any;
};
header: PropType<any>;
footer: PropType<any>;
slotRender: PropType<any>;
viewSlot: PropType<any>;
item: PropType<any>;
viewItem: PropType<any>;
task: PropType<any>;
form: PropType<any>;
resizeHint: PropType<any>;
dialogProps: PropType<any>;
formProps: PropType<any>;
dateHeaderCell: PropType<any>;
timeHeaderCell: PropType<any>;
}>, {}, {
ks: {
activeViewName: string;
currentDate: Date;
showWorkHours: any;
timezone: string;
props: {
validator: Function;
tabIndex: number;
dataItems: any[];
height: string | number;
views: SchedulerViewProps[];
editable: boolean | EditableProp;
modifyInitialFormValues: Function;
defaultDate: Date;
rtl?: boolean;
footer?: any;
form?: any;
header?: any;
view?: string;
group?: SchedulerGroup;
item?: any;
date?: Date;
timezone?: string;
viewSlot?: any;
slotRender?: any;
resizeHint?: any;
timeHeaderCell?: any;
resources?: SchedulerResource[];
dateHeaderCell?: any;
task?: any;
viewItem?: any;
defaultView?: string;
modelFields?: SchedulerModelFields;
dialogProps?: any;
formProps?: any;
onDatachange?: (...args: any[]) => any;
onItemclick?: (...args: any[]) => any;
onViewchange?: (...args: any[]) => any;
onDatechange?: (...args: any[]) => any;
onItemdoubleclick?: (...args: any[]) => any;
onSlotclick?: (...args: any[]) => any;
onSlotdoubleclick?: (...args: any[]) => any;
onTaskclick?: (...args: any[]) => any;
onTaskdoubleclick?: (...args: any[]) => any;
};
views: SchedulerViewProps[];
view: any;
fields: Fields;
groups: any[];
dateRange: DateRange;
orientation: "horizontal" | "vertical";
dateFormat: string;
shortDateFormat: string;
scheduler: CreateComponentPublicInstanceWithMixins<Readonly<ExtractPropTypes<    {
dataItems: {
type: PropType<any[]>;
default: () => any[];
};
views: {
type: PropType<SchedulerViewProps[]>;
default: () => any[];
};
view: PropType<string>;
defaultView: PropType<string>;
date: PropType<Date>;
rtl: PropType<boolean>;
height: {
type: PropType<string | number>;
default: number;
};
timezone: PropType<string>;
group: PropType<SchedulerGroup>;
resources: PropType<SchedulerResource[]>;
modelFields: PropType<SchedulerModelFields>;
tabIndex: {
type: PropType<number>;
default: number;
};
editable: {
type: PropType<boolean | EditableProp>;
default: boolean;
};
defaultDate: {
type: PropType<Date>;
default: () => Date;
};
validator: {
type: PropType<Function>;
default: () => {};
};
modifyInitialFormValues: {
type: PropType<Function>;
default: (i: any) => any;
};
header: PropType<any>;
footer: PropType<any>;
slotRender: PropType<any>;
viewSlot: PropType<any>;
item: PropType<any>;
viewItem: PropType<any>;
task: PropType<any>;
form: PropType<any>;
resizeHint: PropType<any>;
dialogProps: PropType<any>;
formProps: PropType<any>;
dateHeaderCell: PropType<any>;
timeHeaderCell: PropType<any>;
}>> & Readonly<{
onDatachange?: (...args: any[]) => any;
onItemclick?: (...args: any[]) => any;
onViewchange?: (...args: any[]) => any;
onDatechange?: (...args: any[]) => any;
onItemdoubleclick?: (...args: any[]) => any;
onSlotclick?: (...args: any[]) => any;
onSlotdoubleclick?: (...args: any[]) => any;
onTaskclick?: (...args: any[]) => any;
onTaskdoubleclick?: (...args: any[]) => any;
}>, {}, {}, {}, MethodOptions, ComponentOptionsMixin, ComponentOptionsMixin, {}, Readonly<ExtractPropTypes<    {
dataItems: {
type: PropType<any[]>;
default: () => any[];
};
views: {
type: PropType<SchedulerViewProps[]>;
default: () => any[];
};
view: PropType<string>;
defaultView: PropType<string>;
date: PropType<Date>;
rtl: PropType<boolean>;
height: {
type: PropType<string | number>;
default: number;
};
timezone: PropType<string>;
group: PropType<SchedulerGroup>;
resources: PropType<SchedulerResource[]>;
modelFields: PropType<SchedulerModelFields>;
tabIndex: {
type: PropType<number>;
default: number;
};
editable: {
type: PropType<boolean | EditableProp>;
default: boolean;
};
defaultDate: {
type: PropType<Date>;
default: () => Date;
};
validator: {
type: PropType<Function>;
default: () => {};
};
modifyInitialFormValues: {
type: PropType<Function>;
default: (i: any) => any;
};
header: PropType<any>;
footer: PropType<any>;
slotRender: PropType<any>;
viewSlot: PropType<any>;
item: PropType<any>;
viewItem: PropType<any>;
task: PropType<any>;
form: PropType<any>;
resizeHint: PropType<any>;
dialogProps: PropType<any>;
formProps: PropType<any>;
dateHeaderCell: PropType<any>;
timeHeaderCell: PropType<any>;
}>> & Readonly<{
onDatachange?: (...args: any[]) => any;
onItemclick?: (...args: any[]) => any;
onViewchange?: (...args: any[]) => any;
onDatechange?: (...args: any[]) => any;
onItemdoubleclick?: (...args: any[]) => any;
onSlotclick?: (...args: any[]) => any;
onSlotdoubleclick?: (...args: any[]) => any;
onTaskclick?: (...args: any[]) => any;
onTaskdoubleclick?: (...args: any[]) => any;
}>, {}, false, {}, {}, {}, {}, string, {}, any, ComponentProvideOptions, {
P: {};
B: {};
D: {};
C: {};
M: {};
Defaults: {};
}, Readonly<ExtractPropTypes<    {
dataItems: {
type: PropType<any[]>;
default: () => any[];
};
views: {
type: PropType<SchedulerViewProps[]>;
default: () => any[];
};
view: PropType<string>;
defaultView: PropType<string>;
date: PropType<Date>;
rtl: PropType<boolean>;
height: {
type: PropType<string | number>;
default: number;
};
timezone: PropType<string>;
group: PropType<SchedulerGroup>;
resources: PropType<SchedulerResource[]>;
modelFields: PropType<SchedulerModelFields>;
tabIndex: {
type: PropType<number>;
default: number;
};
editable: {
type: PropType<boolean | EditableProp>;
default: boolean;
};
defaultDate: {
type: PropType<Date>;
default: () => Date;
};
validator: {
type: PropType<Function>;
default: () => {};
};
modifyInitialFormValues: {
type: PropType<Function>;
default: (i: any) => any;
};
header: PropType<any>;
footer: PropType<any>;
slotRender: PropType<any>;
viewSlot: PropType<any>;
item: PropType<any>;
viewItem: PropType<any>;
task: PropType<any>;
form: PropType<any>;
resizeHint: PropType<any>;
dialogProps: PropType<any>;
formProps: PropType<any>;
dateHeaderCell: PropType<any>;
timeHeaderCell: PropType<any>;
}>> & Readonly<{
onDatachange?: (...args: any[]) => any;
onItemclick?: (...args: any[]) => any;
onViewchange?: (...args: any[]) => any;
onDatechange?: (...args: any[]) => any;
onItemdoubleclick?: (...args: any[]) => any;
onSlotclick?: (...args: any[]) => any;
onSlotdoubleclick?: (...args: any[]) => any;
onTaskclick?: (...args: any[]) => any;
onTaskdoubleclick?: (...args: any[]) => any;
}>, {}, {}, {}, MethodOptions, {}>;
dataItems: any[];
};
}, {
isRtl(): any;
wrapperClassName(): {
'k-rtl': any;
'k-scheduler': boolean;
};
fields(): Fields;
}, {
getViewComponentByName(viewName: string): DefineComponent<ExtractPropTypes<    {
name: {
type: PropType<string>;
default: string;
};
dateRange: {
type: PropType<DateRange | ((args: SchedulerViewDateRangeArgs_2) => DateRange)>;
default: () => ({ intl, date, numberOfDays, timezone }: SchedulerViewDateRangeArgs_2) => DateRange;
};
selectedDateFormat: {
type: PropType<string>;
default: string;
};
selectedShortDateFormat: {
type: PropType<string>;
default: string;
};
slotDuration: {
type: PropType<number>;
default: number;
};
slotDivisions: {
type: PropType<number>;
default: number;
};
step: {
type: PropType<number>;
default: number;
};
numberOfDays: {
type: PropType<number>;
default: number;
};
task: PropType<any>;
editable: {
type: PropType<boolean | EditableProp>;
default: boolean;
};
}>, {}, {}, {
ranges(): Range_2[];
agendaSlots(): Slot[];
occurrences(): Occurrence[];
items(): Item[];
}, {
handleDataAction(action: DataAction): void;
}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
name: {
type: PropType<string>;
default: string;
};
dateRange: {
type: PropType<DateRange | ((args: SchedulerViewDateRangeArgs_2) => DateRange)>;
default: () => ({ intl, date, numberOfDays, timezone }: SchedulerViewDateRangeArgs_2) => DateRange;
};
selectedDateFormat: {
type: PropType<string>;
default: string;
};
selectedShortDateFormat: {
type: PropType<string>;
default: string;
};
slotDuration: {
type: PropType<number>;
default: number;
};
slotDivisions: {
type: PropType<number>;
default: number;
};
step: {
type: PropType<number>;
default: number;
};
numberOfDays: {
type: PropType<number>;
default: number;
};
task: PropType<any>;
editable: {
type: PropType<boolean | EditableProp>;
default: boolean;
};
}>> & Readonly<{}>, {
name: string;
step: number;
editable: boolean | EditableProp;
numberOfDays: number;
selectedDateFormat: string;
selectedShortDateFormat: string;
dateRange: DateRange | ((args: SchedulerViewDateRangeArgs_2) => DateRange);
slotDivisions: number;
slotDuration: number;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any> | DefineComponent<ExtractPropTypes<    {
name: {
type: PropType<string>;
default: string;
};
title: {
type: PropType<string | ((localization: LocalizationService) => string)>;
default: string;
};
currentTimeMarker: {
type: PropType<boolean>;
default: boolean;
};
dateRange: {
type: PropType<DateRange | ((args: SchedulerViewDateRangeArgs_2) => DateRange)>;
default: () => any;
};
showWorkHours: {
type: PropType<boolean>;
default: boolean;
};
selectedDateFormat: {
type: PropType<string>;
default: string;
};
selectedShortDateFormat: {
type: PropType<string>;
default: string;
};
step: {
type: PropType<number>;
default: number;
};
numberOfDays: {
type: PropType<number>;
default: number;
};
startTime: {
type: PropType<string>;
default: string;
};
endTime: {
type: PropType<string>;
default: string;
};
workDayStart: {
type: PropType<string>;
default: string;
};
workDayEnd: {
type: PropType<string>;
default: string;
};
workWeekStart: {
type: PropType<Day>;
default: Day;
};
workWeekEnd: {
type: PropType<Day>;
default: Day;
};
slotDivisions: {
type: PropType<number>;
default: number;
};
slotDuration: {
type: PropType<number>;
default: number;
};
defaultShowWorkHours: {
type: PropType<boolean>;
default: boolean;
};
columnWidth: {
type: PropType<number>;
default: number;
};
dragItem: {
type: PropType<any>;
default: () => any;
};
resizeItem: {
type: PropType<any>; /**
* Specifies the `className` attribute of the wrapping element of the Scheduler.
*/
default: () => any;
};
dateHeaderCell: PropType<any>;
timeHeaderCell: PropType<any>;
slotRender: PropType<any>;
viewSlot: PropType<any>;
resizeHint: PropType<any>;
item: PropType<any>;
viewItem: PropType<any>;
editable: PropType<boolean | EditableProp>;
}>, {}, {}, {}, {
handleDataAction(action: DataAction): void;
}, ComponentOptionsMixin, ComponentOptionsMixin, {
dataaction: any;
}, string, PublicProps, Readonly<ExtractPropTypes<    {
name: {
type: PropType<string>;
default: string;
};
title: {
type: PropType<string | ((localization: LocalizationService) => string)>;
default: string;
};
currentTimeMarker: {
type: PropType<boolean>;
default: boolean;
};
dateRange: {
type: PropType<DateRange | ((args: SchedulerViewDateRangeArgs_2) => DateRange)>;
default: () => any;
};
showWorkHours: {
type: PropType<boolean>;
default: boolean;
};
selectedDateFormat: {
type: PropType<string>;
default: string;
};
selectedShortDateFormat: {
type: PropType<string>;
default: string;
};
step: {
type: PropType<number>;
default: number;
};
numberOfDays: {
type: PropType<number>;
default: number;
};
startTime: {
type: PropType<string>;
default: string;
};
endTime: {
type: PropType<string>;
default: string;
};
workDayStart: {
type: PropType<string>;
default: string;
};
workDayEnd: {
type: PropType<string>;
default: string;
};
workWeekStart: {
type: PropType<Day>;
default: Day;
};
workWeekEnd: {
type: PropType<Day>;
default: Day;
};
slotDivisions: {
type: PropType<number>;
default: number;
};
slotDuration: {
type: PropType<number>;
default: number;
};
defaultShowWorkHours: {
type: PropType<boolean>;
default: boolean;
};
columnWidth: {
type: PropType<number>;
default: number;
};
dragItem: {
type: PropType<any>;
default: () => any;
};
resizeItem: {
type: PropType<any>; /**
* Specifies the `className` attribute of the wrapping element of the Scheduler.
*/
default: () => any;
};
dateHeaderCell: PropType<any>;
timeHeaderCell: PropType<any>;
slotRender: PropType<any>;
viewSlot: PropType<any>;
resizeHint: PropType<any>;
item: PropType<any>;
viewItem: PropType<any>;
editable: PropType<boolean | EditableProp>;
}>> & Readonly<{
onDataaction?: (...args: any[] | unknown[]) => any;
}>, {
name: string;
title: string | ((localization: LocalizationService) => string);
step: number;
startTime: string;
columnWidth: number;
dragItem: any;
resizeItem: any;
numberOfDays: number;
selectedDateFormat: string;
selectedShortDateFormat: string;
dateRange: DateRange | ((args: SchedulerViewDateRangeArgs_2) => DateRange);
slotDivisions: number;
slotDuration: number;
workWeekStart: Day;
workWeekEnd: Day;
currentTimeMarker: boolean;
workDayStart: string;
workDayEnd: string;
showWorkHours: boolean;
endTime: string;
defaultShowWorkHours: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any> | DefineComponent<ExtractPropTypes<    {
name: {
type: PropType<string>;
default: string;
};
title: PropType<string | ((localization: LocalizationService) => string)>;
dateRange: {
type: PropType<DateRange | ((args: SchedulerViewDateRangeArgs_2) => DateRange)>;
default: () => any;
};
showWorkHours: {
type: PropType<boolean>;
default: boolean;
};
step: {
type: PropType<number>;
default: number;
};
numberOfDays: {
type: PropType<number>;
default: number;
};
slotDuration: {
type: PropType<number>;
default: number;
};
slotDivisions: {
type: PropType<number>;
default: number;
};
selectedDateFormat: {
type: PropType<string>;
default: string;
};
selectedShortDateFormat: {
type: PropType<string>;
default: string;
};
currentTimeMarker: {
type: PropType<boolean>;
default: boolean;
};
startTime: {
type: PropType<string>;
default: string;
};
endTime: {
type: PropType<string>;
default: string;
};
workDayStart: {
type: PropType<any>;
default: string;
};
workDayEnd: {
type: PropType<any>;
default: string;
};
workWeekStart: {
type: PropType<Day>;
default: Day;
};
workWeekEnd: {
type: PropType<Day>;
default: Day;
};
defaultShowWorkHours: {
type: PropType<boolean>;
default: boolean;
};
dateHeaderCell: PropType<any>;
timeHeaderCell: PropType<any>;
slotRender: PropType<any>;
viewSlot: PropType<any>;
resizeHint: PropType<any>;
item: PropType<any>;
viewItem: PropType<any>;
editable: {
type: PropType<boolean>;
default: boolean;
};
format: PropType<string>;
}>, {}, {}, {}, {
handleDataAction(action: DataAction): void;
}, ComponentOptionsMixin, ComponentOptionsMixin, {
dataaction: any;
}, string, PublicProps, Readonly<ExtractPropTypes<    {
name: {
type: PropType<string>;
default: string;
};
title: PropType<string | ((localization: LocalizationService) => string)>;
dateRange: {
type: PropType<DateRange | ((args: SchedulerViewDateRangeArgs_2) => DateRange)>;
default: () => any;
};
showWorkHours: {
type: PropType<boolean>;
default: boolean;
};
step: {
type: PropType<number>;
default: number;
};
numberOfDays: {
type: PropType<number>;
default: number;
};
slotDuration: {
type: PropType<number>;
default: number;
};
slotDivisions: {
type: PropType<number>;
default: number;
};
selectedDateFormat: {
type: PropType<string>;
default: string;
};
selectedShortDateFormat: {
type: PropType<string>;
default: string;
};
currentTimeMarker: {
type: PropType<boolean>;
default: boolean;
};
startTime: {
type: PropType<string>;
default: string;
};
endTime: {
type: PropType<string>;
default: string;
};
workDayStart: {
type: PropType<any>;
default: string;
};
workDayEnd: {
type: PropType<any>;
default: string;
};
workWeekStart: {
type: PropType<Day>;
default: Day;
};
workWeekEnd: {
type: PropType<Day>;
default: Day;
};
defaultShowWorkHours: {
type: PropType<boolean>;
default: boolean;
};
dateHeaderCell: PropType<any>;
timeHeaderCell: PropType<any>;
slotRender: PropType<any>;
viewSlot: PropType<any>;
resizeHint: PropType<any>;
item: PropType<any>;
viewItem: PropType<any>;
editable: {
type: PropType<boolean>;
default: boolean;
};
format: PropType<string>;
}>> & Readonly<{
onDataaction?: (...args: any[] | unknown[]) => any;
}>, {
name: string;
step: number;
startTime: string;
editable: boolean;
numberOfDays: number;
selectedDateFormat: string;
selectedShortDateFormat: string;
dateRange: DateRange | ((args: SchedulerViewDateRangeArgs_2) => DateRange);
slotDivisions: number;
slotDuration: number;
workWeekStart: Day;
workWeekEnd: Day;
currentTimeMarker: boolean;
workDayStart: any;
workDayEnd: any;
showWorkHours: boolean;
endTime: string;
defaultShowWorkHours: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any> | DefineComponent<ExtractPropTypes<    {
name: {
type: PropType<string>;
default: string;
};
slotDuration: {
type: PropType<number>;
default: number;
};
slotDivisions: {
type: PropType<number>;
default: number;
};
numberOfDays: {
type: PropType<number>;
default: number;
};
dateRange: {
type: PropType<DateRange | ((args: SchedulerViewDateRangeArgs_2) => DateRange)>;
default: () => ({ intl, date, timezone, ...other }: SchedulerViewDateRangeArgs_2) => DateRange;
};
title: PropType<string | ((localization: LocalizationService) => string)>;
workWeekStart: {
type: PropType<Day>;
default: Day;
};
workWeekEnd: {
type: PropType<Day>;
default: Day;
};
selectedDateFormat: {
type: PropType<string>;
default: string;
};
selectedShortDateFormat: {
type: PropType<string>;
default: string;
};
showWorkHours: {
type: PropType<boolean>;
default: boolean;
};
dateHeaderCell: PropType<any>;
timeHeaderCell: PropType<any>;
slotRender: PropType<any>;
viewSlot: PropType<any>;
resizeHint: PropType<any>;
item: PropType<any>;
viewItem: PropType<any>;
editable: {
type: PropType<boolean>;
default: boolean;
}; /**
* The `aria-label` attribute to be applied to the Scheduler component.
*
* For more information, refer to the [Scheduler Accessibility Compliance]({% slug accessibility_scheduler %}) article
*/
}>, {}, {}, {}, {
handleDataAction(action: DataAction): void;
}, ComponentOptionsMixin, ComponentOptionsMixin, {
dataaction: any;
}, string, PublicProps, Readonly<ExtractPropTypes<    {
name: {
type: PropType<string>;
default: string;
};
slotDuration: {
type: PropType<number>;
default: number;
};
slotDivisions: {
type: PropType<number>;
default: number;
};
numberOfDays: {
type: PropType<number>;
default: number;
};
dateRange: {
type: PropType<DateRange | ((args: SchedulerViewDateRangeArgs_2) => DateRange)>;
default: () => ({ intl, date, timezone, ...other }: SchedulerViewDateRangeArgs_2) => DateRange;
};
title: PropType<string | ((localization: LocalizationService) => string)>;
workWeekStart: {
type: PropType<Day>;
default: Day;
};
workWeekEnd: {
type: PropType<Day>;
default: Day;
};
selectedDateFormat: {
type: PropType<string>;
default: string;
};
selectedShortDateFormat: {
type: PropType<string>;
default: string;
};
showWorkHours: {
type: PropType<boolean>;
default: boolean;
};
dateHeaderCell: PropType<any>;
timeHeaderCell: PropType<any>;
slotRender: PropType<any>;
viewSlot: PropType<any>;
resizeHint: PropType<any>;
item: PropType<any>;
viewItem: PropType<any>;
editable: {
type: PropType<boolean>;
default: boolean;
}; /**
* The `aria-label` attribute to be applied to the Scheduler component.
*
* For more information, refer to the [Scheduler Accessibility Compliance]({% slug accessibility_scheduler %}) article
*/
}>> & Readonly<{
onDataaction?: (...args: any[] | unknown[]) => any;
}>, {
name: string;
editable: boolean;
numberOfDays: number;
selectedDateFormat: string;
selectedShortDateFormat: string;
dateRange: DateRange | ((args: SchedulerViewDateRangeArgs_2) => DateRange);
slotDivisions: number;
slotDuration: number;
workWeekStart: Day;
workWeekEnd: Day;
showWorkHours: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any> | DefineComponent<ExtractPropTypes<    {
itemsPerSlot: {
type: PropType<number>;
default: number;
};
name: {
type: PropType<string>;
default: string;
};
dateRange: {
type: PropType<DateRange | ((args: SchedulerViewDateRangeArgs_2) => DateRange)>;
default: () => ({ intl, date, timezone }: SchedulerViewDateRangeArgs_2) => DateRange;
};
slotDuration: {
type: PropType<number>;
default: number;
};
slotDivisions: {
type: PropType<number>;
default: number;
};
numberOfDays: {
type: PropType<number>;
default: number;
};
dragItem: {
type: PropType<any>;
default: () => any;
};
resizeItem: {
type: PropType<any>;
default: () => any;
};
title: PropType<string | ((localization: LocalizationService) => string)>;
selectedDateFormat: {
type: PropType<string>;
default: string;
};
selectedShortDateFormat: {
type: PropType<string>;
default: string;
};
dateHeaderCell: PropType<any>;
slotRender: PropType<any>;
viewSlot: PropType<any>;
resizeHint: PropType<any>;
item: PropType<any>;
viewItem: PropType<any>;
editable: {
type: PropType<boolean>;
default: boolean;
};
}>, {}, {
hasMounted: boolean; /**
* Overrides the default editTask. Specifying the `editTask` 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: [SchedulerEditTask]({% slug api_scheduler_scheduleredittaskprops %})
*
* For more information on customizing the scheduler tasks, refer to the [Task Customization]({% slug overview_agenda_view_scheduler %}) article.
*/
currentDragItem: any;
currentResizeItem: any;
}, {
ranges(): Range_2[];
monthSlots(): Slot[];
occurrences(): Occurrence[];
items(): Item[];
compDragItem(): any;
compResizeItem(): any;
}, {
handleDataAction(action: DataAction): void;
handleDragItemChange(item: any): void;
handleResizeItemChange(item: any): void;
}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
itemsPerSlot: {
type: PropType<number>;
default: number;
};
name: {
type: PropType<string>;
default: string;
};
dateRange: {
type: PropType<DateRange | ((args: SchedulerViewDateRangeArgs_2) => DateRange)>;
default: () => ({ intl, date, timezone }: SchedulerViewDateRangeArgs_2) => DateRange;
};
slotDuration: {
type: PropType<number>;
default: number;
};
slotDivisions: {
type: PropType<number>;
default: number;
};
numberOfDays: {
type: PropType<number>;
default: number;
};
dragItem: {
type: PropType<any>;
default: () => any;
};
resizeItem: {
type: PropType<any>;
default: () => any;
};
title: PropType<string | ((localization: LocalizationService) => string)>;
selectedDateFormat: {
type: PropType<string>;
default: string;
};
selectedShortDateFormat: {
type: PropType<string>;
default: string;
};
dateHeaderCell: PropType<any>;
slotRender: PropType<any>;
viewSlot: PropType<any>;
resizeHint: PropType<any>;
item: PropType<any>;
viewItem: PropType<any>;
editable: {
type: PropType<boolean>;
default: boolean;
};
}>> & Readonly<{}>, {
name: string;
editable: boolean;
itemsPerSlot: number;
dragItem: any;
resizeItem: any;
numberOfDays: number;
selectedDateFormat: string;
selectedShortDateFormat: string;
dateRange: DateRange | ((args: SchedulerViewDateRangeArgs_2) => DateRange);
slotDivisions: number;
slotDuration: number;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
getViewPropValue(view: any, propName: string, activeViewName: string): any;
handleDataChange({ created, updated, deleted }: {
created?: DataItem[];
updated?: DataItem[];
deleted?: DataItem[];
}): void;
handleCreate(action: DataAction): void;
handleUpdate(action: DataAction): void;
handleRemove(action: DataAction): void;
handleDataAction(action: DataAction): void;
handleActiveViewNameChange(newView: string, event?: any): void;
handleDateChange(newDate: Date, event?: any): void;
handleDatePickerChange(event: DatePickerChangeEvent): void;
handleNextClick(event: any): void;
handlePrevClick(event: any): void;
handleTodayClick(event: any): void;
handleShowWorkHoursClick(): void;
handleFocus(): void;
handleBlur(): void;
handleItemClick(args: SchedulerItemMouseEvent): void;
handleItemDoubleClick(args: SchedulerItemMouseEvent): void;
handleSlotClick(args: SchedulerSlotMouseEvent): void;
handleSlotDoubleClick(args: SchedulerSlotMouseEvent): void;
handleTaskClick(args: SchedulerTaskMouseEvent): void;
handleTaskDoubleClick(args: SchedulerTaskMouseEvent): void;
setDate(newDate: Date, event: any): void;
updatePassedState(newViewName: string): void;
}, ComponentOptionsMixin, ComponentOptionsMixin, ("datachange" | "itemclick" | "viewchange" | "datechange" | "itemdoubleclick" | "slotclick" | "slotdoubleclick" | "taskclick" | "taskdoubleclick")[], "datachange" | "itemclick" | "viewchange" | "datechange" | "itemdoubleclick" | "slotclick" | "slotdoubleclick" | "taskclick" | "taskdoubleclick", PublicProps, Readonly<ExtractPropTypes<    {
dataItems: {
type: PropType<any[]>;
default: () => any[];
};
views: {
type: PropType<SchedulerViewProps[]>;
default: () => any[];
};
view: PropType<string>;
defaultView: PropType<string>;
date: PropType<Date>;
rtl: PropType<boolean>;
height: {
type: PropType<string | number>;
default: number;
};
timezone: PropType<string>;
group: PropType<SchedulerGroup>;
resources: PropType<SchedulerResource[]>;
modelFields: PropType<SchedulerModelFields>;
tabIndex: {
type: PropType<number>;
default: number;
};
editable: {
type: PropType<boolean | EditableProp>;
default: boolean;
};
defaultDate: {
type: PropType<Date>;
default: () => Date;
};
validator: {
type: PropType<Function>;
default: () => {};
};
modifyInitialFormValues: {
type: PropType<Function>;
default: (i: any) => any;
};
header: PropType<any>;
footer: PropType<any>;
slotRender: PropType<any>;
viewSlot: PropType<any>;
item: PropType<any>;
viewItem: PropType<any>;
task: PropType<any>;
form: PropType<any>;
resizeHint: PropType<any>;
dialogProps: PropType<any>;
formProps: PropType<any>;
dateHeaderCell: PropType<any>;
timeHeaderCell: PropType<any>;
}>> & Readonly<{
onDatachange?: (...args: any[]) => any;
onItemclick?: (...args: any[]) => any;
onViewchange?: (...args: any[]) => any;
onDatechange?: (...args: any[]) => any;
onItemdoubleclick?: (...args: any[]) => any;
onSlotclick?: (...args: any[]) => any;
onSlotdoubleclick?: (...args: any[]) => any;
onTaskclick?: (...args: any[]) => any;
onTaskdoubleclick?: (...args: any[]) => any;
}>, {
validator: Function;
tabIndex: number;
dataItems: any[];
height: string | number;
views: SchedulerViewProps[];
editable: boolean | EditableProp;
modifyInitialFormValues: Function;
defaultDate: Date;
}, {}, {}, {}, string, () => {
ks: any;
setActiveViewName: any;
setActiveDate: any;
itemDoubleClick: any;
itemClick: any;
slotDoubleClick: any;
slotClick: any;
taskDoubleClick: any;
taskClick: any;
ksValidator: any;
ksModifyInitialFormValues: any;
}, true, {}, any>;

/**
 * @hidden
 */
export declare const SchedulerActionButtons: DefineComponent<ExtractPropTypes<    {
editSaveMessage: PropType<string>;
editCancelMessage: PropType<string>;
onCancel: PropType<(event: any) => void>;
}>, {}, {}, {}, {
onSubmit(e: any): void;
handleCancel(e: any): void;
}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
editSaveMessage: PropType<string>;
editCancelMessage: PropType<string>;
onCancel: PropType<(event: any) => void>;
}>> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

/**
 * 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[];
}

/**
 * Called every time the user changes the selected `date`.
 * The value is a JavaScript `Date` object.
 */
export declare interface SchedulerDateChangeEvent {
    value: Date;
}

/** @hidden */
export declare const SchedulerDrag: DefineComponent<ExtractPropTypes<    {
ignoreIsAllDay: PropType<boolean>;
dataItem: PropType<any>;
vertical: PropType<boolean>;
viewItem: PropType<any>;
item: {
type: PropType<SchedulerItemProps>;
default: () => DefineComponent<ExtractPropTypes<    {
uid: PropType<string | number>;
start: PropType<Date>;
end: PropType<Date>;
originalStart: PropType<Date>;
startTimezone: PropType<string>;
endTimezone: PropType<string>;
isAllDay: PropType<boolean>;
title: PropType<string>;
description: PropType<string>;
occurrenceId: PropType<string>;
recurrenceExceptions: PropType<Date[]>;
recurrenceRule: PropType<string>;
recurrenceId: PropType<string | number>;
dataItem: PropType<any>;
head: PropType<boolean>;
tail: PropType<boolean>;
order: PropType<number>;
zonedStart: PropType<ZonedDate>;
zonedEnd: PropType<ZonedDate>;
slots: PropType<Slot_3[]>;
group: PropType<Group_3>;
range: PropType<Range_4>;
isException: PropType<boolean>;
isRecurring: PropType<boolean>;
id: PropType<string>;
tabIndex: PropType<number>;
className: PropType<string>;
itemStyle: PropType<any>;
editable: PropType<boolean | EditableProp_2>;
selected: PropType<boolean>;
vertical: PropType<boolean>;
dragHint: PropType<boolean>;
resizeHint: PropType<boolean>;
format: PropType<string>;
maxSiblingsPerSlot: PropType<number>;
itemTitle: PropType<string>;
formItem: PropType<object>;
dragItem: PropType<object>;
resizeItem: PropType<object>;
removeItem: PropType<object>;
ignoreIsAllDay: PropType<boolean>;
item: PropType<string | object | Function>;
showOccurrenceDialog: {
type: PropType<boolean>;
default: any;
};
showRemoveDialog: {
type: PropType<boolean>;
default: any;
};
}>, {}, {}, {
currentEditable(): EditableProp_2;
resource(): any;
color(): any;
currentTabIndex(): any;
itemClassName(): {
[x: number]: any;
'k-event': boolean;
'k-selected': any;
'k-event-drag-hint': any;
'k-scheduler-marquee': any;
'k-marquee': any;
'k-first': boolean;
'k-last': boolean;
};
eventLabel(): string;
computedStyle(): any;
}, {
getElement(): any;
handleFocus(event: any): void;
handleBlur(event: any): void;
handleMouseDown(event: any): void;
handleClick(event: any): void;
handleMouseUp(event: any): void;
handleMouseOver(event: any): void;
handleMouseOut(event: any): void;
handleMouseEnter(event: any): void;
handleMouseLeave(event: any): void;
handleDoubleClick(event: any): void;
handleRemoveClick(event: any): void;
handleKeyDown(event: any): void;
handleKeyPress(event: any): void;
handleKeyUp(event: any): void;
handlePress(dragEvent: any): void;
handleDrag(dragEvent: any): void;
handleRelease(dragEvent: any): void;
handleResizePress(dragEvent: any): void;
handleResizeStartDrag(dragEvent: any): void;
handleResizeEndDrag(dragEvent: any): void;
handleResizeRelease(dragEvent: any): void;
handleFormClose(event: SchedulerFormStateChangeEvent_2<null> | SchedulerOccurrenceDialogStateChangeEvent_2<null>): void;
handleFormSubmit(event: SchedulerFormStateChangeEvent_2<any>): void;
handleFormCancel(event: SchedulerFormStateChangeEvent_2<null> | SchedulerOccurrenceDialogStateChangeEvent_2<null>): void;
}, ComponentOptionsMixin, ComponentOptionsMixin, {
focus: any;
blur: any;
mousedown: any;
mouseup: any;
mouseover: any;
mouseout: any;
mouseenter: any;
mouseleave: any;
click: any;
doubleclick: any;
removeclick: any;
keydown: any;
keypress: any;
keyup: any;
press: any;
drag: any;
release: any;
resizepress: any;
resizestartdrag: any;
resizeenddrag: any;
resizerelease: any;
cancel: any;
close: any;
formsubmit: any;
}, string, PublicProps, Readonly<ExtractPropTypes<    {
uid: PropType<string | number>;
start: PropType<Date>;
end: PropType<Date>;
originalStart: PropType<Date>;
startTimezone: PropType<string>;
endTimezone: PropType<string>;
isAllDay: PropType<boolean>;
title: PropType<string>;
description: PropType<string>;
occurrenceId: PropType<string>;
recurrenceExceptions: PropType<Date[]>;
recurrenceRule: PropType<string>;
recurrenceId: PropType<string | number>;
dataItem: PropType<any>;
head: PropType<boolean>;
tail: PropType<boolean>;
order: PropType<number>;
zonedStart: PropType<ZonedDate>;
zonedEnd: PropType<ZonedDate>;
slots: PropType<Slot_3[]>;
group: PropType<Group_3>;
range: PropType<Range_4>;
isException: PropType<boolean>;
isRecurring: PropType<boolean>;
id: PropType<string>;
tabIndex: PropType<number>;
className: PropType<string>;
itemStyle: PropType<any>;
editable: PropType<boolean | EditableProp_2>;
selected: PropType<boolean>;
vertical: PropType<boolean>;
dragHint: PropType<boolean>;
resizeHint: PropType<boolean>;
format: PropType<string>;
maxSiblingsPerSlot: PropType<number>;
itemTitle: PropType<string>;
formItem: PropType<object>;
dragItem: PropType<object>;
resizeItem: PropType<object>;
removeItem: PropType<object>;
ignoreIsAllDay: PropType<boolean>;
item: PropType<string | object | Function>;
showOccurrenceDialog: {
type: PropType<boolean>;
default: any;
};
showRemoveDialog: {
type: PropType<boolean>;
default: any;
};
}>> & Readonly<{
onPress?: (...args: any[] | unknown[]) => any;
onDrag?: (...args: any[] | unknown[]) => any;
onRelease?: (...args: any[] | unknown[]) => any;
onClick?: (...args: any[] | unknown[]) => any;
onBlur?: (...args: any[] | unknown[]) => any;
onCancel?: (...args: any[] | unknown[]) => any;
onClose?: (...args: any[] | unknown[]) => any;
onFocus?: (...args: any[] | unknown[]) => any;
onKeydown?: (...args: any[] | unknown[]) => any;
onKeypress?: (...args: any[] | unknown[]) => any;
onKeyup?: (...args: any[] | unknown[]) => any;
onMousedown?: (...args: any[] | unknown[]) => any;
onMouseenter?: (...args: any[] | unknown[]) => any;
onMouseleave?: (...args: any[] | unknown[]) => any;
onMouseout?: (...args: any[] | unknown[]) => any;
onMouseover?: (...args: any[] | unknown[]) => any;
onMouseup?: (...args: any[] | unknown[]) => any;
onDoubleclick?: (...args: any[] | unknown[]) => any;
onFormsubmit?: (...args: any[] | unknown[]) => any;
onRemoveclick?: (...args: any[] | unknown[]) => any;
onResizepress?: (...args: any[] | unknown[]) => any;
onResizestartdrag?: (...args: any[] | unknown[]) => any;
onResizeenddrag?: (...args: any[] | unknown[]) => any;
onResizerelease?: (...args: any[] | unknown[]) => any;
}>, {
showOccurrenceDialog: boolean;
showRemoveDialog: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
};
}>, {}, {}, {
occurrences(): Occurrence_3[];
items(): Item_2[];
}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
ignoreIsAllDay: PropType<boolean>;
dataItem: PropType<any>;
vertical: PropType<boolean>;
viewItem: PropType<any>;
item: {
type: PropType<SchedulerItemProps>;
default: () => DefineComponent<ExtractPropTypes<    {
uid: PropType<string | number>;
start: PropType<Date>;
end: PropType<Date>;
originalStart: PropType<Date>;
startTimezone: PropType<string>;
endTimezone: PropType<string>;
isAllDay: PropType<boolean>;
title: PropType<string>;
description: PropType<string>;
occurrenceId: PropType<string>;
recurrenceExceptions: PropType<Date[]>;
recurrenceRule: PropType<string>;
recurrenceId: PropType<string | number>;
dataItem: PropType<any>;
head: PropType<boolean>;
tail: PropType<boolean>;
order: PropType<number>;
zonedStart: PropType<ZonedDate>;
zonedEnd: PropType<ZonedDate>;
slots: PropType<Slot_3[]>;
group: PropType<Group_3>;
range: PropType<Range_4>;
isException: PropType<boolean>;
isRecurring: PropType<boolean>;
id: PropType<string>;
tabIndex: PropType<number>;
className: PropType<string>;
itemStyle: PropType<any>;
editable: PropType<boolean | EditableProp_2>;
selected: PropType<boolean>;
vertical: PropType<boolean>;
dragHint: PropType<boolean>;
resizeHint: PropType<boolean>;
format: PropType<string>;
maxSiblingsPerSlot: PropType<number>;
itemTitle: PropType<string>;
formItem: PropType<object>;
dragItem: PropType<object>;
resizeItem: PropType<object>;
removeItem: PropType<object>;
ignoreIsAllDay: PropType<boolean>;
item: PropType<string | object | Function>;
showOccurrenceDialog: {
type: PropType<boolean>;
default: any;
};
showRemoveDialog: {
type: PropType<boolean>;
default: any;
};
}>, {}, {}, {
currentEditable(): EditableProp_2;
resource(): any;
color(): any;
currentTabIndex(): any;
itemClassName(): {
[x: number]: any;
'k-event': boolean;
'k-selected': any;
'k-event-drag-hint': any;
'k-scheduler-marquee': any;
'k-marquee': any;
'k-first': boolean;
'k-last': boolean;
};
eventLabel(): string;
computedStyle(): any;
}, {
getElement(): any;
handleFocus(event: any): void;
handleBlur(event: any): void;
handleMouseDown(event: any): void;
handleClick(event: any): void;
handleMouseUp(event: any): void;
handleMouseOver(event: any): void;
handleMouseOut(event: any): void;
handleMouseEnter(event: any): void;
handleMouseLeave(event: any): void;
handleDoubleClick(event: any): void;
handleRemoveClick(event: any): void;
handleKeyDown(event: any): void;
handleKeyPress(event: any): void;
handleKeyUp(event: any): void;
handlePress(dragEvent: any): void;
handleDrag(dragEvent: any): void;
handleRelease(dragEvent: any): void;
handleResizePress(dragEvent: any): void;
handleResizeStartDrag(dragEvent: any): void;
handleResizeEndDrag(dragEvent: any): void;
handleResizeRelease(dragEvent: any): void;
handleFormClose(event: SchedulerFormStateChangeEvent_2<null> | SchedulerOccurrenceDialogStateChangeEvent_2<null>): void;
handleFormSubmit(event: SchedulerFormStateChangeEvent_2<any>): void;
handleFormCancel(event: SchedulerFormStateChangeEvent_2<null> | SchedulerOccurrenceDialogStateChangeEvent_2<null>): void;
}, ComponentOptionsMixin, ComponentOptionsMixin, {
focus: any;
blur: any;
mousedown: any;
mouseup: any;
mouseover: any;
mouseout: any;
mouseenter: any;
mouseleave: any;
click: any;
doubleclick: any;
removeclick: any;
keydown: any;
keypress: any;
keyup: any;
press: any;
drag: any;
release: any;
resizepress: any;
resizestartdrag: any;
resizeenddrag: any;
resizerelease: any;
cancel: any;
close: any;
formsubmit: any;
}, string, PublicProps, Readonly<ExtractPropTypes<    {
uid: PropType<string | number>;
start: PropType<Date>;
end: PropType<Date>;
originalStart: PropType<Date>;
startTimezone: PropType<string>;
endTimezone: PropType<string>;
isAllDay: PropType<boolean>;
title: PropType<string>;
description: PropType<string>;
occurrenceId: PropType<string>;
recurrenceExceptions: PropType<Date[]>;
recurrenceRule: PropType<string>;
recurrenceId: PropType<string | number>;
dataItem: PropType<any>;
head: PropType<boolean>;
tail: PropType<boolean>;
order: PropType<number>;
zonedStart: PropType<ZonedDate>;
zonedEnd: PropType<ZonedDate>;
slots: PropType<Slot_3[]>;
group: PropType<Group_3>;
range: PropType<Range_4>;
isException: PropType<boolean>;
isRecurring: PropType<boolean>;
id: PropType<string>;
tabIndex: PropType<number>;
className: PropType<string>;
itemStyle: PropType<any>;
editable: PropType<boolean | EditableProp_2>;
selected: PropType<boolean>;
vertical: PropType<boolean>;
dragHint: PropType<boolean>;
resizeHint: PropType<boolean>;
format: PropType<string>;
maxSiblingsPerSlot: PropType<number>;
itemTitle: PropType<string>;
formItem: PropType<object>;
dragItem: PropType<object>;
resizeItem: PropType<object>;
removeItem: PropType<object>;
ignoreIsAllDay: PropType<boolean>;
item: PropType<string | object | Function>;
showOccurrenceDialog: {
type: PropType<boolean>;
default: any;
};
showRemoveDialog: {
type: PropType<boolean>;
default: any;
};
}>> & Readonly<{
onPress?: (...args: any[] | unknown[]) => any;
onDrag?: (...args: any[] | unknown[]) => any;
onRelease?: (...args: any[] | unknown[]) => any;
onClick?: (...args: any[] | unknown[]) => any;
onBlur?: (...args: any[] | unknown[]) => any;
onCancel?: (...args: any[] | unknown[]) => any;
onClose?: (...args: any[] | unknown[]) => any;
onFocus?: (...args: any[] | unknown[]) => any;
onKeydown?: (...args: any[] | unknown[]) => any;
onKeypress?: (...args: any[] | unknown[]) => any;
onKeyup?: (...args: any[] | unknown[]) => any;
onMousedown?: (...args: any[] | unknown[]) => any;
onMouseenter?: (...args: any[] | unknown[]) => any;
onMouseleave?: (...args: any[] | unknown[]) => any;
onMouseout?: (...args: any[] | unknown[]) => any;
onMouseover?: (...args: any[] | unknown[]) => any;
onMouseup?: (...args: any[] | unknown[]) => any;
onDoubleclick?: (...args: any[] | unknown[]) => any;
onFormsubmit?: (...args: any[] | unknown[]) => any;
onRemoveclick?: (...args: any[] | unknown[]) => any;
onResizepress?: (...args: any[] | unknown[]) => any;
onResizestartdrag?: (...args: any[] | unknown[]) => any;
onResizeenddrag?: (...args: any[] | unknown[]) => any;
onResizerelease?: (...args: any[] | unknown[]) => any;
}>, {
showOccurrenceDialog: boolean;
showRemoveDialog: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
};
}>> & Readonly<{}>, {
item: SchedulerItemProps;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

/**
 * Represents the props of the Kendo UI for Vue [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?: any;
    /**
     * Overrides the default component responsible for positioning the item inside the view.
     *
     * The default Component is: [SchedulerViewItem]().
     */
    viewItem?: any;
}

/**
 * @hidden
 */
export declare const SchedulerEditItem: DefineComponent<ExtractPropTypes<    {
tabIndex: {
type: PropType<number>;
default: any;
};
item: PropType<any>;
viewItem: PropType<any>;
drag: PropType<any>;
resize: PropType<any>;
form: PropType<any>;
removeDialog: PropType<any>;
occurrenceDialog: PropType<any>;
formItem: PropType<any>;
dragItem: PropType<any>;
resizeItem: PropType<any>;
removeItem: PropType<any>;
showOccurrenceDialog: {
type: PropType<boolean>;
default: any;
};
showRemoveDialog: {
type: PropType<boolean>;
default: any;
};
series: {
type: PropType<boolean>;
default: any;
};
uid: PropType<string | number>;
start: PropType<Date>;
end: PropType<Date>;
originalStart: PropType<Date>;
startTimezone: PropType<string>;
endTimezone: PropType<string>;
isAllDay: PropType<boolean>;
title: PropType<string>;
description: PropType<string>;
occurrenceId: PropType<string>;
recurrenceExceptions: PropType<Date[]>;
recurrenceRule: PropType<string>;
recurrenceId: PropType<string | number>;
dataItem: PropType<any>;
head: PropType<boolean>;
tail: PropType<boolean>;
order: PropType<number>;
zonedStart: PropType<ZonedDate>;
zonedEnd: PropType<ZonedDate>;
slots: PropType<Slot_4[]>;
group: PropType<Group_2>;
range: PropType<Range_5>;
isException: PropType<boolean>;
isRecurring: PropType<boolean>;
id: PropType<string>;
className: PropType<string>;
itemStyle: PropType<any>;
editable: PropType<boolean | EditableProp_3>;
selected: PropType<boolean>;
vertical: PropType<boolean>;
dragHint: PropType<boolean>;
resizeHint: PropType<boolean>;
format: PropType<string>;
ignoreIsAllDay: PropType<boolean>;
itemRef: PropType<any>;
onRemoveclick: PropType<(e: any) => void>;
onDataaction: PropType<(action: DataAction, event?: any) => void>;
onFormItemChange: PropType<(event: SchedulerEditItemStateChangeEvent<DataItem | null>) => void>;
onDragitemchange: PropType<(event: SchedulerEditItemStateChangeEvent<DataItem | null>) => void>;
onResizeitemchange: PropType<(event: SchedulerEditItemStateChangeEvent<DataItem | null>) => void>;
}>, {}, {
ei: {
props: {
readonly drag?: any;
readonly form?: any;
readonly head?: boolean;
readonly title?: string;
readonly vertical?: boolean;
readonly id?: string;
readonly tabIndex?: number;
readonly resize?: any;
readonly slots?: Slot_4[];
readonly description?: string;
readonly end?: Date;
readonly start?: Date;
readonly format?: string;
readonly selected?: boolean;
readonly className?: string;
readonly group?: Group_2;
readonly dataItem?: any;
readonly item?: any;
readonly range?: Range_5;
readonly order?: number;
readonly isAllDay?: boolean;
readonly zonedStart?: ZonedDate;
readonly zonedEnd?: ZonedDate;
readonly editable?: boolean | EditableProp_3;
readonly formItem?: any;
readonly uid?: string | number;
readonly originalStart?: Date;
readonly startTimezone?: string;
readonly endTimezone?: string;
readonly occurrenceId?: string;
readonly recurrenceExceptions?: Date[];
readonly recurrenceRule?: string;
readonly recurrenceId?: string | number;
readonly tail?: boolean;
readonly isException?: boolean;
readonly isRecurring?: boolean;
readonly itemStyle?: any;
readonly dragHint?: boolean;
readonly resizeHint?: boolean;
readonly dragItem?: any;
readonly resizeItem?: any;
readonly removeItem?: any;
readonly ignoreIsAllDay?: boolean;
readonly showOccurrenceDialog?: boolean;
readonly showRemoveDialog?: boolean;
readonly onRemoveclick?: (e: any) => void;
readonly onDataaction?: (action: DataAction, event?: any) => void;
readonly itemRef?: any;
readonly removeDialog?: any;
readonly occurrenceDialog?: any;
readonly series?: boolean;
readonly viewItem?: any;
readonly onFormItemChange?: (event: SchedulerEditItemStateChangeEvent<DataItem | null>) => void;
readonly onDragitemchange?: (event: SchedulerEditItemStateChangeEvent<DataItem | null>) => void;
readonly onResizeitemchange?: (event: SchedulerEditItemStateChangeEvent<DataItem | null>) => void;
} & Readonly<ExtractPropTypes<    {
tabIndex: {
type: PropType<number>;
default: any;
};
item: PropType<any>;
viewItem: PropType<any>;
drag: PropType<any>;
resize: PropType<any>;
form: PropType<any>;
removeDialog: PropType<any>;
occurrenceDialog: PropType<any>;
formItem: PropType<any>;
dragItem: PropType<any>;
resizeItem: PropType<any>;
removeItem: PropType<any>;
showOccurrenceDialog: {
type: PropType<boolean>;
default: any;
};
showRemoveDialog: {
type: PropType<boolean>;
default: any;
};
series: {
type: PropType<boolean>;
default: any;
};
uid: PropType<string | number>;
start: PropType<Date>;
end: PropType<Date>;
originalStart: PropType<Date>;
startTimezone: PropType<string>;
endTimezone: PropType<string>;
isAllDay: PropType<boolean>;
title: PropType<string>;
description: PropType<string>;
occurrenceId: PropType<string>;
recurrenceExceptions: PropType<Date[]>;
recurrenceRule: PropType<string>;
recurrenceId: PropType<string | number>;
dataItem: PropType<any>;
head: PropType<boolean>;
tail: PropType<boolean>;
order: PropType<number>;
zonedStart: PropType<ZonedDate>;
zonedEnd: PropType<ZonedDate>;
slots: PropType<Slot_4[]>;
group: PropType<Group_2>;
range: PropType<Range_5>;
isException: PropType<boolean>;
isRecurring: PropType<boolean>;
id: PropType<string>;
className: PropType<string>;
itemStyle: PropType<any>;
editable: PropType<boolean | EditableProp_3>;
selected: PropType<boolean>;
vertical: PropType<boolean>;
dragHint: PropType<boolean>;
resizeHint: PropType<boolean>;
format: PropType<string>;
ignoreIsAllDay: PropType<boolean>;
itemRef: PropType<any>;
onRemoveclick: PropType<(e: any) => void>;
onDataaction: PropType<(action: DataAction, event?: any) => void>;
onFormItemChange: PropType<(event: SchedulerEditItemStateChangeEvent<DataItem | null>) => void>;
onDragitemchange: PropType<(event: SchedulerEditItemStateChangeEvent<DataItem | null>) => void>;
onResizeitemchange: PropType<(event: SchedulerEditItemStateChangeEvent<DataItem | null>) => void>;
}>> & Readonly<{}>;
form: any;
drag: any;
resize: any;
remove: Function;
showRemoveDialog: boolean;
showOccurrenceDialog: boolean;
};
currentFormItem: any;
currentSelected: any;
currentSeries: any;
currentRemoveItem: any;
currentDragItem: any;
currentResizeItem: any;
currentShowRemoveDialog: any;
currentShowOccurrenceDialog: any;
}, {
currentTabIndex(): any;
compSelected(): any;
compSeries(): any;
compFormItem(): any;
compRemoveItem(): any;
compDragItem(): any;
compResizeItem(): any;
compShowRemoveDialog(): any;
compShowOccurrenceDialog(): any;
actionsReducerMap(): {
SERIES_SET: any;
SERIES_TOGGLE: any;
SERIES_RESET: any;
ITEMS_SELECT_SELECT: any;
ITEMS_SELECT_ADD: any;
ITEMS_SELECT_REMOVE: any;
ITEMS_SELECT_RESET: any;
ITEMS_SELECT_SELECT_NEXT: any;
ITEMS_SELECT_SELECT_PREV: any;
FORM_ITEM_SET: any;
FORM_ITEM_SET_MASTER: any;
FORM_ITEM_RESET: any;
FORM_ITEM_COMPLETE: any;
REMOVE_ITEM_SET: any;
REMOVE_ITEM_RESET: any;
REMOVE_ITEM_COMPLETE: any;
SHOW_OCCURRENCE_DIALOG_CLOSE: any;
SHOW_OCCURRENCE_DIALOG_OPEN: any;
SHOW_OCCURRENCE_DIALOG_SET: any;
SHOW_OCCURRENCE_DIALOG_TOGGLE: any;
SHOW_OCCURRENCE_DIALOG_RESET: any;
SHOW_REMOVE_DIALOG_CLOSE: any;
SHOW_REMOVE_DIALOG_OPEN: any;
SHOW_REMOVE_DIALOG_SET: any;
SHOW_REMOVE_DIALOG_TOGGLE: any;
SHOW_REMOVE_DIALOG_RESET: any;
DRAG_ITEM_START: any;
DRAG_ITEM_DRAG: any;
DRAG_ITEM_COMPLETE: any;
DRAG_ITEM_COMPLETE_OCCURRENCE: any;
DRAG_ITEM_COMPLETE_SERIES: any;
DRAG_ITEM_SET: any;
DRAG_ITEM_RESET: any;
DRAG_ITEM_DRAG_SELECTED: any;
RESIZE_ITEM_START: any;
RESIZE_ITEM_START_DRAG: any;
RESIZE_ITEM_START_DRAG_SELECTED: any;
RESIZE_ITEM_END_DRAG: any;
RESIZE_ITEM_END_DRAG_SELECTED: any;
RESIZE_ITEM_COMPLETE: any;
RESIZE_ITEM_COMPLETE_OCCURRENCE: any;
RESIZE_ITEM_COMPLETE_SERIES: any;
RESIZE_ITEM_SET: any;
RESIZE_ITEM_RESET: any;
ITEMS_FOCUS_NEXT: any;
ITEMS_FOCUS_PREV: any;
SLOT_FOCUS_LEFT: any;
SLOT_FOCUS_RIGHT: any;
SLOT_FOCUS_UP: any;
SLOT_FOCUS_DOWN: any;
null: () => void;
};
}, {
dispatchSeries(action: any, _event: any): void;
dispatchItemSelection(action: any, event: any): void;
dispatchRemoveItem(action: any, _event: any): void;
dispatchShowOccurrenceDialog(action: any, _event: any): void;
dispatchShowRemoveDialog(action: any, _event: any): void;
dispatchDragItem(action: any, _event: any): void;
dispatchResizeItem(action: any, event: any): void;
dispatchViewSlotsFocus(action: any, event: any): void;
dispatchViewItemsFocus(action: any, event: any): void;
dispatchFormItem(action: any, _event: any): void;
handleFocus(event: SchedulerItemFocusEvent): void;
handleMouseDown(event: SchedulerItemMouseEvent): void;
handleMouseUp(event: SchedulerItemMouseEvent): void;
handleClick(event: SchedulerItemMouseEvent): void;
handleDoubleClick(event: SchedulerItemMouseEvent): void;
handleRemoveClick(event: SchedulerItemMouseEvent): void;
handlePress(event: SchedulerItemDragEvent): void;
handleDrag(event: SchedulerItemDragEvent): void;
handleRelease(event: SchedulerItemDragEvent): void;
handleResizePress(event: SchedulerItemDragEvent): void;
handleResizeStartDrag(event: SchedulerItemDragEvent): void;
handleResizeEndDrag(event: SchedulerItemDragEvent): void;
handleResizeRelease(event: SchedulerItemDragEvent): void;
handleFormSubmit(event: SchedulerFormStateChangeEvent<DataItem | null>): void;
handleCancel(event: SchedulerFormStateChangeEvent<null> | SchedulerOccurrenceDialogStateChangeEvent<null>): void;
handleOccurrenceClick(event: SchedulerOccurrenceDialogStateChangeEvent<null>): void;
handleSeriesClick(event: SchedulerOccurrenceDialogStateChangeEvent<null>): void;
handleKeyDown(event: SchedulerItemKeyboardEvent): void;
handleKeyUp(event: SchedulerItemKeyboardEvent): void;
handleRemoveConfirm(event: SchedulerRemoveDialogStateChangeEvent<null>): void;
onClickAction(event: SchedulerItemMouseEvent, _: SchedulerEditItemProps): {
type: ITEMS_SELECT_ACTION;
}[];
onDoubleClickAction(_: any, props: SchedulerEditItemProps): ({
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): any[] | {
type: DRAG_ITEM_ACTION;
payload: {
x: number;
y: number;
};
};
onDragAction(event: SchedulerItemDragEvent, props: SchedulerEditItemProps): any[] | {
type: DRAG_ITEM_ACTION;
payload: {
x: number;
y: number;
};
};
onReleaseAction(event: SchedulerItemDragEvent, props: SchedulerEditItemProps): any[] | {
type: SHOW_OCCURRENCE_DIALOG_ACTION;
payload?: undefined;
} | {
type: DRAG_ITEM_ACTION;
payload: {
x: number;
y: number;
};
};
onResizePressAction(event: SchedulerItemDragEvent, props: SchedulerEditItemProps): any[] | {
type: RESIZE_ITEM_ACTION;
payload: {
x: number;
y: number;
};
};
onResizeStartDragAction(event: SchedulerItemDragEvent, props: SchedulerEditItemProps): any[] | {
type: RESIZE_ITEM_ACTION;
payload: {
x: number;
y: number;
};
};
onResizeEndDragAction(event: SchedulerItemDragEvent, props: SchedulerEditItemProps): any[] | {
type: RESIZE_ITEM_ACTION;
payload: {
x: number;
y: number;
};
};
onResizeReleaseAction(event: SchedulerItemDragEvent, props: SchedulerEditItemProps): any[] | {
type: SHOW_OCCURRENCE_DIALOG_ACTION;
payload?: undefined;
} | {
type: RESIZE_ITEM_ACTION;
payload: {
x: number;
y: number;
};
};
onOccurrenceClickAction(_event: SchedulerOccurrenceDialogStateChangeEvent<any>, props: SchedulerEditItemProps): ({
type: DRAG_ITEM_ACTION;
} | {
type: SHOW_OCCURRENCE_DIALOG_ACTION;
})[] | ({
type: RESIZE_ITEM_ACTION;
} | {
type: SHOW_OCCURRENCE_DIALOG_ACTION;
})[] | ({
type: SERIES_ACTION;
payload: boolean;
} | {
type: FORM_ITEM_ACTION;
payload: any;
} | {
type: SHOW_OCCURRENCE_DIALOG_ACTION;
payload?: undefined;
})[] | ({
type: SERIES_ACTION;
payload: boolean;
} | {
type: REMOVE_ITEM_ACTION;
payload: any;
} | {
type: SHOW_REMOVE_DIALOG_ACTION;
payload?: undefined;
} | {
type: SHOW_OCCURRENCE_DIALOG_ACTION;
payload?: undefined;
})[];
onSeriesClickAction(_event: SchedulerOccurrenceDialogStateChangeEvent<any>, props: SchedulerEditItemProps): ({
type: DRAG_ITEM_ACTION;
} | {
type: SHOW_OCCURRENCE_DIALOG_ACTION;
})[] | ({
type: RESIZE_ITEM_ACTION;
} | {
type: SHOW_OCCURRENCE_DIALOG_ACTION;
})[] | ({
type: SERIES_ACTION;
payload: boolean;
} | {
type: FORM_ITEM_ACTION;
payload: any;
} | {
type: SHOW_OCCURRENCE_DIALOG_ACTION;
payload?: undefined;
})[] | ({
type: SERIES_ACTION;
payload: boolean;
} | {
type: REMOVE_ITEM_ACTION;
payload: any;
} | {
type: SHOW_REMOVE_DIALOG_ACTION;
payload?: undefined;
} | {
type: SHOW_OCCURRENCE_DIALOG_ACTION;
payload?: undefined;
})[];
onKeyDownAction(event: SchedulerItemKeyboardEvent, props: SchedulerEditItemProps): ({
type: FORM_ITEM_ACTION;
payload: any;
} | {
type: SHOW_OCCURRENCE_DIALOG_ACTION;
payload?: undefined;
})[] | ({
type: ITEMS_FOCUS_ACTION;
ignoreIsAllDay: boolean;
} | {
type: ITEMS_SELECT_ACTION;
ignoreIsAllDay: boolean;
})[] | {
type: SLOTS_FOCUS_ACTION;
slot: any;
}[] | ({
type: REMOVE_ITEM_ACTION;
payload: any;
} | {
type: SHOW_OCCURRENCE_DIALOG_ACTION;
payload?: undefined;
} | {
type: SHOW_REMOVE_DIALOG_ACTION;
payload?: undefined;
})[];
onFormSubmitAction(event: SchedulerFormStateChangeEvent<DataItem | null>): {
type: FORM_ITEM_ACTION;
payload: any;
};
onRemoveConfirmAction(): ({
type: REMOVE_ITEM_ACTION;
} | {
type: SHOW_OCCURRENCE_DIALOG_ACTION;
})[];
onCancelAction(): ({
type: SERIES_ACTION;
} | {
type: REMOVE_ITEM_ACTION;
} | {
type: FORM_ITEM_ACTION;
} | {
type: DRAG_ITEM_ACTION;
} | {
type: RESIZE_ITEM_ACTION;
} | {
type: SHOW_REMOVE_DIALOG_ACTION;
} | {
type: SHOW_OCCURRENCE_DIALOG_ACTION;
})[];
}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
tabIndex: {
type: PropType<number>;
default: any;
};
item: PropType<any>;
viewItem: PropType<any>;
drag: PropType<any>;
resize: PropType<any>;
form: PropType<any>;
removeDialog: PropType<any>;
occurrenceDialog: PropType<any>;
formItem: PropType<any>;
dragItem: PropType<any>;
resizeItem: PropType<any>;
removeItem: PropType<any>;
showOccurrenceDialog: {
type: PropType<boolean>;
default: any;
};
showRemoveDialog: {
type: PropType<boolean>;
default: any;
};
series: {
type: PropType<boolean>;
default: any;
};
uid: PropType<string | number>;
start: PropType<Date>;
end: PropType<Date>;
originalStart: PropType<Date>;
startTimezone: PropType<string>;
endTimezone: PropType<string>;
isAllDay: PropType<boolean>;
title: PropType<string>;
description: PropType<string>;
occurrenceId: PropType<string>;
recurrenceExceptions: PropType<Date[]>;
recurrenceRule: PropType<string>;
recurrenceId: PropType<string | number>;
dataItem: PropType<any>;
head: PropType<boolean>;
tail: PropType<boolean>;
order: PropType<number>;
zonedStart: PropType<ZonedDate>;
zonedEnd: PropType<ZonedDate>;
slots: PropType<Slot_4[]>;
group: PropType<Group_2>;
range: PropType<Range_5>;
isException: PropType<boolean>;
isRecurring: PropType<boolean>;
id: PropType<string>;
className: PropType<string>;
itemStyle: PropType<any>;
editable: PropType<boolean | EditableProp_3>;
selected: PropType<boolean>;
vertical: PropType<boolean>;
dragHint: PropType<boolean>;
resizeHint: PropType<boolean>;
format: PropType<string>;
ignoreIsAllDay: PropType<boolean>;
itemRef: PropType<any>;
onRemoveclick: PropType<(e: any) => void>;
onDataaction: PropType<(action: DataAction, event?: any) => void>;
onFormItemChange: PropType<(event: SchedulerEditItemStateChangeEvent<DataItem | null>) => void>;
onDragitemchange: PropType<(event: SchedulerEditItemStateChangeEvent<DataItem | null>) => void>;
onResizeitemchange: PropType<(event: SchedulerEditItemStateChangeEvent<DataItem | null>) => void>;
}>> & Readonly<{}>, {
tabIndex: number;
showOccurrenceDialog: boolean;
showRemoveDialog: boolean;
series: boolean;
}, {}, {}, {}, string, () => {
ei: any;
ksCancel: any;
ksFormSubmit: any;
ksOccurrenceClick: any;
ksSeriesClick: any;
ksRemoveConfirm: any;
}, true, {}, any>;

/**
 * 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;

/**
 * @hidden
 */
export declare interface SchedulerEditItemHandle {
    element: HTMLDivElement | null;
    props: SchedulerEditItemProps;
}

/**
 * Represents the props of the Kendo UI for Vue [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_schedulerviewitemprops %}).
     */
    viewItem?: any;
    /**
     * Overrides the default component responsible for visualizing the `dragItem`.
     *
     * The default Component is: [SchedulerDrag]({% slug api_scheduler_schedulerdragprops %}).
     */
    drag?: any;
    /**
     * Overrides the default component responsible for visualizing the `resizeItem`.
     *
     * The default Component is: [SchedulerResize]({% slug api_scheduler_schedulerresizeprops %}).
     */
    resize?: any;
    /**
     * Overrides the default component responsible for visualizing the `formItem`.
     *
     * The default Component is: [SchedulerForm]({% slug api_scheduler_schedulerformprops %}).
     */
    form?: any;
    /**
     * Overrides the default component responsible for visualizing the `removeItem` and confirming the `remove` action.
     *
     * The default Component is: [SchedulerRemoveDialog]({% slug api_scheduler_schedulerremovedialogprops %}).
     */
    removeDialog?: any;
    /**
     * Overrides the default component responsible for the selection between `occurrence` and `series` edit.
     *
     * The default Component is: [SchedulerOccurrenceDialog]({% slug api_scheduler_scheduleroccurrencedialogprops %}).
     */
    occurrenceDialog?: any;
    /**
     * 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)[];
}

/**
 * @hidden
 */
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;
}

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

/**
 * @hidden
 */
export declare const SchedulerEditSlot: DefineComponent<ExtractPropTypes<    {
tabIndex: {
type: PropType<number>;
default: any;
};
className: PropType<string>;
form: PropType<any>;
formItem: PropType<any>;
refTo: PropType<any>;
items: PropType<Item_4[]>;
row: PropType<number>;
group: PropType<Group_2>;
range: PropType<Range_5>;
isWorkDay: {
type: PropType<boolean>;
default: boolean;
};
isWorkHour: {
type: PropType<boolean>;
default: boolean;
};
selected: PropType<boolean>;
col: PropType<number>;
index: PropType<number>;
start: PropType<Date>;
end: PropType<Date>;
zonedStart: PropType<ZonedDate>;
zonedEnd: PropType<ZonedDate>;
isAllDay: PropType<boolean>;
expandable: PropType<boolean | SchedulerSlotExpandableConfig_2>;
slotRender: PropType<any>;
viewSlot: PropType<any>;
navDay: PropType<boolean>;
editable: PropType<boolean | EditableProp_3>;
itemsPerSlot: PropType<number>;
onDataaction: PropType<(action: DataAction, event: any) => void>;
}>, {}, {
currentFormItem: any;
}, {
cSlot(): any;
currentTabIndex(): any;
computedEditable(): EditableProp_3;
compFormItem(): any;
}, {
handleShowMoreItemsClick(event: any): void;
createDataItemFromSlot(): any;
handleFocus(event: SchedulerSlotFocusEvent): void;
handleDoubleClick(event: SchedulerSlotMouseEvent): void;
handleKeyDown(event: SchedulerSlotKeyboardEvent): void;
handleEditFormSubmit(event: SchedulerFormStateChangeEvent<DataItem | null>): void;
handleEditFormCancel(event: SchedulerFormStateChangeEvent<null>): void;
handleEditFormClose(event: SchedulerFormStateChangeEvent<null>): void;
handleFormItemChange(value: DataItem | null, event?: any): void;
setFormItem(dataItem: DataItem | null, event: any): void;
}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
tabIndex: {
type: PropType<number>;
default: any;
};
className: PropType<string>;
form: PropType<any>;
formItem: PropType<any>;
refTo: PropType<any>;
items: PropType<Item_4[]>;
row: PropType<number>;
group: PropType<Group_2>;
range: PropType<Range_5>;
isWorkDay: {
type: PropType<boolean>;
default: boolean;
};
isWorkHour: {
type: PropType<boolean>;
default: boolean;
};
selected: PropType<boolean>;
col: PropType<number>;
index: PropType<number>;
start: PropType<Date>;
end: PropType<Date>;
zonedStart: PropType<ZonedDate>;
zonedEnd: PropType<ZonedDate>;
isAllDay: PropType<boolean>;
expandable: PropType<boolean | SchedulerSlotExpandableConfig_2>;
slotRender: PropType<any>;
viewSlot: PropType<any>;
navDay: PropType<boolean>;
editable: PropType<boolean | EditableProp_3>;
itemsPerSlot: PropType<number>;
onDataaction: PropType<(action: DataAction, event: any) => void>;
}>> & Readonly<{}>, {
tabIndex: number;
isWorkDay: boolean;
isWorkHour: boolean;
}, {}, {}, {}, string, () => {
ksEditFormSubmit: any;
ksEditFormCancel: any;
ksEditFormClose: any;
}, true, {}, any>;

/** @hidden */
export declare interface SchedulerEditSlotHandle {
    props: SchedulerEditSlotProps;
}

/**
 * Represents the props of the Kendo UI for Vue [SchedulerEditSlot]({% slug api_scheduler_schedulereditslotprops %}) component.
 */
export declare interface SchedulerEditSlotProps extends SchedulerViewSlotProps {
    /**
     * Overrides the default component responsible for view-specific functionality.
     *
     * The default Component is: [SchedulerViewSlot]({% slug api_scheduler_schedulerviewslotprops %}).
     */
    viewSlot?: any;
    /**
     * Overrides the default component responsible for visualizing the `formItem`.
     *
     * The default Component is: [SchedulerForm]({% slug api_scheduler_schedulerformprops %}).
     */
    form?: any;
    /**
     * 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;
}

/**
 * @hidden
 */
export declare const SchedulerEditTask: DefineComponent<ExtractPropTypes<    {
viewTask: PropType<any>;
removeDialog: PropType<any>;
removeItem: PropType<any>;
occurrenceDialog: PropType<any>;
task: PropType<any>;
showOccurrenceDialog: {
type: PropType<boolean>;
default: any;
};
showRemoveDialog: {
type: PropType<boolean>;
default: any;
};
series: {
type: PropType<boolean>;
default: any;
};
refTo: PropType<HTMLDivElement>;
id: PropType<string>;
tabIndex: PropType<number>;
editable: PropType<boolean | EditableProp_3>;
head: PropType<boolean>;
tail: PropType<boolean>;
order: PropType<number>;
zonedStart: PropType<ZonedDate>;
zonedEnd: PropType<ZonedDate>;
slots: PropType<Slot_4[]>;
group: PropType<Group_2>;
range: PropType<Range_5>;
isException: PropType<boolean>;
isRecurring: PropType<boolean>;
isAllDay: PropType<boolean>;
uid: PropType<string | number>;
start: PropType<Date>;
end: PropType<Date>;
originalStart: PropType<Date>;
startTimezone: PropType<string>;
endTimezone: PropType<string>;
title: PropType<string>;
description: PropType<string>;
occurrenceId: PropType<string>;
recurrenceExceptions: PropType<Date[]>;
recurrenceRule: PropType<string>;
recurrenceId: PropType<string | number>;
dataItem: PropType<any>;
}>, {}, {
et: {
removeItem: any;
showRemoveDialog: boolean;
showOccurrenceDialog: boolean;
};
currentSeries: any;
currentRemoveItem: any;
currentShowRemoveDialog: any;
currentShowOccurrenceDialog: any;
}, {
compSeries(): any;
compRemoveItem(): any;
compShowRemoveDialog(): any;
compShowOccurrenceDialog(): any;
currentEditable(): EditableProp_3;
}, {
setRemoveItem(item: any, event: any): void;
setShowRemoveDialog(show: boolean, event: any): void;
setShowOccurrenceDialog(show: boolean, event: any): void;
handleRemoveClick(event: SchedulerTaskMouseEvent): void;
handleCancel(event: SchedulerFormStateChangeEvent<null> | SchedulerOccurrenceDialogStateChangeEvent<null>): void;
handleRemoveConfirm(event: SchedulerRemoveDialogStateChangeEvent<null>): void;
handleRemoveItemChange(value: DataItem | null, event?: any): void;
handleRemoveDialogChange(value: boolean, event?: any): void;
handleOccurrenceDialogChange(value: boolean, event?: any): void;
handleOccurrenceClick(event: SchedulerOccurrenceDialogStateChangeEvent<null>): void;
handleSeriesClick(event: SchedulerOccurrenceDialogStateChangeEvent<null>): void;
}, ComponentOptionsMixin, ComponentOptionsMixin, ("dataaction" | "showremovedialogchange" | "showoccurrencedialogchange" | "removeitemchange")[], "dataaction" | "showremovedialogchange" | "showoccurrencedialogchange" | "removeitemchange", PublicProps, Readonly<ExtractPropTypes<    {
viewTask: PropType<any>;
removeDialog: PropType<any>;
removeItem: PropType<any>;
occurrenceDialog: PropType<any>;
task: PropType<any>;
showOccurrenceDialog: {
type: PropType<boolean>;
default: any;
};
showRemoveDialog: {
type: PropType<boolean>;
default: any;
};
series: {
type: PropType<boolean>;
default: any;
};
refTo: PropType<HTMLDivElement>;
id: PropType<string>;
tabIndex: PropType<number>;
editable: PropType<boolean | EditableProp_3>;
head: PropType<boolean>;
tail: PropType<boolean>;
order: PropType<number>;
zonedStart: PropType<ZonedDate>;
zonedEnd: PropType<ZonedDate>;
slots: PropType<Slot_4[]>;
group: PropType<Group_2>;
range: PropType<Range_5>;
isException: PropType<boolean>;
isRecurring: PropType<boolean>;
isAllDay: PropType<boolean>;
uid: PropType<string | number>;
start: PropType<Date>;
end: PropType<Date>;
originalStart: PropType<Date>;
startTimezone: PropType<string>;
endTimezone: PropType<string>;
title: PropType<string>;
description: PropType<string>;
occurrenceId: PropType<string>;
recurrenceExceptions: PropType<Date[]>;
recurrenceRule: PropType<string>;
recurrenceId: PropType<string | number>;
dataItem: PropType<any>;
}>> & Readonly<{
onDataaction?: (...args: any[]) => any;
onShowremovedialogchange?: (...args: any[]) => any;
onShowoccurrencedialogchange?: (...args: any[]) => any;
onRemoveitemchange?: (...args: any[]) => any;
}>, {
showOccurrenceDialog: boolean;
showRemoveDialog: boolean;
series: boolean;
}, {}, {}, {}, string, () => {
et: any;
removeTask: any;
removeDialog: any;
occurrenceDialog: any;
ksCancel: any;
ksSeriesClick: any;
ksOccurrenceClick: any;
ksRemoveConfirm: any;
}, true, {}, any>;

/** @hidden */
export declare interface SchedulerEditTaskHandle {
    element: HTMLDivElement | null;
    props: SchedulerEditTaskProps;
}

/**
 * Represents the props of the Kendo UI for Vue [SchedulerEditTask]({% slug api_scheduler_scheduleredittaskprops %}) 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_schedulerviewtaskprops %}).
     */
    viewTask?: any;
    /**
     * Overrides the default component responsible for visualizing the `removeItem` and confirming the `remove` action.
     *
     * The default Component is: [SchedulerRemoveDialog]({% slug api_scheduler_schedulerremovedialogprops %}).
     */
    removeDialog?: any;
    /**
     * Setting this property will force the `showRemoveDialog` to be in controlled state, allowing further control over the display of the `removeDialog` component.
     */
    showRemoveDialog?: boolean;
    /**
     * 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 `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_scheduleroccurrencedialogprops %}).
     */
    occurrenceDialog?: any;
    /**
     * 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;
}

/**
 * @hidden
 */
export declare const SchedulerFooter: DefineComponent<    {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

/** @hidden */
export declare interface SchedulerFooterHandle {
    element: HTMLDivElement | null;
    props: SchedulerFooterProps;
}

export declare interface SchedulerFooterProps extends ToolbarProps {
}

/**
 * @hidden
 */
export declare const SchedulerForm: DefineComponent<ExtractPropTypes<    {
dataItem: PropType<any>;
}>, {
kendoLocalizationService: {};
}, {
media: string;
}, {}, {
calculateMedia(): void;
handleCancel(event: any): void;
handleClose({ event }: DialogCloseEvent): void;
handleSubmit(dataItem: DataItem, event: any): void;
startAfterEndValidator(value: any, formValueGetter: any): any;
endAfterStartValidator(value: any, formValueGetter: any): any;
requiredValidator(value: any): any;
formValidator(_dataItem: any, formValueGetter: any): any;
}, ComponentOptionsMixin, ComponentOptionsMixin, {
cancel: any;
close: any;
submit: any;
}, string, PublicProps, Readonly<ExtractPropTypes<    {
dataItem: PropType<any>;
}>> & Readonly<{
onCancel?: (...args: any[] | unknown[]) => any;
onClose?: (...args: any[] | unknown[]) => any;
onSubmit?: (...args: any[] | unknown[]) => any;
}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

/**
 * @hidden
 */
export declare const SchedulerFormEditor: DefineComponent<ExtractPropTypes<    {
as: (ObjectConstructor | StringConstructor | FunctionConstructor)[];
id: StringConstructor;
tabIndex: NumberConstructor;
titleLabel: {
type: (ObjectConstructor | StringConstructor | FunctionConstructor)[];
default: () => DefineComponent<ExtractPropTypes<    {
id: PropType<string>;
/**
* Specifies the `id` attribute of the root element.
*/
editorId: PropType<string>;
editorRef: PropType<any>;
editorValid: {
type: PropType<boolean>;
default: any;
};
editorDisabled: PropType<boolean>;
optional: PropType<boolean>;
}>, {
kendoLocalizationService: {};
}, {}, {
labelClassName(): {
'k-label': boolean;
'k-label-empty': boolean;
'k-text-error': boolean;
'k-text-disabled': boolean;
};
}, {
onLabelClick(e: any): void;
}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
id: PropType<string>;
/**
* Specifies the `id` attribute of the root element.
*/
editorId: PropType<string>;
editorRef: PropType<any>;
editorValid: {
type: PropType<boolean>;
default: any;
};
editorDisabled: PropType<boolean>;
optional: PropType<boolean>;
}>> & Readonly<{}>, {
editorValid: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
};
titleError: {
type: (ObjectConstructor | StringConstructor | FunctionConstructor)[];
default: () => DefineComponent<ExtractPropTypes<    {
id: PropType<string>;
direction: {
type: PropType<string>;
default: string;
validator: (value: string) => any;
};
}>, {}, {}, {
errorClassName(): object;
}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
id: PropType<string>;
direction: {
type: PropType<string>;
default: string;
validator: (value: string) => any;
};
}>> & Readonly<{}>, {
direction: string;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
};
titleEditor: {
type: (ObjectConstructor | StringConstructor | FunctionConstructor)[];
default: () => DefineComponent<ExtractPropTypes<    {
modelValue: {
type: PropType<string | number>;
default: any;
};
disabled: {
type: PropType<boolean>;
default: any;
};
defaultValue: {
type: PropType<string | number | string[]>;
default: string;
};
value: {
type: PropType<string | number | string[]>;
};
label: {
/**
* Overrides the component used for visualizing the `end timezone` field error.
* The [Kendo UI for Vue Error]({% slug error_labels %}) component is used, by default.
*
* For more information, please refer to the [`Scheduler Form Editor Customization`]({% slug editing_scheduler_custom %}) article.
*/
type: PropType<string>;
};
placeholder: {
type: PropType<string>;
};
required: {
type: PropType<boolean>;
default: boolean;
};
size: {
type: PropType<string>;
default: string;
validator: (value: any) => any;
};
rounded: {
type: PropType<string>;
default: string;
validator: (value: any) => any;
};
fillMode: {
type: PropType<string>;
default: string;
validator: (value: any) => any;
};
dir: {
type: PropType<string>;
};
id: StringConstructor;
valid: {
type: PropType<boolean>;
default: any;
};
validate: {
type: PropType<boolean>;
};
validationMessage: {
type: PropType<string>;
};
validityStyles: {
type: PropType<boolean>;
default: boolean;
};
iconName: PropType<string>;
inputPrefix: PropType<string | boolean | Object | Function>;
inputSuffix: PropType<string | boolean | Object | Function>;
showValidationIcon: PropType<boolean>;
showLoadingIcon: PropType<boolean>;
showClearButton: PropType<boolean>;
inputClass: PropType<string>;
wrapperClass: PropType<string>;
tabIndex: PropType<number>;
role: PropType<string>;
title: PropType<string>;
ariaLabel: PropType<string>;
inputAttributes: PropType<Object>;
}>, {
inputRef: Ref<any, any>;
}, {
hasMounted: boolean;
autofill: boolean;
currentValue: string | number | string[];
valueDuringOnChange: string;
focused: boolean;
}, {
spanClassNames(): {
'k-floating-label-container': boolean;
'k-focus': any;
'k-empty': boolean;
'k-autofill': any;
'k-invalid': boolean;
'k-rtl': boolean;
};
inputInnerClass(): {
[x: number]: any;
'k-input-inner': boolean;
};
computedValue(): any;
}, {
updateValidClass(): void;
emitFocus(e: any): void;
emitBlur(e: any): void;
handleKeydown(e: any): void;
handleKeyup(e: any): void;
handleKeypress(e: any): void;
clearClick(event: any): void;
focus(): void;
validity(): {
customError: boolean;
valid: any;
badTextBox: any;
patternMismatch: any;
rangeOverflow: any;
rangeUnderflow: any;
stepMismatch: any;
tooLong: any;
tooShort: any;
typeMismatch: any;
valueMissing: any;
};
isInvalid(state: Object): boolean;
setValidity(): void;
handleInput(event: any): void;
handleChange(event: any): void;
emitUpdate(event: any, eventName: string, value: any): void;
handleAutoFill(e: any): void;
handleAutoFillEnd(e: any): void;
name: () => any;
inputWrapperClass(): {
[x: string]: any;
[x: number]: any;
'k-textbox': boolean;
'k-input': boolean;
'k-invalid': boolean;
'k-required': any;
'k-disabled': any;
};
}, ComponentOptionsMixin, ComponentOptionsMixin, {
input: any;
change: any;
changemodel: any;
'update:modelValue': any;
focus: any;
blur: any;
keyup: any;
keydown: any;
keypress: any;
}, string, PublicProps, Readonly<ExtractPropTypes<    {
modelValue: {
type: PropType<string | number>;
default: any;
};
disabled: {
type: PropType<boolean>;
default: any;
};
defaultValue: {
type: PropType<string | number | string[]>;
default: string;
};
value: {
type: PropType<string | number | string[]>;
};
label: {
/**
* Overrides the component used for visualizing the `end timezone` field error.
* The [Kendo UI for Vue Error]({% slug error_labels %}) component is used, by default.
*
* For more information, please refer to the [`Scheduler Form Editor Customization`]({% slug editing_scheduler_custom %}) article.
*/
type: PropType<string>;
};
placeholder: {
type: PropType<string>;
};
required: {
type: PropType<boolean>;
default: boolean;
};
size: {
type: PropType<string>;
default: string;
validator: (value: any) => any;
};
rounded: {
type: PropType<string>;
default: string;
validator: (value: any) => any;
};
fillMode: {
type: PropType<string>;
default: string;
validator: (value: any) => any;
};
dir: {
type: PropType<string>;
};
id: StringConstructor;
valid: {
type: PropType<boolean>;
default: any;
};
validate: {
type: PropType<boolean>;
};
validationMessage: {
type: PropType<string>;
};
validityStyles: {
type: PropType<boolean>;
default: boolean;
};
iconName: PropType<string>;
inputPrefix: PropType<string | boolean | Object | Function>;
inputSuffix: PropType<string | boolean | Object | Function>;
showValidationIcon: PropType<boolean>;
showLoadingIcon: PropType<boolean>;
showClearButton: PropType<boolean>;
inputClass: PropType<string>;
wrapperClass: PropType<string>;
tabIndex: PropType<number>;
role: PropType<string>;
title: PropType<string>;
ariaLabel: PropType<string>;
inputAttributes: PropType<Object>;
}>> & Readonly<{
onInput?: (...args: any[] | unknown[]) => any;
onBlur?: (...args: any[] | unknown[]) => any;
onChange?: (...args: any[] | unknown[]) => any;
onFocus?: (...args: any[] | unknown[]) => any;
onKeydown?: (...args: any[] | unknown[]) => any;
onKeypress?: (...args: any[] | unknown[]) => any;
onKeyup?: (...args: any[] | unknown[]) => any;
onChangemodel?: (...args: any[] | unknown[]) => any;
"onUpdate:modelValue"?: (...args: any[] | unknown[]) => any;
}>, {
required: boolean;
size: string;
rounded: string;
fillMode: string;
disabled: boolean;
defaultValue: string | number | string[];
valid: boolean;
modelValue: string | number;
validityStyles: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
};
startLabel: {
type: (ObjectConstructor | StringConstructor | FunctionConstructor)[];
default: () => DefineComponent<ExtractPropTypes<    {
id: PropType<string>;
/**
* Specifies the `id` attribute of the root element.
*/
editorId: PropType<string>;
editorRef: PropType<any>;
editorValid: {
type: PropType<boolean>;
default: any;
};
editorDisabled: PropType<boolean>;
optional: PropType<boolean>;
}>, {
kendoLocalizationService: {};
}, {}, {
labelClassName(): {
'k-label': boolean;
'k-label-empty': boolean;
'k-text-error': boolean;
'k-text-disabled': boolean;
};
}, {
onLabelClick(e: any): void;
}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
id: PropType<string>;
/**
* Specifies the `id` attribute of the root element.
*/
editorId: PropType<string>;
editorRef: PropType<any>;
editorValid: {
type: PropType<boolean>;
default: any;
};
editorDisabled: PropType<boolean>;
optional: PropType<boolean>;
}>> & Readonly<{}>, {
editorValid: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
};
startError: {
type: (ObjectConstructor | StringConstructor | FunctionConstructor)[];
default: () => DefineComponent<ExtractPropTypes<    {
id: PropType<string>;
direction: {
type: PropType<string>;
default: string;
validator: (value: string) => any;
};
}>, {}, {}, {
errorClassName(): object;
}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
id: PropType<string>;
direction: {
type: PropType<string>;
default: string;
validator: (value: string) => any;
};
}>> & Readonly<{}>, {
direction: string;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
};
startEditor: {
type: (ObjectConstructor | StringConstructor | FunctionConstructor)[];
default: () => DefineComponent<    {}, {}, {}, {}, {
handleChange(event: any): any;
readDateAsLocal(value: any, timezone?: string): Date;
readDateWithTimezone(value: any, timezone?: string): Date;
}, ComponentOptionsMixin, ComponentOptionsMixin, {
change: any;
}, string, PublicProps, Readonly<{}> & Readonly<{
onChange?: (...args: any[] | unknown[]) => any;
}>, {} | {
[x: string]: any;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
};
startTimezoneLabel: {
type: (ObjectConstructor | StringConstructor | FunctionConstructor)[];
default: () => DefineComponent<ExtractPropTypes<    {
id: PropType<string>;
/**
* Specifies the `id` attribute of the root element.
*/
editorId: PropType<string>;
editorRef: PropType<any>;
editorValid: {
type: PropType<boolean>;
default: any;
};
editorDisabled: PropType<boolean>;
optional: PropType<boolean>;
}>, {
kendoLocalizationService: {};
}, {}, {
labelClassName(): {
'k-label': boolean;
'k-label-empty': boolean;
'k-text-error': boolean;
'k-text-disabled': boolean;
};
}, {
onLabelClick(e: any): void;
}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
id: PropType<string>;
/**
* Specifies the `id` attribute of the root element.
*/
editorId: PropType<string>;
editorRef: PropType<any>;
editorValid: {
type: PropType<boolean>;
default: any;
};
editorDisabled: PropType<boolean>;
optional: PropType<boolean>;
}>> & Readonly<{}>, {
editorValid: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
};
startTimezoneError: {
type: (ObjectConstructor | StringConstructor | FunctionConstructor)[];
default: () => DefineComponent<ExtractPropTypes<    {
id: PropType<string>;
direction: {
type: PropType<string>;
default: string;
validator: (value: string) => any;
};
}>, {}, {}, {
errorClassName(): object;
}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
id: PropType<string>;
direction: {
type: PropType<string>;
default: string;
validator: (value: string) => any;
};
}>> & Readonly<{}>, {
direction: string;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
};
startTimezoneEditor: {
type: (ObjectConstructor | StringConstructor | FunctionConstructor)[];
default: () => DefineComponent<ExtractPropTypes<    {
value: PropType<any>;
dataItems: PropType<any[]>;
validationMessage: PropType<string>;
touched: PropType<boolean>;
modified: PropType<boolean>;
visited: PropType<boolean>;
valid: PropType<boolean>;
name: PropType<string>;
}>, {
kendoLocalizationService: {};
}, {
filteredData: any[];
}, {}, {
onValueChange(e: any): void;
onFilterChange(event: any): void;
}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
value: PropType<any>;
dataItems: PropType<any[]>;
validationMessage: PropType<string>;
touched: PropType<boolean>;
modified: PropType<boolean>;
visited: PropType<boolean>;
valid: PropType<boolean>;
name: PropType<string>;
}>> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
};
startTimezoneCheckedLabel: {
type: (ObjectConstructor | StringConstructor | FunctionConstructor)[];
default: () => DefineComponent<ExtractPropTypes<    {
id: PropType<string>;
/**
* Specifies the `id` attribute of the root element.
*/
editorId: PropType<string>;
editorRef: PropType<any>;
editorValid: {
type: PropType<boolean>;
default: any;
};
editorDisabled: PropType<boolean>;
optional: PropType<boolean>;
}>, {
kendoLocalizationService: {};
}, {}, {
labelClassName(): {
'k-label': boolean;
'k-label-empty': boolean;
'k-text-error': boolean;
'k-text-disabled': boolean;
};
}, {
onLabelClick(e: any): void;
}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
id: PropType<string>;
/**
* Specifies the `id` attribute of the root element.
*/
editorId: PropType<string>;
editorRef: PropType<any>;
editorValid: {
type: PropType<boolean>;
default: any;
};
editorDisabled: PropType<boolean>;
optional: PropType<boolean>;
}>> & Readonly<{}>, {
editorValid: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
};
startTimezoneCheckedEditor: {
type: (ObjectConstructor | StringConstructor | FunctionConstructor)[];
default: () => DefineComponent<ExtractPropTypes<    {
checked: {
type: PropType<boolean>;
default: any;
};
defaultChecked: {
type: PropType<boolean>;
default: any;
};
defaultValue: {
type: PropType<any>;
default: any;
};
modelValue: {
type: PropType<string | number | boolean | string[]>;
default: any;
};
dir: PropType<string>;
disabled: PropType<boolean>;
id: PropType<string>;
ariaLabelledBy: PropType<string>;
ariaDescribedBy: PropType<string>;
label: PropType<string | HTMLElement>;
labelRender: PropType<any>;
labelPlacement: PropType<string>;
labelOptional: PropType<boolean>;
labelClass: PropType<string>;
name: PropType<string>;
size: {
type: PropType<string>;
default: string;
validator: (value: any) => any;
};
rounded: {
type: PropType<string>;
default: string;
validator: (value: any) => any;
};
tabIndex: PropType<number>;
value: {
type: PropType<string | number | boolean | string[]>;
default: any;
};
validationMessage: PropType<string>;
required: PropType<boolean>;
valid: {
type: PropType<boolean>;
default: any;
};
validityStyles: {
type: PropType<boolean>;
default: boolean;
};
}>, {
inputRef: Ref<any, any>;
kendoLocalizationService: {};
}, {
valueDuringOnChange: any;
currentDir: string;
currentChecked: any;
currentValue: any;
}, {
valueIsBooleanOrNull(): boolean;
isCheckedControlled(): boolean;
isValueControlled(): any;
computedValue(): any;
computedChecked(): any;
useValueAsChecked(): any;
checkedProp(): any;
valueProp(): any;
indeterminateProp(): boolean;
isValid(): any;
labelComputedClass(): {
[x: number]: any;
'k-checkbox-label': boolean;
};
}, {
setValidity(): void;
localizeMessage(message: string): string;
focusElement(): void;
setValue(e: any, val: boolean): void;
onChangeHandler(e: any): void;
onKeyDownHandler(e: any): void;
onBlurHandler(e: any): void;
onFocusHandler(e: any): void;
}, ComponentOptionsMixin, ComponentOptionsMixin, {
changemodel: any;
'update:modelValue': any;
change: any;
focus: any;
blur: any;
}, string, PublicProps, Readonly<ExtractPropTypes<    {
checked: {
type: PropType<boolean>;
default: any;
};
defaultChecked: {
type: PropType<boolean>;
default: any;
};
defaultValue: {
type: PropType<any>;
default: any;
};
modelValue: {
type: PropType<string | number | boolean | string[]>;
default: any;
};
dir: PropType<string>;
disabled: PropType<boolean>;
id: PropType<string>;
ariaLabelledBy: PropType<string>;
ariaDescribedBy: PropType<string>;
label: PropType<string | HTMLElement>;
labelRender: PropType<any>;
labelPlacement: PropType<string>;
labelOptional: PropType<boolean>;
labelClass: PropType<string>;
name: PropType<string>;
size: {
type: PropType<string>;
default: string;
validator: (value: any) => any;
};
rounded: {
type: PropType<string>;
default: string;
validator: (value: any) => any;
};
tabIndex: PropType<number>;
value: {
type: PropType<string | number | boolean | string[]>;
default: any;
};
validationMessage: PropType<string>;
required: PropType<boolean>;
valid: {
type: PropType<boolean>;
default: any;
};
validityStyles: {
type: PropType<boolean>;
default: boolean;
};
}>> & Readonly<{
onBlur?: (...args: any[] | unknown[]) => any;
onChange?: (...args: any[] | unknown[]) => any;
onFocus?: (...args: any[] | unknown[]) => any;
onChangemodel?: (...args: any[] | unknown[]) => any;
"onUpdate:modelValue"?: (...args: any[] | unknown[]) => any;
}>, {
value: string | number | boolean | string[];
size: string;
rounded: string;
defaultValue: any;
valid: boolean;
modelValue: string | number | boolean | string[];
validityStyles: boolean;
checked: boolean;
defaultChecked: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
};
endLabel: {
type: (ObjectConstructor | StringConstructor | FunctionConstructor)[];
default: () => DefineComponent<ExtractPropTypes<    {
id: PropType<string>;
/**
* Specifies the `id` attribute of the root element.
*/
editorId: PropType<string>;
editorRef: PropType<any>;
editorValid: {
type: PropType<boolean>;
default: any;
};
editorDisabled: PropType<boolean>;
optional: PropType<boolean>;
}>, {
kendoLocalizationService: {};
}, {}, {
labelClassName(): {
'k-label': boolean;
'k-label-empty': boolean;
'k-text-error': boolean;
'k-text-disabled': boolean;
};
}, {
onLabelClick(e: any): void;
}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
id: PropType<string>;
/**
* Specifies the `id` attribute of the root element.
*/
editorId: PropType<string>;
editorRef: PropType<any>;
editorValid: {
type: PropType<boolean>;
default: any;
};
editorDisabled: PropType<boolean>;
optional: PropType<boolean>;
}>> & Readonly<{}>, {
editorValid: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
};
endError: {
type: (ObjectConstructor | StringConstructor | FunctionConstructor)[];
default: () => DefineComponent<ExtractPropTypes<    {
id: PropType<string>;
direction: {
type: PropType<string>;
default: string;
validator: (value: string) => any;
};
}>, {}, {}, {
errorClassName(): object;
}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
id: PropType<string>;
direction: {
type: PropType<string>;
default: string;
validator: (value: string) => any;
};
}>> & Readonly<{}>, {
direction: string;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
};
endEditor: {
type: (ObjectConstructor | StringConstructor | FunctionConstructor)[];
default: () => DefineComponent<    {}, {}, {}, {}, {
handleChange(event: any): any;
readDateAsLocal(value: any, timezone?: string): Date;
readDateWithTimezone(value: any, timezone?: string): Date;
}, ComponentOptionsMixin, ComponentOptionsMixin, {
change: any;
}, string, PublicProps, Readonly<{}> & Readonly<{
onChange?: (...args: any[] | unknown[]) => any;
}>, {} | {
[x: string]: any;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
};
endTimezoneLabel: {
type: (ObjectConstructor | StringConstructor | FunctionConstructor)[];
default: () => DefineComponent<ExtractPropTypes<    {
id: PropType<string>;
/**
* Specifies the `id` attribute of the root element.
*/
editorId: PropType<string>;
editorRef: PropType<any>;
editorValid: {
type: PropType<boolean>;
default: any;
};
editorDisabled: PropType<boolean>;
optional: PropType<boolean>;
}>, {
kendoLocalizationService: {};
}, {}, {
labelClassName(): {
'k-label': boolean;
'k-label-empty': boolean;
'k-text-error': boolean;
'k-text-disabled': boolean;
};
}, {
onLabelClick(e: any): void;
}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
id: PropType<string>;
/**
* Specifies the `id` attribute of the root element.
*/
editorId: PropType<string>;
editorRef: PropType<any>;
editorValid: {
type: PropType<boolean>;
default: any;
};
editorDisabled: PropType<boolean>;
optional: PropType<boolean>;
}>> & Readonly<{}>, {
editorValid: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
};
endTimezoneError: {
type: (ObjectConstructor | StringConstructor | FunctionConstructor)[];
default: () => DefineComponent<ExtractPropTypes<    {
id: PropType<string>;
direction: {
type: PropType<string>;
default: string;
validator: (value: string) => any;
};
}>, {}, {}, {
errorClassName(): object;
}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
id: PropType<string>;
direction: {
type: PropType<string>;
default: string;
validator: (value: string) => any;
};
}>> & Readonly<{}>, {
direction: string;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
};
endTimezoneEditor: {
type: (ObjectConstructor | StringConstructor | FunctionConstructor)[];
default: () => DefineComponent<ExtractPropTypes<    {
value: PropType<any>;
dataItems: PropType<any[]>;
validationMessage: PropType<string>;
touched: PropType<boolean>;
modified: PropType<boolean>;
visited: PropType<boolean>;
valid: PropType<boolean>;
name: PropType<string>;
}>, {
kendoLocalizationService: {};
}, {
filteredData: any[];
}, {}, {
onValueChange(e: any): void;
onFilterChange(event: any): void;
}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
value: PropType<any>;
dataItems: PropType<any[]>;
validationMessage: PropType<string>;
touched: PropType<boolean>;
modified: PropType<boolean>;
visited: PropType<boolean>;
valid: PropType<boolean>;
name: PropType<string>;
}>> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
};
endTimezoneCheckedLabel: {
type: (ObjectConstructor | StringConstructor | FunctionConstructor)[];
default: () => DefineComponent<ExtractPropTypes<    {
id: PropType<string>;
/**
* Specifies the `id` attribute of the root element.
*/
editorId: PropType<string>;
editorRef: PropType<any>;
editorValid: {
type: PropType<boolean>;
default: any;
};
editorDisabled: PropType<boolean>;
optional: PropType<boolean>;
}>, {
kendoLocalizationService: {};
}, {}, {
labelClassName(): {
'k-label': boolean;
'k-label-empty': boolean;
'k-text-error': boolean;
'k-text-disabled': boolean;
};
}, {
onLabelClick(e: any): void;
}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
id: PropType<string>;
/**
* Specifies the `id` attribute of the root element.
*/
editorId: PropType<string>;
editorRef: PropType<any>;
editorValid: {
type: PropType<boolean>;
default: any;
};
editorDisabled: PropType<boolean>;
optional: PropType<boolean>;
}>> & Readonly<{}>, {
editorValid: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
};
endTimezoneCheckedEditor: {
type: (ObjectConstructor | StringConstructor | FunctionConstructor)[];
default: () => DefineComponent<ExtractPropTypes<    {
checked: {
type: PropType<boolean>;
default: any;
};
defaultChecked: {
type: PropType<boolean>;
default: any;
};
defaultValue: {
type: PropType<any>;
default: any;
};
modelValue: {
type: PropType<string | number | boolean | string[]>;
default: any;
};
dir: PropType<string>;
disabled: PropType<boolean>;
id: PropType<string>;
ariaLabelledBy: PropType<string>;
ariaDescribedBy: PropType<string>;
label: PropType<string | HTMLElement>;
labelRender: PropType<any>;
labelPlacement: PropType<string>;
labelOptional: PropType<boolean>;
labelClass: PropType<string>;
name: PropType<string>;
size: {
type: PropType<string>;
default: string;
validator: (value: any) => any;
};
rounded: {
type: PropType<string>;
default: string;
validator: (value: any) => any;
};
tabIndex: PropType<number>;
value: {
type: PropType<string | number | boolean | string[]>;
default: any;
};
validationMessage: PropType<string>;
required: PropType<boolean>;
valid: {
type: PropType<boolean>;
default: any;
};
validityStyles: {
type: PropType<boolean>;
default: boolean;
};
}>, {
inputRef: Ref<any, any>;
kendoLocalizationService: {};
}, {
valueDuringOnChange: any;
currentDir: string;
currentChecked: any;
currentValue: any;
}, {
valueIsBooleanOrNull(): boolean;
isCheckedControlled(): boolean;
isValueControlled(): any;
computedValue(): any;
computedChecked(): any;
useValueAsChecked(): any;
checkedProp(): any;
valueProp(): any;
indeterminateProp(): boolean;
isValid(): any;
labelComputedClass(): {
[x: number]: any;
'k-checkbox-label': boolean;
};
}, {
setValidity(): void;
localizeMessage(message: string): string;
focusElement(): void;
setValue(e: any, val: boolean): void;
onChangeHandler(e: any): void;
onKeyDownHandler(e: any): void;
onBlurHandler(e: any): void;
onFocusHandler(e: any): void;
}, ComponentOptionsMixin, ComponentOptionsMixin, {
changemodel: any;
'update:modelValue': any;
change: any;
focus: any;
blur: any;
}, string, PublicProps, Readonly<ExtractPropTypes<    {
checked: {
type: PropType<boolean>;
default: any;
};
defaultChecked: {
type: PropType<boolean>;
default: any;
};
defaultValue: {
type: PropType<any>;
default: any;
};
modelValue: {
type: PropType<string | number | boolean | string[]>;
default: any;
};
dir: PropType<string>;
disabled: PropType<boolean>;
id: PropType<string>;
ariaLabelledBy: PropType<string>;
ariaDescribedBy: PropType<string>;
label: PropType<string | HTMLElement>;
labelRender: PropType<any>;
labelPlacement: PropType<string>;
labelOptional: PropType<boolean>;
labelClass: PropType<string>;
name: PropType<string>;
size: {
type: PropType<string>;
default: string;
validator: (value: any) => any;
};
rounded: {
type: PropType<string>;
default: string;
validator: (value: any) => any;
};
tabIndex: PropType<number>;
value: {
type: PropType<string | number | boolean | string[]>;
default: any;
};
validationMessage: PropType<string>;
required: PropType<boolean>;
valid: {
type: PropType<boolean>;
default: any;
};
validityStyles: {
type: PropType<boolean>;
default: boolean;
};
}>> & Readonly<{
onBlur?: (...args: any[] | unknown[]) => any;
onChange?: (...args: any[] | unknown[]) => any;
onFocus?: (...args: any[] | unknown[]) => any;
onChangemodel?: (...args: any[] | unknown[]) => any;
"onUpdate:modelValue"?: (...args: any[] | unknown[]) => any;
}>, {
value: string | number | boolean | string[];
size: string;
rounded: string;
defaultValue: any;
valid: boolean;
modelValue: string | number | boolean | string[];
validityStyles: boolean;
checked: boolean;
defaultChecked: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
};
allDayLabel: {
type: (ObjectConstructor | StringConstructor | FunctionConstructor)[];
default: () => DefineComponent<ExtractPropTypes<    {
id: PropType<string>;
/**
* Specifies the `id` attribute of the root element.
*/
editorId: PropType<string>;
editorRef: PropType<any>;
editorValid: {
type: PropType<boolean>;
default: any;
};
editorDisabled: PropType<boolean>;
optional: PropType<boolean>;
}>, {
kendoLocalizationService: {};
}, {}, {
labelClassName(): {
'k-label': boolean;
'k-label-empty': boolean;
'k-text-error': boolean;
'k-text-disabled': boolean;
};
}, {
onLabelClick(e: any): void;
}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
id: PropType<string>;
/**
* Specifies the `id` attribute of the root element.
*/
editorId: PropType<string>;
editorRef: PropType<any>;
editorValid: {
type: PropType<boolean>;
default: any;
};
editorDisabled: PropType<boolean>;
optional: PropType<boolean>;
}>> & Readonly<{}>, {
editorValid: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
};
allDayEditor: {
type: (ObjectConstructor | StringConstructor | FunctionConstructor)[];
default: () => DefineComponent<ExtractPropTypes<    {
checked: {
type: PropType<boolean>;
default: any;
};
defaultChecked: {
type: PropType<boolean>;
default: any;
};
defaultValue: {
type: PropType<any>;
default: any;
};
modelValue: {
type: PropType<string | number | boolean | string[]>;
default: any;
};
dir: PropType<string>;
disabled: PropType<boolean>;
id: PropType<string>;
ariaLabelledBy: PropType<string>;
ariaDescribedBy: PropType<string>;
label: PropType<string | HTMLElement>;
labelRender: PropType<any>;
labelPlacement: PropType<string>;
labelOptional: PropType<boolean>;
labelClass: PropType<string>;
name: PropType<string>;
size: {
type: PropType<string>;
default: string;
validator: (value: any) => any;
};
rounded: {
type: PropType<string>;
default: string;
validator: (value: any) => any;
};
tabIndex: PropType<number>;
value: {
type: PropType<string | number | boolean | string[]>;
default: any;
};
validationMessage: PropType<string>;
required: PropType<boolean>;
valid: {
type: PropType<boolean>;
default: any;
};
validityStyles: {
type: PropType<boolean>;
default: boolean;
};
}>, {
inputRef: Ref<any, any>;
kendoLocalizationService: {};
}, {
valueDuringOnChange: any;
currentDir: string;
currentChecked: any;
currentValue: any;
}, {
valueIsBooleanOrNull(): boolean;
isCheckedControlled(): boolean;
isValueControlled(): any;
computedValue(): any;
computedChecked(): any;
useValueAsChecked(): any;
checkedProp(): any;
valueProp(): any;
indeterminateProp(): boolean;
isValid(): any;
labelComputedClass(): {
[x: number]: any;
'k-checkbox-label': boolean;
};
}, {
setValidity(): void;
localizeMessage(message: string): string;
focusElement(): void;
setValue(e: any, val: boolean): void;
onChangeHandler(e: any): void;
onKeyDownHandler(e: any): void;
onBlurHandler(e: any): void;
onFocusHandler(e: any): void;
}, ComponentOptionsMixin, ComponentOptionsMixin, {
changemodel: any;
'update:modelValue': any;
change: any;
focus: any;
blur: any;
}, string, PublicProps, Readonly<ExtractPropTypes<    {
checked: {
type: PropType<boolean>;
default: any;
};
defaultChecked: {
type: PropType<boolean>;
default: any;
};
defaultValue: {
type: PropType<any>;
default: any;
};
modelValue: {
type: PropType<string | number | boolean | string[]>;
default: any;
};
dir: PropType<string>;
disabled: PropType<boolean>;
id: PropType<string>;
ariaLabelledBy: PropType<string>;
ariaDescribedBy: PropType<string>;
label: PropType<string | HTMLElement>;
labelRender: PropType<any>;
labelPlacement: PropType<string>;
labelOptional: PropType<boolean>;
labelClass: PropType<string>;
name: PropType<string>;
size: {
type: PropType<string>;
default: string;
validator: (value: any) => any;
};
rounded: {
type: PropType<string>;
default: string;
validator: (value: any) => any;
};
tabIndex: PropType<number>;
value: {
type: PropType<string | number | boolean | string[]>;
default: any;
};
validationMessage: PropType<string>;
required: PropType<boolean>;
valid: {
type: PropType<boolean>;
default: any;
};
validityStyles: {
type: PropType<boolean>;
default: boolean;
};
}>> & Readonly<{
onBlur?: (...args: any[] | unknown[]) => any;
onChange?: (...args: any[] | unknown[]) => any;
onFocus?: (...args: any[] | unknown[]) => any;
onChangemodel?: (...args: any[] | unknown[]) => any;
"onUpdate:modelValue"?: (...args: any[] | unknown[]) => any;
}>, {
value: string | number | boolean | string[];
size: string;
rounded: string;
defaultValue: any;
valid: boolean;
modelValue: string | number | boolean | string[];
validityStyles: boolean;
checked: boolean;
defaultChecked: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
};
recurrenceEditor: {
type: (ObjectConstructor | StringConstructor | FunctionConstructor)[];
default: () => DefineComponent<ExtractPropTypes<    {
name: PropType<string>;
value: {
type: PropType<string>;
default: string;
};
start: PropType<Date>;
timezone: PropType<string>;
}>, {}, {
defaultCount: number;
defaultUntil: ZonedDate;
}, {
rrule(): RecurrenceRule;
frequencies(): FrequencyEntity[];
frequency(): Frequency;
extendedWeekDays(): WeekDayEntity[];
weekDay(): WeekDayEntity;
months(): MonthEntity[];
month(): MonthEntity;
offsets(): OffsetPositionEntity[];
offset(): OffsetPositionEntity;
endRule(): EndRule;
monthDay(): number;
until(): Date;
weekDays(): WeekDayEntity[];
repeatOnRule(): RepeatOnRule;
}, {
localizeMessage(baseMassage: string, removePrepend?: boolean): string;
onChangeHandler(newRrule: RecurrenceRule): void;
handleFrequencyChange(newFreq: string): void;
handleIntervalChange(event: NumericTextBoxChangeEvent): void;
handleCountChange(event: NumericTextBoxChangeEvent): void;
handleUntilChange(event: DatePickerChangeEvent): void;
handleWeekDaysChange(newWeekDays: number[]): void;
handleWeekDayChange(event: DropDownListChangeEvent): void;
handleMonthDayChange(event: NumericTextBoxChangeEvent): void;
handleMonthChange(event: DropDownListChangeEvent): void;
handleEndRuleChange(event: RadioGroupChangeEvent): void;
handleRepeatOnRuleChange(event: RadioGroupChangeEvent): void;
handleOffsetChange(event: DropDownListChangeEvent): void;
}, ComponentOptionsMixin, ComponentOptionsMixin, {
change: any;
}, string, PublicProps, Readonly<ExtractPropTypes<    {
name: PropType<string>;
value: {
type: PropType<string>;
default: string;
};
start: PropType<Date>;
timezone: PropType<string>;
}>> & Readonly<{
onChange?: (...args: any[] | unknown[]) => any;
}>, {
value: string;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
};
descriptionLabel: {
type: (ObjectConstructor | StringConstructor | FunctionConstructor)[];
default: () => DefineComponent<ExtractPropTypes<    {
id: PropType<string>;
/**
* Specifies the `id` attribute of the root element.
*/
editorId: PropType<string>;
editorRef: PropType<any>;
editorValid: {
type: PropType<boolean>;
default: any;
};
editorDisabled: PropType<boolean>;
optional: PropType<boolean>;
}>, {
kendoLocalizationService: {};
}, {}, {
labelClassName(): {
'k-label': boolean;
'k-label-empty': boolean;
'k-text-error': boolean;
'k-text-disabled': boolean;
};
}, {
onLabelClick(e: any): void;
}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
id: PropType<string>;
/**
* Specifies the `id` attribute of the root element.
*/
editorId: PropType<string>;
editorRef: PropType<any>;
editorValid: {
type: PropType<boolean>;
default: any;
};
editorDisabled: PropType<boolean>;
optional: PropType<boolean>;
}>> & Readonly<{}>, {
editorValid: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
};
descriptionError: {
type: (ObjectConstructor | StringConstructor | FunctionConstructor)[];
default: () => DefineComponent<ExtractPropTypes<    {
id: PropType<string>;
direction: {
type: PropType<string>;
default: string;
validator: (value: string) => any;
};
}>, {}, {}, {
errorClassName(): object;
}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
id: PropType<string>;
direction: {
type: PropType<string>;
default: string;
validator: (value: string) => any;
};
}>> & Readonly<{}>, {
direction: string;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
};
descriptionEditor: {
type: (ObjectConstructor | StringConstructor | FunctionConstructor)[];
default: () => DefineComponent<ExtractPropTypes<    {
title: PropType<string>;
ariaDescribedBy: PropType<string>;
ariaLabelledBy: PropType<string>;
autoSize: PropType<boolean>;
modelValue: {
type: PropType<string | number | string[]>;
default: any;
};
defaultValue: PropType<string | number | string[]>;
dir: PropType<string>;
disabled: PropType<boolean>;
readOnly: PropType<boolean>;
rows: PropType<number>;
id: PropType<string>;
/**
* Overrides the component used for visualizing the `title` field editor.
* The [Kendo UI for Vue Input]({% slug overview_textbox %}) component is used, by default.
*
* For more information, please refer to the [`Scheduler Form Editor Customization`]({% slug editing_scheduler_custom %}) article.
*/
name: PropType<string>;
validationMessage: PropType<string>;
size: {
type: PropType<string>;
default: string;
validator: (value: any) => any;
};
rounded: {
type: PropType<string>;
default: string;
validator: (value: any) => any;
};
fillMode: {
type: PropType<string>;
default: string;
validator: (value: any) => any;
};
required: PropType<boolean>;
placeholder: PropType<string>;
tabIndex: PropType<number>;
valid: {
type: PropType<boolean>;
default: any;
};
value: PropType<string | number | string[]>;
validityStyles: {
type: PropType<boolean>;
default: boolean;
};
iconName: PropType<string>;
inputPrefix: PropType<string | boolean | Object | Function>;
inputSuffix: PropType<string | boolean | Object | Function>;
showValidationIcon: PropType<boolean>;
showLoadingIcon: PropType<boolean>;
showClearButton: PropType<boolean>;
inputClass: PropType<string>;
wrapperClass: PropType<string>;
flow: {
type: PropType<string>;
default: string;
validator: (value: any) => any;
};
resizable: {
type: PropType<string>;
default: string;
validator: (value: any) => any;
}; /**
* Overrides the component used for visualizing the `start timezone checked` label.
* The [Kendo UI for Vue Label]({% slug label_labels %}) component is used, by default.
*
* For more information, please refer to the [`Scheduler Form Editor Customization`]({% slug editing_scheduler_custom %}) article.
*/
inputAttributes: PropType<Object>;
}>, {}, {
currentValue: string | number | string[];
textAreaHeight: string;
currentDir: string;
}, {
resizableClass(): "k-resize-none" | "k-resize-y" | "k-resize-x" | "k-resize";
rootClassName(): {
[x: string]: any;
[x: number]: any;
'k-input': boolean;
'k-textarea': boolean;
'k-disabled': any;
'k-invalid': boolean;
'k-required': any;
'k-loading': any;
'!k-flex-col': boolean;
'!k-flex-row': boolean;
};
inputInnerClass(): {
[x: number]: any;
'k-input-inner': boolean;
'!k-resize-none': boolean;
'!k-overflow-auto': boolean;
'k-flex': boolean;
};
prefixRenderClass(): {
'k-input-prefix': boolean;
'!k-flex-col': boolean;
'!k-flex-row': boolean;
'!k-align-items-start': boolean;
};
suffixRenderClass(): {
'k-input-suffix': boolean;
'!k-flex-col': boolean; /**
* Overrides the component used for visualizing the `end timezone` field error.
* The [Kendo UI for Vue Error]({% slug error_labels %}) component is used, by default.
*
* For more information, please refer to the [`Scheduler Form Editor Customization`]({% slug editing_scheduler_custom %}) article.
*/
'!k-flex-row': boolean;
'!k-align-items-start': boolean;
};
suffixIconWrapClass(): {
'k-flex-wrap': boolean;
'!k-align-items-start': boolean;
};
computedValue(): any;
isValid(): any;
}, {
setValidity(): void;
clearClick(event: any): void;
focus(): void;
emitUpdate(event: any, eventName: string, value: any): void;
handleChange(event: any): void;
handleInput(event: any): void;
handleFocus(event: any): void;
handleBlur(event: any): void;
}, ComponentOptionsMixin, ComponentOptionsMixin, {
input: any;
change: any;
changemodel: any;
'update:modelValue': any;
focus: any;
blur: any;
}, string, PublicProps, Readonly<ExtractPropTypes<    {
title: PropType<string>;
ariaDescribedBy: PropType<string>;
ariaLabelledBy: PropType<string>;
autoSize: PropType<boolean>;
modelValue: {
type: PropType<string | number | string[]>;
default: any;
};
defaultValue: PropType<string | number | string[]>;
dir: PropType<string>;
disabled: PropType<boolean>;
readOnly: PropType<boolean>;
rows: PropType<number>;
id: PropType<string>;
/**
* Overrides the component used for visualizing the `title` field editor.
* The [Kendo UI for Vue Input]({% slug overview_textbox %}) component is used, by default.
*
* For more information, please refer to the [`Scheduler Form Editor Customization`]({% slug editing_scheduler_custom %}) article.
*/
name: PropType<string>;
validationMessage: PropType<string>;
size: {
type: PropType<string>;
default: string;
validator: (value: any) => any;
};
rounded: {
type: PropType<string>;
default: string;
validator: (value: any) => any;
};
fillMode: {
type: PropType<string>;
default: string;
validator: (value: any) => any;
};
required: PropType<boolean>;
placeholder: PropType<string>;
tabIndex: PropType<number>;
valid: {
type: PropType<boolean>;
default: any;
};
value: PropType<string | number | string[]>;
validityStyles: {
type: PropType<boolean>;
default: boolean;
};
iconName: PropType<string>;
inputPrefix: PropType<string | boolean | Object | Function>;
inputSuffix: PropType<string | boolean | Object | Function>;
showValidationIcon: PropType<boolean>;
showLoadingIcon: PropType<boolean>;
showClearButton: PropType<boolean>;
inputClass: PropType<string>;
wrapperClass: PropType<string>;
flow: {
type: PropType<string>;
default: string;
validator: (value: any) => any;
};
resizable: {
type: PropType<string>;
default: string;
validator: (value: any) => any;
}; /**
* Overrides the component used for visualizing the `start timezone checked` label.
* The [Kendo UI for Vue Label]({% slug label_labels %}) component is used, by default.
*
* For more information, please refer to the [`Scheduler Form Editor Customization`]({% slug editing_scheduler_custom %}) article.
*/
inputAttributes: PropType<Object>;
}>> & Readonly<{
onInput?: (...args: any[] | unknown[]) => any;
onBlur?: (...args: any[] | unknown[]) => any;
onChange?: (...args: any[] | unknown[]) => any;
onFocus?: (...args: any[] | unknown[]) => any;
onChangemodel?: (...args: any[] | unknown[]) => any;
"onUpdate:modelValue"?: (...args: any[] | unknown[]) => any;
}>, {
size: string;
flow: string;
rounded: string;
fillMode: string;
resizable: string;
valid: boolean;
modelValue: string | number | string[];
validityStyles: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
};
resourceLabel: {
type: (ObjectConstructor | StringConstructor | FunctionConstructor)[];
default: () => DefineComponent<ExtractPropTypes<    {
id: PropType<string>;
/**
* Specifies the `id` attribute of the root element.
*/
editorId: PropType<string>;
editorRef: PropType<any>;
editorValid: {
type: PropType<boolean>;
default: any;
};
editorDisabled: PropType<boolean>;
optional: PropType<boolean>;
}>, {
kendoLocalizationService: {};
}, {}, {
labelClassName(): {
'k-label': boolean;
'k-label-empty': boolean;
'k-text-error': boolean;
'k-text-disabled': boolean;
};
}, {
onLabelClick(e: any): void;
}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
id: PropType<string>;
/**
* Specifies the `id` attribute of the root element.
*/
editorId: PropType<string>;
editorRef: PropType<any>;
editorValid: {
type: PropType<boolean>;
default: any;
};
editorDisabled: PropType<boolean>;
optional: PropType<boolean>;
}>> & Readonly<{}>, {
editorValid: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
};
resourcesError: {
type: (ObjectConstructor | StringConstructor | FunctionConstructor)[];
default: () => DefineComponent<ExtractPropTypes<    {
id: PropType<string>;
/**
* Specifies the `id` attribute of the root element.
*/
editorId: PropType<string>;
editorRef: PropType<any>;
editorValid: {
type: PropType<boolean>;
default: any;
};
editorDisabled: PropType<boolean>;
optional: PropType<boolean>;
}>, {
kendoLocalizationService: {};
}, {}, {
labelClassName(): {
'k-label': boolean;
'k-label-empty': boolean;
'k-text-error': boolean;
'k-text-disabled': boolean;
};
}, {
onLabelClick(e: any): void;
}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
id: PropType<string>;
/**
* Specifies the `id` attribute of the root element.
*/
editorId: PropType<string>;
editorRef: PropType<any>;
editorValid: {
type: PropType<boolean>;
default: any;
};
editorDisabled: PropType<boolean>;
optional: PropType<boolean>;
}>> & Readonly<{}>, {
editorValid: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
};
resourceEditor: {
type: (ObjectConstructor | StringConstructor | FunctionConstructor)[];
default: () => DefineComponent<ExtractPropTypes<    {
resource: PropType<SchedulerResource_2>;
dataItems: PropType<any[]>;
textField: PropType<string>;
valueField: PropType<string>;
colorField: PropType<string>;
multiple: PropType<boolean>;
validationMessage: PropType<string>;
value: PropType<any>;
touched: PropType<boolean>;
modified: PropType<boolean>;
visited: PropType<boolean>;
valid: PropType<boolean>;
name: PropType<string>;
}>, {}, {}, {}, {
handleChange(event: DropDownListChangeEvent | MultiSelectChangeEvent): void;
}, ComponentOptionsMixin, ComponentOptionsMixin, {
change: any;
}, string, PublicProps, Readonly<ExtractPropTypes<    {
resource: PropType<SchedulerResource_2>;
dataItems: PropType<any[]>;
textField: PropType<string>;
valueField: PropType<string>;
colorField: PropType<string>;
multiple: PropType<boolean>;
validationMessage: PropType<string>;
value: PropType<any>;
touched: PropType<boolean>;
modified: PropType<boolean>;
visited: PropType<boolean>;
valid: PropType<boolean>;
name: PropType<string>;
}>> & Readonly<{
onChange?: (...args: any[] | unknown[]) => any;
}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
};
errors: ObjectConstructor;
valid: BooleanConstructor;
touched: BooleanConstructor;
visited: BooleanConstructor;
modified: BooleanConstructor;
submitted: BooleanConstructor;
allowSubmit: BooleanConstructor;
valueGetter: FunctionConstructor;
}>, {}, {
startZoneChecked: boolean;
endZoneChecked: boolean;
}, {}, {
handleStartZoneCheckboxChange(e: any): void;
handleEndZoneCheckboxChange(e: any): void;
requiredValidator(value: any): any;
startTimezoneValidator(_dataItem: any, formValueGetter: any): any;
endTimezoneValidator(_dataItem: any, formValueGetter: any): any;
}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
as: (ObjectConstructor | StringConstructor | FunctionConstructor)[];
id: StringConstructor;
tabIndex: NumberConstructor;
titleLabel: {
type: (ObjectConstructor | StringConstructor | FunctionConstructor)[];
default: () => DefineComponent<ExtractPropTypes<    {
id: PropType<string>;
/**
* Specifies the `id` attribute of the root element.
*/
editorId: PropType<string>;
editorRef: PropType<any>;
editorValid: {
type: PropType<boolean>;
default: any;
};
editorDisabled: PropType<boolean>;
optional: PropType<boolean>;
}>, {
kendoLocalizationService: {};
}, {}, {
labelClassName(): {
'k-label': boolean;
'k-label-empty': boolean;
'k-text-error': boolean;
'k-text-disabled': boolean;
};
}, {
onLabelClick(e: any): void;
}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
id: PropType<string>;
/**
* Specifies the `id` attribute of the root element.
*/
editorId: PropType<string>;
editorRef: PropType<any>;
editorValid: {
type: PropType<boolean>;
default: any;
};
editorDisabled: PropType<boolean>;
optional: PropType<boolean>;
}>> & Readonly<{}>, {
editorValid: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
};
titleError: {
type: (ObjectConstructor | StringConstructor | FunctionConstructor)[];
default: () => DefineComponent<ExtractPropTypes<    {
id: PropType<string>;
direction: {
type: PropType<string>;
default: string;
validator: (value: string) => any;
};
}>, {}, {}, {
errorClassName(): object;
}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
id: PropType<string>;
direction: {
type: PropType<string>;
default: string;
validator: (value: string) => any;
};
}>> & Readonly<{}>, {
direction: string;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
};
titleEditor: {
type: (ObjectConstructor | StringConstructor | FunctionConstructor)[];
default: () => DefineComponent<ExtractPropTypes<    {
modelValue: {
type: PropType<string | number>;
default: any;
};
disabled: {
type: PropType<boolean>;
default: any;
};
defaultValue: {
type: PropType<string | number | string[]>;
default: string;
};
value: {
type: PropType<string | number | string[]>;
};
label: {
/**
* Overrides the component used for visualizing the `end timezone` field error.
* The [Kendo UI for Vue Error]({% slug error_labels %}) component is used, by default.
*
* For more information, please refer to the [`Scheduler Form Editor Customization`]({% slug editing_scheduler_custom %}) article.
*/
type: PropType<string>;
};
placeholder: {
type: PropType<string>;
};
required: {
type: PropType<boolean>;
default: boolean;
};
size: {
type: PropType<string>;
default: string;
validator: (value: any) => any;
};
rounded: {
type: PropType<string>;
default: string;
validator: (value: any) => any;
};
fillMode: {
type: PropType<string>;
default: string;
validator: (value: any) => any;
};
dir: {
type: PropType<string>;
};
id: StringConstructor;
valid: {
type: PropType<boolean>;
default: any;
};
validate: {
type: PropType<boolean>;
};
validationMessage: {
type: PropType<string>;
};
validityStyles: {
type: PropType<boolean>;
default: boolean;
};
iconName: PropType<string>;
inputPrefix: PropType<string | boolean | Object | Function>;
inputSuffix: PropType<string | boolean | Object | Function>;
showValidationIcon: PropType<boolean>;
showLoadingIcon: PropType<boolean>;
showClearButton: PropType<boolean>;
inputClass: PropType<string>;
wrapperClass: PropType<string>;
tabIndex: PropType<number>;
role: PropType<string>;
title: PropType<string>;
ariaLabel: PropType<string>;
inputAttributes: PropType<Object>;
}>, {
inputRef: Ref<any, any>;
}, {
hasMounted: boolean;
autofill: boolean;
currentValue: string | number | string[];
valueDuringOnChange: string;
focused: boolean;
}, {
spanClassNames(): {
'k-floating-label-container': boolean;
'k-focus': any;
'k-empty': boolean;
'k-autofill': any;
'k-invalid': boolean;
'k-rtl': boolean;
};
inputInnerClass(): {
[x: number]: any;
'k-input-inner': boolean;
};
computedValue(): any;
}, {
updateValidClass(): void;
emitFocus(e: any): void;
emitBlur(e: any): void;
handleKeydown(e: any): void;
handleKeyup(e: any): void;
handleKeypress(e: any): void;
clearClick(event: any): void;
focus(): void;
validity(): {
customError: boolean;
valid: any;
badTextBox: any;
patternMismatch: any;
rangeOverflow: any;
rangeUnderflow: any;
stepMismatch: any;
tooLong: any;
tooShort: any;
typeMismatch: any;
valueMissing: any;
};
isInvalid(state: Object): boolean;
setValidity(): void;
handleInput(event: any): void;
handleChange(event: any): void;
emitUpdate(event: any, eventName: string, value: any): void;
handleAutoFill(e: any): void;
handleAutoFillEnd(e: any): void;
name: () => any;
inputWrapperClass(): {
[x: string]: any;
[x: number]: any;
'k-textbox': boolean;
'k-input': boolean;
'k-invalid': boolean;
'k-required': any;
'k-disabled': any;
};
}, ComponentOptionsMixin, ComponentOptionsMixin, {
input: any;
change: any;
changemodel: any;
'update:modelValue': any;
focus: any;
blur: any;
keyup: any;
keydown: any;
keypress: any;
}, string, PublicProps, Readonly<ExtractPropTypes<    {
modelValue: {
type: PropType<string | number>;
default: any;
};
disabled: {
type: PropType<boolean>;
default: any;
};
defaultValue: {
type: PropType<string | number | string[]>;
default: string;
};
value: {
type: PropType<string | number | string[]>;
};
label: {
/**
* Overrides the component used for visualizing the `end timezone` field error.
* The [Kendo UI for Vue Error]({% slug error_labels %}) component is used, by default.
*
* For more information, please refer to the [`Scheduler Form Editor Customization`]({% slug editing_scheduler_custom %}) article.
*/
type: PropType<string>;
};
placeholder: {
type: PropType<string>;
};
required: {
type: PropType<boolean>;
default: boolean;
};
size: {
type: PropType<string>;
default: string;
validator: (value: any) => any;
};
rounded: {
type: PropType<string>;
default: string;
validator: (value: any) => any;
};
fillMode: {
type: PropType<string>;
default: string;
validator: (value: any) => any;
};
dir: {
type: PropType<string>;
};
id: StringConstructor;
valid: {
type: PropType<boolean>;
default: any;
};
validate: {
type: PropType<boolean>;
};
validationMessage: {
type: PropType<string>;
};
validityStyles: {
type: PropType<boolean>;
default: boolean;
};
iconName: PropType<string>;
inputPrefix: PropType<string | boolean | Object | Function>;
inputSuffix: PropType<string | boolean | Object | Function>;
showValidationIcon: PropType<boolean>;
showLoadingIcon: PropType<boolean>;
showClearButton: PropType<boolean>;
inputClass: PropType<string>;
wrapperClass: PropType<string>;
tabIndex: PropType<number>;
role: PropType<string>;
title: PropType<string>;
ariaLabel: PropType<string>;
inputAttributes: PropType<Object>;
}>> & Readonly<{
onInput?: (...args: any[] | unknown[]) => any;
onBlur?: (...args: any[] | unknown[]) => any;
onChange?: (...args: any[] | unknown[]) => any;
onFocus?: (...args: any[] | unknown[]) => any;
onKeydown?: (...args: any[] | unknown[]) => any;
onKeypress?: (...args: any[] | unknown[]) => any;
onKeyup?: (...args: any[] | unknown[]) => any;
onChangemodel?: (...args: any[] | unknown[]) => any;
"onUpdate:modelValue"?: (...args: any[] | unknown[]) => any;
}>, {
required: boolean;
size: string;
rounded: string;
fillMode: string;
disabled: boolean;
defaultValue: string | number | string[];
valid: boolean;
modelValue: string | number;
validityStyles: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
};
startLabel: {
type: (ObjectConstructor | StringConstructor | FunctionConstructor)[];
default: () => DefineComponent<ExtractPropTypes<    {
id: PropType<string>;
/**
* Specifies the `id` attribute of the root element.
*/
editorId: PropType<string>;
editorRef: PropType<any>;
editorValid: {
type: PropType<boolean>;
default: any;
};
editorDisabled: PropType<boolean>;
optional: PropType<boolean>;
}>, {
kendoLocalizationService: {};
}, {}, {
labelClassName(): {
'k-label': boolean;
'k-label-empty': boolean;
'k-text-error': boolean;
'k-text-disabled': boolean;
};
}, {
onLabelClick(e: any): void;
}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
id: PropType<string>;
/**
* Specifies the `id` attribute of the root element.
*/
editorId: PropType<string>;
editorRef: PropType<any>;
editorValid: {
type: PropType<boolean>;
default: any;
};
editorDisabled: PropType<boolean>;
optional: PropType<boolean>;
}>> & Readonly<{}>, {
editorValid: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
};
startError: {
type: (ObjectConstructor | StringConstructor | FunctionConstructor)[];
default: () => DefineComponent<ExtractPropTypes<    {
id: PropType<string>;
direction: {
type: PropType<string>;
default: string;
validator: (value: string) => any;
};
}>, {}, {}, {
errorClassName(): object;
}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
id: PropType<string>;
direction: {
type: PropType<string>;
default: string;
validator: (value: string) => any;
};
}>> & Readonly<{}>, {
direction: string;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
};
startEditor: {
type: (ObjectConstructor | StringConstructor | FunctionConstructor)[];
default: () => DefineComponent<    {}, {}, {}, {}, {
handleChange(event: any): any;
readDateAsLocal(value: any, timezone?: string): Date;
readDateWithTimezone(value: any, timezone?: string): Date;
}, ComponentOptionsMixin, ComponentOptionsMixin, {
change: any;
}, string, PublicProps, Readonly<{}> & Readonly<{
onChange?: (...args: any[] | unknown[]) => any;
}>, {} | {
[x: string]: any;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
};
startTimezoneLabel: {
type: (ObjectConstructor | StringConstructor | FunctionConstructor)[];
default: () => DefineComponent<ExtractPropTypes<    {
id: PropType<string>;
/**
* Specifies the `id` attribute of the root element.
*/
editorId: PropType<string>;
editorRef: PropType<any>;
editorValid: {
type: PropType<boolean>;
default: any;
};
editorDisabled: PropType<boolean>;
optional: PropType<boolean>;
}>, {
kendoLocalizationService: {};
}, {}, {
labelClassName(): {
'k-label': boolean;
'k-label-empty': boolean;
'k-text-error': boolean;
'k-text-disabled': boolean;
};
}, {
onLabelClick(e: any): void;
}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
id: PropType<string>;
/**
* Specifies the `id` attribute of the root element.
*/
editorId: PropType<string>;
editorRef: PropType<any>;
editorValid: {
type: PropType<boolean>;
default: any;
};
editorDisabled: PropType<boolean>;
optional: PropType<boolean>;
}>> & Readonly<{}>, {
editorValid: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
};
startTimezoneError: {
type: (ObjectConstructor | StringConstructor | FunctionConstructor)[];
default: () => DefineComponent<ExtractPropTypes<    {
id: PropType<string>;
direction: {
type: PropType<string>;
default: string;
validator: (value: string) => any;
};
}>, {}, {}, {
errorClassName(): object;
}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
id: PropType<string>;
direction: {
type: PropType<string>;
default: string;
validator: (value: string) => any;
};
}>> & Readonly<{}>, {
direction: string;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
};
startTimezoneEditor: {
type: (ObjectConstructor | StringConstructor | FunctionConstructor)[];
default: () => DefineComponent<ExtractPropTypes<    {
value: PropType<any>;
dataItems: PropType<any[]>;
validationMessage: PropType<string>;
touched: PropType<boolean>;
modified: PropType<boolean>;
visited: PropType<boolean>;
valid: PropType<boolean>;
name: PropType<string>;
}>, {
kendoLocalizationService: {};
}, {
filteredData: any[];
}, {}, {
onValueChange(e: any): void;
onFilterChange(event: any): void;
}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
value: PropType<any>;
dataItems: PropType<any[]>;
validationMessage: PropType<string>;
touched: PropType<boolean>;
modified: PropType<boolean>;
visited: PropType<boolean>;
valid: PropType<boolean>;
name: PropType<string>;
}>> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
};
startTimezoneCheckedLabel: {
type: (ObjectConstructor | StringConstructor | FunctionConstructor)[];
default: () => DefineComponent<ExtractPropTypes<    {
id: PropType<string>;
/**
* Specifies the `id` attribute of the root element.
*/
editorId: PropType<string>;
editorRef: PropType<any>;
editorValid: {
type: PropType<boolean>;
default: any;
};
editorDisabled: PropType<boolean>;
optional: PropType<boolean>;
}>, {
kendoLocalizationService: {};
}, {}, {
labelClassName(): {
'k-label': boolean;
'k-label-empty': boolean;
'k-text-error': boolean;
'k-text-disabled': boolean;
};
}, {
onLabelClick(e: any): void;
}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
id: PropType<string>;
/**
* Specifies the `id` attribute of the root element.
*/
editorId: PropType<string>;
editorRef: PropType<any>;
editorValid: {
type: PropType<boolean>;
default: any;
};
editorDisabled: PropType<boolean>;
optional: PropType<boolean>;
}>> & Readonly<{}>, {
editorValid: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
};
startTimezoneCheckedEditor: {
type: (ObjectConstructor | StringConstructor | FunctionConstructor)[];
default: () => DefineComponent<ExtractPropTypes<    {
checked: {
type: PropType<boolean>;
default: any;
};
defaultChecked: {
type: PropType<boolean>;
default: any;
};
defaultValue: {
type: PropType<any>;
default: any;
};
modelValue: {
type: PropType<string | number | boolean | string[]>;
default: any;
};
dir: PropType<string>;
disabled: PropType<boolean>;
id: PropType<string>;
ariaLabelledBy: PropType<string>;
ariaDescribedBy: PropType<string>;
label: PropType<string | HTMLElement>;
labelRender: PropType<any>;
labelPlacement: PropType<string>;
labelOptional: PropType<boolean>;
labelClass: PropType<string>;
name: PropType<string>;
size: {
type: PropType<string>;
default: string;
validator: (value: any) => any;
};
rounded: {
type: PropType<string>;
default: string;
validator: (value: any) => any;
};
tabIndex: PropType<number>;
value: {
type: PropType<string | number | boolean | string[]>;
default: any;
};
validationMessage: PropType<string>;
required: PropType<boolean>;
valid: {
type: PropType<boolean>;
default: any;
};
validityStyles: {
type: PropType<boolean>;
default: boolean;
};
}>, {
inputRef: Ref<any, any>;
kendoLocalizationService: {};
}, {
valueDuringOnChange: any;
currentDir: string;
currentChecked: any;
currentValue: any;
}, {
valueIsBooleanOrNull(): boolean;
isCheckedControlled(): boolean;
isValueControlled(): any;
computedValue(): any;
computedChecked(): any;
useValueAsChecked(): any;
checkedProp(): any;
valueProp(): any;
indeterminateProp(): boolean;
isValid(): any;
labelComputedClass(): {
[x: number]: any;
'k-checkbox-label': boolean;
};
}, {
setValidity(): void;
localizeMessage(message: string): string;
focusElement(): void;
setValue(e: any, val: boolean): void;
onChangeHandler(e: any): void;
onKeyDownHandler(e: any): void;
onBlurHandler(e: any): void;
onFocusHandler(e: any): void;
}, ComponentOptionsMixin, ComponentOptionsMixin, {
changemodel: any;
'update:modelValue': any;
change: any;
focus: any;
blur: any;
}, string, PublicProps, Readonly<ExtractPropTypes<    {
checked: {
type: PropType<boolean>;
default: any;
};
defaultChecked: {
type: PropType<boolean>;
default: any;
};
defaultValue: {
type: PropType<any>;
default: any;
};
modelValue: {
type: PropType<string | number | boolean | string[]>;
default: any;
};
dir: PropType<string>;
disabled: PropType<boolean>;
id: PropType<string>;
ariaLabelledBy: PropType<string>;
ariaDescribedBy: PropType<string>;
label: PropType<string | HTMLElement>;
labelRender: PropType<any>;
labelPlacement: PropType<string>;
labelOptional: PropType<boolean>;
labelClass: PropType<string>;
name: PropType<string>;
size: {
type: PropType<string>;
default: string;
validator: (value: any) => any;
};
rounded: {
type: PropType<string>;
default: string;
validator: (value: any) => any;
};
tabIndex: PropType<number>;
value: {
type: PropType<string | number | boolean | string[]>;
default: any;
};
validationMessage: PropType<string>;
required: PropType<boolean>;
valid: {
type: PropType<boolean>;
default: any;
};
validityStyles: {
type: PropType<boolean>;
default: boolean;
};
}>> & Readonly<{
onBlur?: (...args: any[] | unknown[]) => any;
onChange?: (...args: any[] | unknown[]) => any;
onFocus?: (...args: any[] | unknown[]) => any;
onChangemodel?: (...args: any[] | unknown[]) => any;
"onUpdate:modelValue"?: (...args: any[] | unknown[]) => any;
}>, {
value: string | number | boolean | string[];
size: string;
rounded: string;
defaultValue: any;
valid: boolean;
modelValue: string | number | boolean | string[];
validityStyles: boolean;
checked: boolean;
defaultChecked: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
};
endLabel: {
type: (ObjectConstructor | StringConstructor | FunctionConstructor)[];
default: () => DefineComponent<ExtractPropTypes<    {
id: PropType<string>;
/**
* Specifies the `id` attribute of the root element.
*/
editorId: PropType<string>;
editorRef: PropType<any>;
editorValid: {
type: PropType<boolean>;
default: any;
};
editorDisabled: PropType<boolean>;
optional: PropType<boolean>;
}>, {
kendoLocalizationService: {};
}, {}, {
labelClassName(): {
'k-label': boolean;
'k-label-empty': boolean;
'k-text-error': boolean;
'k-text-disabled': boolean;
};
}, {
onLabelClick(e: any): void;
}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
id: PropType<string>;
/**
* Specifies the `id` attribute of the root element.
*/
editorId: PropType<string>;
editorRef: PropType<any>;
editorValid: {
type: PropType<boolean>;
default: any;
};
editorDisabled: PropType<boolean>;
optional: PropType<boolean>;
}>> & Readonly<{}>, {
editorValid: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
};
endError: {
type: (ObjectConstructor | StringConstructor | FunctionConstructor)[];
default: () => DefineComponent<ExtractPropTypes<    {
id: PropType<string>;
direction: {
type: PropType<string>;
default: string;
validator: (value: string) => any;
};
}>, {}, {}, {
errorClassName(): object;
}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
id: PropType<string>;
direction: {
type: PropType<string>;
default: string;
validator: (value: string) => any;
};
}>> & Readonly<{}>, {
direction: string;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
};
endEditor: {
type: (ObjectConstructor | StringConstructor | FunctionConstructor)[];
default: () => DefineComponent<    {}, {}, {}, {}, {
handleChange(event: any): any;
readDateAsLocal(value: any, timezone?: string): Date;
readDateWithTimezone(value: any, timezone?: string): Date;
}, ComponentOptionsMixin, ComponentOptionsMixin, {
change: any;
}, string, PublicProps, Readonly<{}> & Readonly<{
onChange?: (...args: any[] | unknown[]) => any;
}>, {} | {
[x: string]: any;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
};
endTimezoneLabel: {
type: (ObjectConstructor | StringConstructor | FunctionConstructor)[];
default: () => DefineComponent<ExtractPropTypes<    {
id: PropType<string>;
/**
* Specifies the `id` attribute of the root element.
*/
editorId: PropType<string>;
editorRef: PropType<any>;
editorValid: {
type: PropType<boolean>;
default: any;
};
editorDisabled: PropType<boolean>;
optional: PropType<boolean>;
}>, {
kendoLocalizationService: {};
}, {}, {
labelClassName(): {
'k-label': boolean;
'k-label-empty': boolean;
'k-text-error': boolean;
'k-text-disabled': boolean;
};
}, {
onLabelClick(e: any): void;
}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
id: PropType<string>;
/**
* Specifies the `id` attribute of the root element.
*/
editorId: PropType<string>;
editorRef: PropType<any>;
editorValid: {
type: PropType<boolean>;
default: any;
};
editorDisabled: PropType<boolean>;
optional: PropType<boolean>;
}>> & Readonly<{}>, {
editorValid: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
};
endTimezoneError: {
type: (ObjectConstructor | StringConstructor | FunctionConstructor)[];
default: () => DefineComponent<ExtractPropTypes<    {
id: PropType<string>;
direction: {
type: PropType<string>;
default: string;
validator: (value: string) => any;
};
}>, {}, {}, {
errorClassName(): object;
}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
id: PropType<string>;
direction: {
type: PropType<string>;
default: string;
validator: (value: string) => any;
};
}>> & Readonly<{}>, {
direction: string;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
};
endTimezoneEditor: {
type: (ObjectConstructor | StringConstructor | FunctionConstructor)[];
default: () => DefineComponent<ExtractPropTypes<    {
value: PropType<any>;
dataItems: PropType<any[]>;
validationMessage: PropType<string>;
touched: PropType<boolean>;
modified: PropType<boolean>;
visited: PropType<boolean>;
valid: PropType<boolean>;
name: PropType<string>;
}>, {
kendoLocalizationService: {};
}, {
filteredData: any[];
}, {}, {
onValueChange(e: any): void;
onFilterChange(event: any): void;
}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
value: PropType<any>;
dataItems: PropType<any[]>;
validationMessage: PropType<string>;
touched: PropType<boolean>;
modified: PropType<boolean>;
visited: PropType<boolean>;
valid: PropType<boolean>;
name: PropType<string>;
}>> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
};
endTimezoneCheckedLabel: {
type: (ObjectConstructor | StringConstructor | FunctionConstructor)[];
default: () => DefineComponent<ExtractPropTypes<    {
id: PropType<string>;
/**
* Specifies the `id` attribute of the root element.
*/
editorId: PropType<string>;
editorRef: PropType<any>;
editorValid: {
type: PropType<boolean>;
default: any;
};
editorDisabled: PropType<boolean>;
optional: PropType<boolean>;
}>, {
kendoLocalizationService: {};
}, {}, {
labelClassName(): {
'k-label': boolean;
'k-label-empty': boolean;
'k-text-error': boolean;
'k-text-disabled': boolean;
};
}, {
onLabelClick(e: any): void;
}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
id: PropType<string>;
/**
* Specifies the `id` attribute of the root element.
*/
editorId: PropType<string>;
editorRef: PropType<any>;
editorValid: {
type: PropType<boolean>;
default: any;
};
editorDisabled: PropType<boolean>;
optional: PropType<boolean>;
}>> & Readonly<{}>, {
editorValid: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
};
endTimezoneCheckedEditor: {
type: (ObjectConstructor | StringConstructor | FunctionConstructor)[];
default: () => DefineComponent<ExtractPropTypes<    {
checked: {
type: PropType<boolean>;
default: any;
};
defaultChecked: {
type: PropType<boolean>;
default: any;
};
defaultValue: {
type: PropType<any>;
default: any;
};
modelValue: {
type: PropType<string | number | boolean | string[]>;
default: any;
};
dir: PropType<string>;
disabled: PropType<boolean>;
id: PropType<string>;
ariaLabelledBy: PropType<string>;
ariaDescribedBy: PropType<string>;
label: PropType<string | HTMLElement>;
labelRender: PropType<any>;
labelPlacement: PropType<string>;
labelOptional: PropType<boolean>;
labelClass: PropType<string>;
name: PropType<string>;
size: {
type: PropType<string>;
default: string;
validator: (value: any) => any;
};
rounded: {
type: PropType<string>;
default: string;
validator: (value: any) => any;
};
tabIndex: PropType<number>;
value: {
type: PropType<string | number | boolean | string[]>;
default: any;
};
validationMessage: PropType<string>;
required: PropType<boolean>;
valid: {
type: PropType<boolean>;
default: any;
};
validityStyles: {
type: PropType<boolean>;
default: boolean;
};
}>, {
inputRef: Ref<any, any>;
kendoLocalizationService: {};
}, {
valueDuringOnChange: any;
currentDir: string;
currentChecked: any;
currentValue: any;
}, {
valueIsBooleanOrNull(): boolean;
isCheckedControlled(): boolean;
isValueControlled(): any;
computedValue(): any;
computedChecked(): any;
useValueAsChecked(): any;
checkedProp(): any;
valueProp(): any;
indeterminateProp(): boolean;
isValid(): any;
labelComputedClass(): {
[x: number]: any;
'k-checkbox-label': boolean;
};
}, {
setValidity(): void;
localizeMessage(message: string): string;
focusElement(): void;
setValue(e: any, val: boolean): void;
onChangeHandler(e: any): void;
onKeyDownHandler(e: any): void;
onBlurHandler(e: any): void;
onFocusHandler(e: any): void;
}, ComponentOptionsMixin, ComponentOptionsMixin, {
changemodel: any;
'update:modelValue': any;
change: any;
focus: any;
blur: any;
}, string, PublicProps, Readonly<ExtractPropTypes<    {
checked: {
type: PropType<boolean>;
default: any;
};
defaultChecked: {
type: PropType<boolean>;
default: any;
};
defaultValue: {
type: PropType<any>;
default: any;
};
modelValue: {
type: PropType<string | number | boolean | string[]>;
default: any;
};
dir: PropType<string>;
disabled: PropType<boolean>;
id: PropType<string>;
ariaLabelledBy: PropType<string>;
ariaDescribedBy: PropType<string>;
label: PropType<string | HTMLElement>;
labelRender: PropType<any>;
labelPlacement: PropType<string>;
labelOptional: PropType<boolean>;
labelClass: PropType<string>;
name: PropType<string>;
size: {
type: PropType<string>;
default: string;
validator: (value: any) => any;
};
rounded: {
type: PropType<string>;
default: string;
validator: (value: any) => any;
};
tabIndex: PropType<number>;
value: {
type: PropType<string | number | boolean | string[]>;
default: any;
};
validationMessage: PropType<string>;
required: PropType<boolean>;
valid: {
type: PropType<boolean>;
default: any;
};
validityStyles: {
type: PropType<boolean>;
default: boolean;
};
}>> & Readonly<{
onBlur?: (...args: any[] | unknown[]) => any;
onChange?: (...args: any[] | unknown[]) => any;
onFocus?: (...args: any[] | unknown[]) => any;
onChangemodel?: (...args: any[] | unknown[]) => any;
"onUpdate:modelValue"?: (...args: any[] | unknown[]) => any;
}>, {
value: string | number | boolean | string[];
size: string;
rounded: string;
defaultValue: any;
valid: boolean;
modelValue: string | number | boolean | string[];
validityStyles: boolean;
checked: boolean;
defaultChecked: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
};
allDayLabel: {
type: (ObjectConstructor | StringConstructor | FunctionConstructor)[];
default: () => DefineComponent<ExtractPropTypes<    {
id: PropType<string>;
/**
* Specifies the `id` attribute of the root element.
*/
editorId: PropType<string>;
editorRef: PropType<any>;
editorValid: {
type: PropType<boolean>;
default: any;
};
editorDisabled: PropType<boolean>;
optional: PropType<boolean>;
}>, {
kendoLocalizationService: {};
}, {}, {
labelClassName(): {
'k-label': boolean;
'k-label-empty': boolean;
'k-text-error': boolean;
'k-text-disabled': boolean;
};
}, {
onLabelClick(e: any): void;
}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
id: PropType<string>;
/**
* Specifies the `id` attribute of the root element.
*/
editorId: PropType<string>;
editorRef: PropType<any>;
editorValid: {
type: PropType<boolean>;
default: any;
};
editorDisabled: PropType<boolean>;
optional: PropType<boolean>;
}>> & Readonly<{}>, {
editorValid: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
};
allDayEditor: {
type: (ObjectConstructor | StringConstructor | FunctionConstructor)[];
default: () => DefineComponent<ExtractPropTypes<    {
checked: {
type: PropType<boolean>;
default: any;
};
defaultChecked: {
type: PropType<boolean>;
default: any;
};
defaultValue: {
type: PropType<any>;
default: any;
};
modelValue: {
type: PropType<string | number | boolean | string[]>;
default: any;
};
dir: PropType<string>;
disabled: PropType<boolean>;
id: PropType<string>;
ariaLabelledBy: PropType<string>;
ariaDescribedBy: PropType<string>;
label: PropType<string | HTMLElement>;
labelRender: PropType<any>;
labelPlacement: PropType<string>;
labelOptional: PropType<boolean>;
labelClass: PropType<string>;
name: PropType<string>;
size: {
type: PropType<string>;
default: string;
validator: (value: any) => any;
};
rounded: {
type: PropType<string>;
default: string;
validator: (value: any) => any;
};
tabIndex: PropType<number>;
value: {
type: PropType<string | number | boolean | string[]>;
default: any;
};
validationMessage: PropType<string>;
required: PropType<boolean>;
valid: {
type: PropType<boolean>;
default: any;
};
validityStyles: {
type: PropType<boolean>;
default: boolean;
};
}>, {
inputRef: Ref<any, any>;
kendoLocalizationService: {};
}, {
valueDuringOnChange: any;
currentDir: string;
currentChecked: any;
currentValue: any;
}, {
valueIsBooleanOrNull(): boolean;
isCheckedControlled(): boolean;
isValueControlled(): any;
computedValue(): any;
computedChecked(): any;
useValueAsChecked(): any;
checkedProp(): any;
valueProp(): any;
indeterminateProp(): boolean;
isValid(): any;
labelComputedClass(): {
[x: number]: any;
'k-checkbox-label': boolean;
};
}, {
setValidity(): void;
localizeMessage(message: string): string;
focusElement(): void;
setValue(e: any, val: boolean): void;
onChangeHandler(e: any): void;
onKeyDownHandler(e: any): void;
onBlurHandler(e: any): void;
onFocusHandler(e: any): void;
}, ComponentOptionsMixin, ComponentOptionsMixin, {
changemodel: any;
'update:modelValue': any;
change: any;
focus: any;
blur: any;
}, string, PublicProps, Readonly<ExtractPropTypes<    {
checked: {
type: PropType<boolean>;
default: any;
};
defaultChecked: {
type: PropType<boolean>;
default: any;
};
defaultValue: {
type: PropType<any>;
default: any;
};
modelValue: {
type: PropType<string | number | boolean | string[]>;
default: any;
};
dir: PropType<string>;
disabled: PropType<boolean>;
id: PropType<string>;
ariaLabelledBy: PropType<string>;
ariaDescribedBy: PropType<string>;
label: PropType<string | HTMLElement>;
labelRender: PropType<any>;
labelPlacement: PropType<string>;
labelOptional: PropType<boolean>;
labelClass: PropType<string>;
name: PropType<string>;
size: {
type: PropType<string>;
default: string;
validator: (value: any) => any;
};
rounded: {
type: PropType<string>;
default: string;
validator: (value: any) => any;
};
tabIndex: PropType<number>;
value: {
type: PropType<string | number | boolean | string[]>;
default: any;
};
validationMessage: PropType<string>;
required: PropType<boolean>;
valid: {
type: PropType<boolean>;
default: any;
};
validityStyles: {
type: PropType<boolean>;
default: boolean;
};
}>> & Readonly<{
onBlur?: (...args: any[] | unknown[]) => any;
onChange?: (...args: any[] | unknown[]) => any;
onFocus?: (...args: any[] | unknown[]) => any;
onChangemodel?: (...args: any[] | unknown[]) => any;
"onUpdate:modelValue"?: (...args: any[] | unknown[]) => any;
}>, {
value: string | number | boolean | string[];
size: string;
rounded: string;
defaultValue: any;
valid: boolean;
modelValue: string | number | boolean | string[];
validityStyles: boolean;
checked: boolean;
defaultChecked: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
};
recurrenceEditor: {
type: (ObjectConstructor | StringConstructor | FunctionConstructor)[];
default: () => DefineComponent<ExtractPropTypes<    {
name: PropType<string>;
value: {
type: PropType<string>;
default: string;
};
start: PropType<Date>;
timezone: PropType<string>;
}>, {}, {
defaultCount: number;
defaultUntil: ZonedDate;
}, {
rrule(): RecurrenceRule;
frequencies(): FrequencyEntity[];
frequency(): Frequency;
extendedWeekDays(): WeekDayEntity[];
weekDay(): WeekDayEntity;
months(): MonthEntity[];
month(): MonthEntity;
offsets(): OffsetPositionEntity[];
offset(): OffsetPositionEntity;
endRule(): EndRule;
monthDay(): number;
until(): Date;
weekDays(): WeekDayEntity[];
repeatOnRule(): RepeatOnRule;
}, {
localizeMessage(baseMassage: string, removePrepend?: boolean): string;
onChangeHandler(newRrule: RecurrenceRule): void;
handleFrequencyChange(newFreq: string): void;
handleIntervalChange(event: NumericTextBoxChangeEvent): void;
handleCountChange(event: NumericTextBoxChangeEvent): void;
handleUntilChange(event: DatePickerChangeEvent): void;
handleWeekDaysChange(newWeekDays: number[]): void;
handleWeekDayChange(event: DropDownListChangeEvent): void;
handleMonthDayChange(event: NumericTextBoxChangeEvent): void;
handleMonthChange(event: DropDownListChangeEvent): void;
handleEndRuleChange(event: RadioGroupChangeEvent): void;
handleRepeatOnRuleChange(event: RadioGroupChangeEvent): void;
handleOffsetChange(event: DropDownListChangeEvent): void;
}, ComponentOptionsMixin, ComponentOptionsMixin, {
change: any;
}, string, PublicProps, Readonly<ExtractPropTypes<    {
name: PropType<string>;
value: {
type: PropType<string>;
default: string;
};
start: PropType<Date>;
timezone: PropType<string>;
}>> & Readonly<{
onChange?: (...args: any[] | unknown[]) => any;
}>, {
value: string;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
};
descriptionLabel: {
type: (ObjectConstructor | StringConstructor | FunctionConstructor)[];
default: () => DefineComponent<ExtractPropTypes<    {
id: PropType<string>;
/**
* Specifies the `id` attribute of the root element.
*/
editorId: PropType<string>;
editorRef: PropType<any>;
editorValid: {
type: PropType<boolean>;
default: any;
};
editorDisabled: PropType<boolean>;
optional: PropType<boolean>;
}>, {
kendoLocalizationService: {};
}, {}, {
labelClassName(): {
'k-label': boolean;
'k-label-empty': boolean;
'k-text-error': boolean;
'k-text-disabled': boolean;
};
}, {
onLabelClick(e: any): void;
}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
id: PropType<string>;
/**
* Specifies the `id` attribute of the root element.
*/
editorId: PropType<string>;
editorRef: PropType<any>;
editorValid: {
type: PropType<boolean>;
default: any;
};
editorDisabled: PropType<boolean>;
optional: PropType<boolean>;
}>> & Readonly<{}>, {
editorValid: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
};
descriptionError: {
type: (ObjectConstructor | StringConstructor | FunctionConstructor)[];
default: () => DefineComponent<ExtractPropTypes<    {
id: PropType<string>;
direction: {
type: PropType<string>;
default: string;
validator: (value: string) => any;
};
}>, {}, {}, {
errorClassName(): object;
}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
id: PropType<string>;
direction: {
type: PropType<string>;
default: string;
validator: (value: string) => any;
};
}>> & Readonly<{}>, {
direction: string;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
};
descriptionEditor: {
type: (ObjectConstructor | StringConstructor | FunctionConstructor)[];
default: () => DefineComponent<ExtractPropTypes<    {
title: PropType<string>;
ariaDescribedBy: PropType<string>;
ariaLabelledBy: PropType<string>;
autoSize: PropType<boolean>;
modelValue: {
type: PropType<string | number | string[]>;
default: any;
};
defaultValue: PropType<string | number | string[]>;
dir: PropType<string>;
disabled: PropType<boolean>;
readOnly: PropType<boolean>;
rows: PropType<number>;
id: PropType<string>;
/**
* Overrides the component used for visualizing the `title` field editor.
* The [Kendo UI for Vue Input]({% slug overview_textbox %}) component is used, by default.
*
* For more information, please refer to the [`Scheduler Form Editor Customization`]({% slug editing_scheduler_custom %}) article.
*/
name: PropType<string>;
validationMessage: PropType<string>;
size: {
type: PropType<string>;
default: string;
validator: (value: any) => any;
};
rounded: {
type: PropType<string>;
default: string;
validator: (value: any) => any;
};
fillMode: {
type: PropType<string>;
default: string;
validator: (value: any) => any;
};
required: PropType<boolean>;
placeholder: PropType<string>;
tabIndex: PropType<number>;
valid: {
type: PropType<boolean>;
default: any;
};
value: PropType<string | number | string[]>;
validityStyles: {
type: PropType<boolean>;
default: boolean;
};
iconName: PropType<string>;
inputPrefix: PropType<string | boolean | Object | Function>;
inputSuffix: PropType<string | boolean | Object | Function>;
showValidationIcon: PropType<boolean>;
showLoadingIcon: PropType<boolean>;
showClearButton: PropType<boolean>;
inputClass: PropType<string>;
wrapperClass: PropType<string>;
flow: {
type: PropType<string>;
default: string;
validator: (value: any) => any;
};
resizable: {
type: PropType<string>;
default: string;
validator: (value: any) => any;
}; /**
* Overrides the component used for visualizing the `start timezone checked` label.
* The [Kendo UI for Vue Label]({% slug label_labels %}) component is used, by default.
*
* For more information, please refer to the [`Scheduler Form Editor Customization`]({% slug editing_scheduler_custom %}) article.
*/
inputAttributes: PropType<Object>;
}>, {}, {
currentValue: string | number | string[];
textAreaHeight: string;
currentDir: string;
}, {
resizableClass(): "k-resize-none" | "k-resize-y" | "k-resize-x" | "k-resize";
rootClassName(): {
[x: string]: any;
[x: number]: any;
'k-input': boolean;
'k-textarea': boolean;
'k-disabled': any;
'k-invalid': boolean;
'k-required': any;
'k-loading': any;
'!k-flex-col': boolean;
'!k-flex-row': boolean;
};
inputInnerClass(): {
[x: number]: any;
'k-input-inner': boolean;
'!k-resize-none': boolean;
'!k-overflow-auto': boolean;
'k-flex': boolean;
};
prefixRenderClass(): {
'k-input-prefix': boolean;
'!k-flex-col': boolean;
'!k-flex-row': boolean;
'!k-align-items-start': boolean;
};
suffixRenderClass(): {
'k-input-suffix': boolean;
'!k-flex-col': boolean; /**
* Overrides the component used for visualizing the `end timezone` field error.
* The [Kendo UI for Vue Error]({% slug error_labels %}) component is used, by default.
*
* For more information, please refer to the [`Scheduler Form Editor Customization`]({% slug editing_scheduler_custom %}) article.
*/
'!k-flex-row': boolean;
'!k-align-items-start': boolean;
};
suffixIconWrapClass(): {
'k-flex-wrap': boolean;
'!k-align-items-start': boolean;
};
computedValue(): any;
isValid(): any;
}, {
setValidity(): void;
clearClick(event: any): void;
focus(): void;
emitUpdate(event: any, eventName: string, value: any): void;
handleChange(event: any): void;
handleInput(event: any): void;
handleFocus(event: any): void;
handleBlur(event: any): void;
}, ComponentOptionsMixin, ComponentOptionsMixin, {
input: any;
change: any;
changemodel: any;
'update:modelValue': any;
focus: any;
blur: any;
}, string, PublicProps, Readonly<ExtractPropTypes<    {
title: PropType<string>;
ariaDescribedBy: PropType<string>;
ariaLabelledBy: PropType<string>;
autoSize: PropType<boolean>;
modelValue: {
type: PropType<string | number | string[]>;
default: any;
};
defaultValue: PropType<string | number | string[]>;
dir: PropType<string>;
disabled: PropType<boolean>;
readOnly: PropType<boolean>;
rows: PropType<number>;
id: PropType<string>;
/**
* Overrides the component used for visualizing the `title` field editor.
* The [Kendo UI for Vue Input]({% slug overview_textbox %}) component is used, by default.
*
* For more information, please refer to the [`Scheduler Form Editor Customization`]({% slug editing_scheduler_custom %}) article.
*/
name: PropType<string>;
validationMessage: PropType<string>;
size: {
type: PropType<string>;
default: string;
validator: (value: any) => any;
};
rounded: {
type: PropType<string>;
default: string;
validator: (value: any) => any;
};
fillMode: {
type: PropType<string>;
default: string;
validator: (value: any) => any;
};
required: PropType<boolean>;
placeholder: PropType<string>;
tabIndex: PropType<number>;
valid: {
type: PropType<boolean>;
default: any;
};
value: PropType<string | number | string[]>;
validityStyles: {
type: PropType<boolean>;
default: boolean;
};
iconName: PropType<string>;
inputPrefix: PropType<string | boolean | Object | Function>;
inputSuffix: PropType<string | boolean | Object | Function>;
showValidationIcon: PropType<boolean>;
showLoadingIcon: PropType<boolean>;
showClearButton: PropType<boolean>;
inputClass: PropType<string>;
wrapperClass: PropType<string>;
flow: {
type: PropType<string>;
default: string;
validator: (value: any) => any;
};
resizable: {
type: PropType<string>;
default: string;
validator: (value: any) => any;
}; /**
* Overrides the component used for visualizing the `start timezone checked` label.
* The [Kendo UI for Vue Label]({% slug label_labels %}) component is used, by default.
*
* For more information, please refer to the [`Scheduler Form Editor Customization`]({% slug editing_scheduler_custom %}) article.
*/
inputAttributes: PropType<Object>;
}>> & Readonly<{
onInput?: (...args: any[] | unknown[]) => any;
onBlur?: (...args: any[] | unknown[]) => any;
onChange?: (...args: any[] | unknown[]) => any;
onFocus?: (...args: any[] | unknown[]) => any;
onChangemodel?: (...args: any[] | unknown[]) => any;
"onUpdate:modelValue"?: (...args: any[] | unknown[]) => any;
}>, {
size: string;
flow: string;
rounded: string;
fillMode: string;
resizable: string;
valid: boolean;
modelValue: string | number | string[];
validityStyles: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
};
resourceLabel: {
type: (ObjectConstructor | StringConstructor | FunctionConstructor)[];
default: () => DefineComponent<ExtractPropTypes<    {
id: PropType<string>;
/**
* Specifies the `id` attribute of the root element.
*/
editorId: PropType<string>;
editorRef: PropType<any>;
editorValid: {
type: PropType<boolean>;
default: any;
};
editorDisabled: PropType<boolean>;
optional: PropType<boolean>;
}>, {
kendoLocalizationService: {};
}, {}, {
labelClassName(): {
'k-label': boolean;
'k-label-empty': boolean;
'k-text-error': boolean;
'k-text-disabled': boolean;
};
}, {
onLabelClick(e: any): void;
}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
id: PropType<string>;
/**
* Specifies the `id` attribute of the root element.
*/
editorId: PropType<string>;
editorRef: PropType<any>;
editorValid: {
type: PropType<boolean>;
default: any;
};
editorDisabled: PropType<boolean>;
optional: PropType<boolean>;
}>> & Readonly<{}>, {
editorValid: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
};
resourcesError: {
type: (ObjectConstructor | StringConstructor | FunctionConstructor)[];
default: () => DefineComponent<ExtractPropTypes<    {
id: PropType<string>;
/**
* Specifies the `id` attribute of the root element.
*/
editorId: PropType<string>;
editorRef: PropType<any>;
editorValid: {
type: PropType<boolean>;
default: any;
};
editorDisabled: PropType<boolean>;
optional: PropType<boolean>;
}>, {
kendoLocalizationService: {};
}, {}, {
labelClassName(): {
'k-label': boolean;
'k-label-empty': boolean;
'k-text-error': boolean;
'k-text-disabled': boolean;
};
}, {
onLabelClick(e: any): void;
}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
id: PropType<string>;
/**
* Specifies the `id` attribute of the root element.
*/
editorId: PropType<string>;
editorRef: PropType<any>;
editorValid: {
type: PropType<boolean>;
default: any;
};
editorDisabled: PropType<boolean>;
optional: PropType<boolean>;
}>> & Readonly<{}>, {
editorValid: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
};
resourceEditor: {
type: (ObjectConstructor | StringConstructor | FunctionConstructor)[];
default: () => DefineComponent<ExtractPropTypes<    {
resource: PropType<SchedulerResource_2>;
dataItems: PropType<any[]>;
textField: PropType<string>;
valueField: PropType<string>;
colorField: PropType<string>;
multiple: PropType<boolean>;
validationMessage: PropType<string>;
value: PropType<any>;
touched: PropType<boolean>;
modified: PropType<boolean>;
visited: PropType<boolean>;
valid: PropType<boolean>;
name: PropType<string>;
}>, {}, {}, {}, {
handleChange(event: DropDownListChangeEvent | MultiSelectChangeEvent): void;
}, ComponentOptionsMixin, ComponentOptionsMixin, {
change: any;
}, string, PublicProps, Readonly<ExtractPropTypes<    {
resource: PropType<SchedulerResource_2>;
dataItems: PropType<any[]>;
textField: PropType<string>;
valueField: PropType<string>;
colorField: PropType<string>;
multiple: PropType<boolean>;
validationMessage: PropType<string>;
value: PropType<any>;
touched: PropType<boolean>;
modified: PropType<boolean>;
visited: PropType<boolean>;
valid: PropType<boolean>;
name: PropType<string>;
}>> & Readonly<{
onChange?: (...args: any[] | unknown[]) => any;
}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
};
errors: ObjectConstructor;
valid: BooleanConstructor;
touched: BooleanConstructor;
visited: BooleanConstructor;
modified: BooleanConstructor;
submitted: BooleanConstructor;
allowSubmit: BooleanConstructor;
valueGetter: FunctionConstructor;
}>> & Readonly<{}>, {
touched: boolean;
modified: boolean;
visited: boolean;
valid: boolean;
allowSubmit: boolean;
titleLabel: string | Function | Record<string, any>;
titleError: string | Function | Record<string, any>;
titleEditor: string | Function | Record<string, any>;
startLabel: string | Function | Record<string, any>;
startError: string | Function | Record<string, any>;
startEditor: string | Function | Record<string, any>;
startTimezoneLabel: string | Function | Record<string, any>;
startTimezoneError: string | Function | Record<string, any>;
startTimezoneEditor: string | Function | Record<string, any>;
startTimezoneCheckedLabel: string | Function | Record<string, any>;
startTimezoneCheckedEditor: string | Function | Record<string, any>;
endLabel: string | Function | Record<string, any>;
endError: string | Function | Record<string, any>;
endEditor: string | Function | Record<string, any>;
endTimezoneLabel: string | Function | Record<string, any>;
endTimezoneError: string | Function | Record<string, any>;
endTimezoneEditor: string | Function | Record<string, any>;
endTimezoneCheckedLabel: string | Function | Record<string, any>;
endTimezoneCheckedEditor: string | Function | Record<string, any>;
allDayLabel: string | Function | Record<string, any>;
allDayEditor: string | Function | Record<string, any>;
recurrenceEditor: string | Function | Record<string, any>;
descriptionLabel: string | Function | Record<string, any>;
descriptionError: string | Function | Record<string, any>;
descriptionEditor: string | Function | Record<string, any>;
resourceLabel: string | Function | Record<string, any>;
resourcesError: string | Function | Record<string, any>;
resourceEditor: string | Function | Record<string, any>;
submitted: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

/** @hidden */
export declare interface SchedulerFormEditorHandle {
    element: any;
    props: SchedulerFormEditorProps;
}

/**
 * Represents the props of the Kendo UI for Vue `SchedulerFormEditor` component.
 */
export declare interface SchedulerFormEditorProps extends Omit_2<FormElementProps, 'children'>, FormRenderProps {
    /** @hidden */
    as?: any;
    /**
     * 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 [Kendo UI for Vue Label]({% slug label_labels %}) component is used, by default.
     *
     * For more information, please refer to the [`Scheduler Form Editor Customization`]({% slug editing_scheduler_custom %}) article.
     */
    titleLabel?: any;
    /**
     * Overrides the component used for visualizing the `title` field error.
     * The [Kendo UI for Vue Error]({% slug error_labels %}) component is used, by default.
     *
     * For more information, please refer to the [`Scheduler Form Editor Customization`]({% slug editing_scheduler_custom %}) article.
     */
    titleError?: any;
    /**
     * Overrides the component used for visualizing the `title` field editor.
     * The [Kendo UI for Vue Input]({% slug overview_textbox %}) component is used, by default.
     *
     * For more information, please refer to the [`Scheduler Form Editor Customization`]({% slug editing_scheduler_custom %}) article.
     */
    titleEditor?: any;
    /**
     * Overrides the component used for visualizing the `start` field label.
     * The [Kendo UI for Vue Label]({% slug label_labels %}) component is used, by default.
     *
     * For more information, please refer to the [`Scheduler Form Editor Customization`]({% slug editing_scheduler_custom %}) article.
     */
    startLabel?: any;
    /**
     * Overrides the component used for visualizing the `start` field error.
     * The [Kendo UI for Vue Error]({% slug error_labels %}) component is used, by default.
     *
     * For more information, please refer to the [`Scheduler Form Editor Customization`]({% slug editing_scheduler_custom %}) article.
     */
    startError?: any;
    /**
     * Overrides the component used for visualizing the `start` field editor.
     * The [Kendo UI for Vue DatePicker]({% slug overview_datepicker %}) or [Kendo UI for Vue 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 editing_scheduler_custom %}) article.
     */
    startEditor?: any;
    /**
     * Overrides the component used for visualizing the `start timezone` field label.
     * The [Kendo UI for Vue Label]({% slug label_labels %}) component is used, by default.
     *
     * For more information, please refer to the [`Scheduler Form Editor Customization`]({% slug editing_scheduler_custom %}) article.
     */
    startTimezoneLabel?: any;
    /**
     * Overrides the component used for visualizing the `start timezone` field error.
     * The [Kendo UI for Vue Error]({% slug error_labels %}) component is used, by default.
     *
     * For more information, please refer to the [`Scheduler Form Editor Customization`]({% slug editing_scheduler_custom %}) article.
     */
    startTimezoneError?: any;
    /**
     * Overrides the component used for visualizing the `start timezone` field editor.
     * An extended [Kendo UI for Vue ComboBox]({% slug overview_combobox %}) component is used, by default.
     *
     * For more information, please refer to the [`Scheduler Form Editor Customization`]({% slug editing_scheduler_custom %}) article.
     */
    startTimezoneEditor?: any;
    /**
     * Overrides the component used for visualizing the `start timezone checked` label.
     * The [Kendo UI for Vue Label]({% slug label_labels %}) component is used, by default.
     *
     * For more information, please refer to the [`Scheduler Form Editor Customization`]({% slug editing_scheduler_custom %}) article.
     */
    startTimezoneCheckedLabel?: any;
    /**
     * Overrides the component used for visualizing the `start timezone checked` editor.
     * The [Kendo UI for Vue Checkbox]({% slug overview_checkbox %}) component is used, by default.
     *
     * For more information, please refer to the [`Scheduler Form Editor Customization`]({% slug editing_scheduler_custom %}) article.
     */
    startTimezoneCheckedEditor?: any;
    /**
     * Overrides the component used for visualizing the `end` field label.
     * The [Kendo UI for Vue Label]({% slug label_labels %}) component is used, by default.
     *
     * For more information, please refer to the [`Scheduler Form Editor Customization`]({% slug editing_scheduler_custom %}) article.
     */
    endLabel?: any;
    /**
     * Overrides the component used for visualizing the `end` field error.
     * The [Kendo UI for Vue Error]({% slug error_labels %}) component is used, by default.
     *
     * For more information, please refer to the [`Scheduler Form Editor Customization`]({% slug editing_scheduler_custom %}) article.
     */
    endError?: any;
    /**
     * Overrides the component used for visualizing the `end` field editor.
     * The [Kendo UI for Vue DatePicker]({% slug overview_datepicker %}) or [Kendo UI for Vue 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 editing_scheduler_custom %}) article.
     */
    endEditor?: any;
    /**
     * Overrides the component used for visualizing the `end timezone` field label.
     * The [Kendo UI for Vue Label]({% slug label_labels %}) component is used, by default.
     *
     * For more information, please refer to the [`Scheduler Form Editor Customization`]({% slug editing_scheduler_custom %}) article.
     */
    endTimezoneLabel?: any;
    /**
     * Overrides the component used for visualizing the `end timezone` field error.
     * The [Kendo UI for Vue Error]({% slug error_labels %}) component is used, by default.
     *
     * For more information, please refer to the [`Scheduler Form Editor Customization`]({% slug editing_scheduler_custom %}) article.
     */
    endTimezoneError?: any;
    /**
     * Overrides the component used for visualizing the `end timezone` field editor.
     * An extended [Kendo UI for Vue ComboBox]({% slug overview_combobox %}) component is used, by default.
     *
     * For more information, please refer to the [`Scheduler Form Editor Customization`]({% slug editing_scheduler_custom %}) article.
     */
    endTimezoneEditor?: any;
    /**
     * Overrides the component used for visualizing the `start timezone checked` label.
     * The [Kendo UI for Vue Label]({% slug label_labels %}) component is used, by default.
     *
     * For more information, please refer to the [`Scheduler Form Editor Customization`]({% slug editing_scheduler_custom %}) article.
     */
    endTimezoneCheckedLabel?: any;
    /**
     * Overrides the component used for visualizing the `end timezone checked` editor.
     * The [Kendo UI for Vue Checkbox]({% slug overview_checkbox %}) component is used, by default.
     *
     * For more information, please refer to the [`Scheduler Form Editor Customization`]({% slug editing_scheduler_custom %}) article.
     */
    endTimezoneCheckedEditor?: any;
    /**
     * Overrides the component used for visualizing the `allDay` field label.
     * The [Kendo UI for Vue Label]({% slug label_labels %}) component is used, by default.
     *
     * For more information, please refer to the [`Scheduler Form Editor Customization`]({% slug editing_scheduler_custom %}) article.
     */
    allDayLabel?: any;
    /**
     * Overrides the component used for visualizing the `allDay` field editor.
     * The [Kendo UI for Vue Checkbox]({% slug overview_checkbox %}) component is used, by default.
     *
     * For more information, please refer to the [`Scheduler Form Editor Customization`]({% slug editing_scheduler_custom %}) article.
     */
    allDayEditor?: any;
    /**
     * 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 editing_scheduler_custom %}) article.
     */
    recurrenceEditor?: any;
    /**
     * Overrides the component used for visualizing the `description` field label.
     * The [Kendo UI for Vue Label]({% slug label_labels %}) component is used, by default.
     *
     * For more information, please refer to the [`Scheduler Form Editor Customization`]({% slug editing_scheduler_custom %}) article.
     */
    descriptionLabel?: any;
    /**
     * Overrides the component used for visualizing the `description` field error.
     * The [Kendo UI for Vue Error]({% slug error_labels %}) component is used, by default.
     *
     * For more information, please refer to the [`Scheduler Form Editor Customization`]({% slug editing_scheduler_custom %}) article.
     */
    descriptionError?: any;
    /**
     * Overrides the component used for visualizing the `description` field editor.
     * The [Kendo UI for Vue TextArea]({% slug overview_textarea %}) component is used, by default.
     *
     * For more information, please refer to the [`Scheduler Form Editor Customization`]({% slug editing_scheduler_custom %}) article.
     */
    descriptionEditor?: any;
    /**
     * Overrides the component used for visualizing the `start timezone checked` field label.
     * The [Kendo UI for Vue Label]({% slug label_labels %}) component is used, by default.
     *
     * For more information, please refer to the [`Scheduler Form Editor Customization`]({% slug editing_scheduler_custom %}) article.
     */
    resourceLabel?: any;
    /**
     * Overrides the component used for visualizing each `resources` field error.
     * The [Kendo UI for Vue Error]({% slug error_labels %}) component is used, by default.
     *
     * For more information, please refer to the [`Scheduler Form Editor Customization`]({% slug editing_scheduler_custom %}) article.
     */
    resourcesError?: any;
    /**
     * Overrides the component used for visualizing each `resource` field editor.
     * An extended Kendo UI for Vue [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 editing_scheduler_custom %}) article.
     */
    resourceEditor?: any;
}

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

/**
 * Represents the props of the Kendo UI for Vue [SchedulerForm]({% slug api_scheduler_schedulerformprops %}) component.
 */
export declare interface SchedulerFormProps extends FormProps {
    /**
     * Specifies the `dataItem` to be visualized inside the form.
     */
    dataItem: DataItem;
    /**
     * Called when the `cancel` button is clicked.
     */
    onCancel?: (event: SchedulerFormStateChangeEvent<null>) => void;
    /**
     * Called when the `close` button is clicked.
     */
    onClose?: (event: SchedulerFormStateChangeEvent<null>) => void;
}

declare interface SchedulerFormStateChangeEvent<T> {
    target: SchedulerFormHandle;
    value: T;
    event: any;
}

/**
 * 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';
}

/**
 * @hidden
 */
export declare const SchedulerHeader: DefineComponent<    {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

/** @hidden */
export declare interface SchedulerHeaderHandle {
    element: HTMLDivElement | null;
    props: SchedulerHeaderProps;
}

/**
 * Represents the props of the Kendo UI for Vue [SchedulerHeader]({% slug api_scheduler_schedulerfooterprops %}) component.
 */
export declare interface SchedulerHeaderProps extends ToolbarProps {
}

/**
 * @hidden
 */
export declare const SchedulerItem: DefineComponent<ExtractPropTypes<    {
uid: PropType<string | number>;
start: PropType<Date>;
end: PropType<Date>;
originalStart: PropType<Date>;
startTimezone: PropType<string>;
endTimezone: PropType<string>;
isAllDay: PropType<boolean>;
title: PropType<string>;
description: PropType<string>;
occurrenceId: PropType<string>;
recurrenceExceptions: PropType<Date[]>;
recurrenceRule: PropType<string>;
recurrenceId: PropType<string | number>;
dataItem: PropType<any>;
head: PropType<boolean>;
tail: PropType<boolean>;
order: PropType<number>;
zonedStart: PropType<ZonedDate>;
zonedEnd: PropType<ZonedDate>;
slots: PropType<Slot_4[]>;
group: PropType<Group_2>;
range: PropType<Range_5>;
isException: PropType<boolean>;
isRecurring: PropType<boolean>;
id: PropType<string>;
tabIndex: PropType<number>;
className: PropType<string>;
itemStyle: PropType<any>;
editable: PropType<boolean | EditableProp>;
selected: PropType<boolean>;
vertical: PropType<boolean>;
dragHint: PropType<boolean>;
resizeHint: PropType<boolean>;
format: PropType<string>;
maxSiblingsPerSlot: PropType<number>;
itemTitle: PropType<string>;
formItem: PropType<object>;
dragItem: PropType<object>;
resizeItem: PropType<object>;
removeItem: PropType<object>;
ignoreIsAllDay: PropType<boolean>;
item: PropType<string | object | Function>;
showOccurrenceDialog: {
type: PropType<boolean>;
default: any;
};
showRemoveDialog: {
type: PropType<boolean>;
default: any;
};
}>, {}, {}, {
currentEditable(): EditableProp;
resource(): any;
color(): any;
currentTabIndex(): any;
itemClassName(): {
[x: number]: any;
'k-event': boolean;
'k-selected': any;
'k-event-drag-hint': any;
'k-scheduler-marquee': any;
'k-marquee': any;
'k-first': boolean;
'k-last': boolean;
};
eventLabel(): string;
computedStyle(): any;
}, {
getElement(): any;
handleFocus(event: any): void;
handleBlur(event: any): void;
handleMouseDown(event: any): void;
handleClick(event: any): void;
handleMouseUp(event: any): void;
handleMouseOver(event: any): void;
handleMouseOut(event: any): void;
handleMouseEnter(event: any): void;
handleMouseLeave(event: any): void;
handleDoubleClick(event: any): void;
handleRemoveClick(event: any): void;
handleKeyDown(event: any): void;
handleKeyPress(event: any): void;
handleKeyUp(event: any): void;
handlePress(dragEvent: any): void;
handleDrag(dragEvent: any): void;
handleRelease(dragEvent: any): void;
handleResizePress(dragEvent: any): void;
handleResizeStartDrag(dragEvent: any): void;
handleResizeEndDrag(dragEvent: any): void;
handleResizeRelease(dragEvent: any): void;
handleFormClose(event: SchedulerFormStateChangeEvent<null> | SchedulerOccurrenceDialogStateChangeEvent<null>): void;
handleFormSubmit(event: SchedulerFormStateChangeEvent<DataItem | null>): void;
handleFormCancel(event: SchedulerFormStateChangeEvent<null> | SchedulerOccurrenceDialogStateChangeEvent<null>): void;
}, ComponentOptionsMixin, ComponentOptionsMixin, {
focus: any;
blur: any;
mousedown: any;
mouseup: any;
mouseover: any;
mouseout: any;
mouseenter: any;
mouseleave: any;
click: any;
doubleclick: any;
removeclick: any;
keydown: any;
keypress: any;
keyup: any;
press: any;
drag: any;
release: any;
resizepress: any;
resizestartdrag: any;
resizeenddrag: any;
resizerelease: any;
cancel: any;
close: any;
formsubmit: any;
}, string, PublicProps, Readonly<ExtractPropTypes<    {
uid: PropType<string | number>;
start: PropType<Date>;
end: PropType<Date>;
originalStart: PropType<Date>;
startTimezone: PropType<string>;
endTimezone: PropType<string>;
isAllDay: PropType<boolean>;
title: PropType<string>;
description: PropType<string>;
occurrenceId: PropType<string>;
recurrenceExceptions: PropType<Date[]>;
recurrenceRule: PropType<string>;
recurrenceId: PropType<string | number>;
dataItem: PropType<any>;
head: PropType<boolean>;
tail: PropType<boolean>;
order: PropType<number>;
zonedStart: PropType<ZonedDate>;
zonedEnd: PropType<ZonedDate>;
slots: PropType<Slot_4[]>;
group: PropType<Group_2>;
range: PropType<Range_5>;
isException: PropType<boolean>;
isRecurring: PropType<boolean>;
id: PropType<string>;
tabIndex: PropType<number>;
className: PropType<string>;
itemStyle: PropType<any>;
editable: PropType<boolean | EditableProp>;
selected: PropType<boolean>;
vertical: PropType<boolean>;
dragHint: PropType<boolean>;
resizeHint: PropType<boolean>;
format: PropType<string>;
maxSiblingsPerSlot: PropType<number>;
itemTitle: PropType<string>;
formItem: PropType<object>;
dragItem: PropType<object>;
resizeItem: PropType<object>;
removeItem: PropType<object>;
ignoreIsAllDay: PropType<boolean>;
item: PropType<string | object | Function>;
showOccurrenceDialog: {
type: PropType<boolean>;
default: any;
};
showRemoveDialog: {
type: PropType<boolean>;
default: any;
};
}>> & Readonly<{
onPress?: (...args: any[] | unknown[]) => any;
onDrag?: (...args: any[] | unknown[]) => any;
onRelease?: (...args: any[] | unknown[]) => any;
onClick?: (...args: any[] | unknown[]) => any;
onBlur?: (...args: any[] | unknown[]) => any;
onCancel?: (...args: any[] | unknown[]) => any;
onClose?: (...args: any[] | unknown[]) => any;
onFocus?: (...args: any[] | unknown[]) => any;
onKeydown?: (...args: any[] | unknown[]) => any;
onKeypress?: (...args: any[] | unknown[]) => any;
onKeyup?: (...args: any[] | unknown[]) => any;
onMousedown?: (...args: any[] | unknown[]) => any;
onMouseenter?: (...args: any[] | unknown[]) => any;
onMouseleave?: (...args: any[] | unknown[]) => any;
onMouseout?: (...args: any[] | unknown[]) => any;
onMouseover?: (...args: any[] | unknown[]) => any;
onMouseup?: (...args: any[] | unknown[]) => any;
onDoubleclick?: (...args: any[] | unknown[]) => any;
onFormsubmit?: (...args: any[] | unknown[]) => any;
onRemoveclick?: (...args: any[] | unknown[]) => any;
onResizepress?: (...args: any[] | unknown[]) => any;
onResizestartdrag?: (...args: any[] | unknown[]) => any;
onResizeenddrag?: (...args: any[] | unknown[]) => any;
onResizerelease?: (...args: any[] | unknown[]) => any;
}>, {
showOccurrenceDialog: boolean;
showRemoveDialog: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

/**
 * @hidden
 */
export declare const SchedulerItemContent: DefineComponent<ExtractPropTypes<    {
title: PropType<string>;
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
title: PropType<string>;
}>> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

/**
 * Represents the props of the [SchedulerItemContent]({% slug api_scheduler_scheduleritemcontentprops %}) component.
 * Extends the [native `div` props`](https://developer.mozilla.org/en-US/docs/Web/API/HTMLDivElement).
 */
export declare interface SchedulerItemContentProps {
    /**
     * The title of the item.
     */
    title?: string;
}

/**
 * @hidden
 */
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
 */
declare interface SchedulerItemFocusEvent {
    target: SchedulerItemHandle;
    event: any;
}

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

/** @hidden */
export declare interface SchedulerItemHandle {
    element: HTMLDivElement | null;
    props: SchedulerItemProps;
}

/**
 * @hidden
 */
declare interface SchedulerItemKeyboardEvent {
    target: SchedulerItemHandle;
    event: any;
}

/**
 * @hidden
 */
declare interface SchedulerItemMouseEvent {
    target: SchedulerItemHandle;
    event: any;
}

/**
 * Represents the props of the Kendo UI for Vue [SchedulerItem]({% slug api_scheduler_scheduleritemprops %}) component.
 */
export declare interface SchedulerItemProps extends Item_2 {
    /**
     * 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`
     */
    itemStyle?: any;
    /**
     * 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;
    /**
     * 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.
     */
    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.
     */
    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.
     */
    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.
     */
    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.
     */
    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.
     */
    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.
     */
    onResizeRelease?: (event: SchedulerItemDragEvent) => void;
    /** @hidden */
    maxSiblingsPerSlot?: number;
    /** @hidden */
    itemTitle?: string;
    /** @hidden */
    showRemoveDialog?: boolean;
    /** @hidden */
    showOccurrenceDialog?: boolean;
    /** @hidden */
    formItem?: object;
    /** @hidden */
    dragItem?: object;
    /** @hidden */
    resizeItem?: object;
    /** @hidden */
    removeItem?: object;
    /** @hidden */
    ignoreIsAllDay?: boolean;
    /** @hidden */
    item?: string | Function | object;
}

/**
 * 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?: any;
    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?: any;
    ignoreIsAllDay?: boolean;
}

/**
 * Defines the model fields that will be used for creating `SchedulerEvent` instances.
 */
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;
}

/**
 * @hidden
 */
export declare const SchedulerNavigation: DefineComponent<ExtractPropTypes<    {
isRtl: PropType<boolean>;
onPrevclick: PropType<(e: any) => void>;
onNextclick: PropType<(e: any) => void>;
onTodayclick: PropType<(e: any) => void>;
}>, {}, {}, {}, {
handleTodayClick(e: any): void;
handlePrevClick(e: any): void;
handleNextClick(e: any): void;
}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
isRtl: PropType<boolean>;
onPrevclick: PropType<(e: any) => void>;
onNextclick: PropType<(e: any) => void>;
onTodayclick: PropType<(e: any) => void>;
}>> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

/** @hidden */
export declare interface SchedulerNavigationProps {
    isRtl?: boolean;
    onPrevclick?: (e: any) => void;
    onNextclick?: (e: any) => void;
    onTodayclick?: (e: any) => void;
}

/**
 * @hidden
 */
export declare const SchedulerOccurrenceDialog: DefineComponent<ExtractPropTypes<    {
dataItem: PropType<any>;
isRemove: PropType<boolean>;
onClose: PropType<(event: SchedulerOccurrenceDialogStateChangeEvent<DataItem | null>) => void>;
onOccurrenceclose: PropType<(event: SchedulerOccurrenceDialogStateChangeEvent<DataItem | null>) => void>;
onSeriesclose: PropType<(event: SchedulerOccurrenceDialogStateChangeEvent<DataItem | null>) => void>;
}>, {
kendoLocalizationService: {};
}, {}, {}, {
handleClose({ event }: DialogCloseEvent): void;
handleSeriesClick(event: any): void;
handleOccurrenceClick(event: any): void;
}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
dataItem: PropType<any>;
isRemove: PropType<boolean>;
onClose: PropType<(event: SchedulerOccurrenceDialogStateChangeEvent<DataItem | null>) => void>;
onOccurrenceclose: PropType<(event: SchedulerOccurrenceDialogStateChangeEvent<DataItem | null>) => void>;
onSeriesclose: PropType<(event: SchedulerOccurrenceDialogStateChangeEvent<DataItem | null>) => void>;
}>> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

/** @hidden */
export declare type SchedulerOccurrenceDialogHandle = {
    props: SchedulerOccurrenceDialogProps;
};

/**
 * Represents the props of the Kendo UI for Vue [SchedulerOccurrenceDialog]({% slug api_scheduler_scheduleroccurrencedialogprops %}) 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;
    /**
     * @hidden
     */
    onOccurrenceclose?: (event: SchedulerOccurrenceDialogStateChangeEvent<DataItem | null>) => void;
    /**
     * @hidden
     */
    onSeriesclose?: (event: SchedulerOccurrenceDialogStateChangeEvent<DataItem | null>) => void;
}

declare interface SchedulerOccurrenceDialogStateChangeEvent<T> {
    target: SchedulerOccurrenceDialogHandle;
    value: T;
    event: any;
}

/**
 * Represents the props of the [Kendo UI for Vue Scheduler component]({% slug overview_scheduler %}).
 */
export declare interface SchedulerProps {
    /**
     * Specifies the `id` of the wrapping element of the Scheduler.
     */
    id?: string;
    /**
     * Specifies the `tabIndex` attribute of the wrapping element of the Scheduler.
     */
    tabIndex?: number;
    /**
     * Specifies the `role` attribute of the Scheduler wrapping element.
     *
     * For more information, refer to the [Scheduler Accessibility Compliance]({% slug accessibility_scheduler %}) article
     */
    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
     */
    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
     */
    ariaLabel?: string;
    /**
     * Specifies the `className` attribute of the wrapping element of the 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_scheduleritemprops %})
     *
     * For more information on customizing the scheduler items, refer to the [Item Customization]({% slug scheduler_custom_event %}) article.
     */
    item?: any;
    /**
     * Overrides the default viewItem. Specifying the `viewItem` property of a specific view will override this property.
     *
     * The default component is: [SchedulerViewItem]({% slug api_scheduler_schedulerviewitemprops %})
     *
     * For more information on customizing the scheduler items, refer to the [Item Customization]({% slug scheduler_custom_event %}) article.
     */
    viewItem?: any;
    /**
     * Overrides the default editItem. Specifying the `editItem` property of a specific view will override this property.
     *
     * The default component is: [SchedulerEditItem]({% slug api_scheduler_scheduleredititemprops %})
     *
     * For more information on customizing the scheduler items, refer to the [Item Customization]({% slug scheduler_custom_event %}) article.
     */
    editItem?: any;
    /**
     * 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_schedulertaskprops %})
     *
     * For more information on customizing the scheduler tasks, refer to the [Task Customization]({% slug overview_agenda_view_scheduler %}) article.
     */
    task?: any;
    /**
     *
     *  Represents component based on the DateHeaderCellProps.
     */
    dateHeaderCell?: any;
    /**
     *
     *  Represents component based on the TimeHeaderCellProps.
     */
    timeHeaderCell?: any;
    /**
     * 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_schedulerviewtaskprops %})
     *
     * For more information on customizing the scheduler tasks, refer to the [Task Customization]({% slug overview_agenda_view_scheduler %}) article.
     */
    viewTask?: any;
    /**
     * Overrides the default editTask. Specifying the `editTask` 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: [SchedulerEditTask]({% slug api_scheduler_scheduleredittaskprops %})
     *
     * For more information on customizing the scheduler tasks, refer to the [Task Customization]({% slug overview_agenda_view_scheduler %}) article.
     */
    editTask?: any;
    /**
     * Overrides the default header component of the Scheduler.
     *
     * The default component is: [SchedulerHeader]({% slug api_scheduler_schedulerheaderprops %})
     *
     * For more information on customizing the scheduler header, refer to the [Header Customization]({% slug overview_header_footer_scheduler %}) article.
     */
    header?: any;
    /**
     * Overrides the default footer component of the Scheduler.
     *
     * The default component is: [Scheduler]({% slug api_scheduler_schedulerfooterprops %})
     *
     * For more information on customizing the scheduler footer, refer to the [Footer Customization]({% slug overview_header_footer_scheduler %}) article.
     */
    footer?: any;
    /**
     * 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_schedulerslotprops %})
     *
     * For more information on customizing the scheduler slots, refer to the [Slot Customization]({% slug scheduler_custom_slot %}) article.
     */
    slotRender?: any;
    /**
     * 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_schedulerviewslotprops %})
     *
     * For more information on customizing the scheduler slots, refer to the [Slot Customization]({% slug scheduler_custom_slot %}) article.
     */
    viewSlot?: any;
    /**
     * 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_schedulereditslotprops %})
     *
     * For more information on customizing the scheduler slots, refer to the [Slot Customization]({% slug scheduler_custom_slot %}) article.
     */
    editSlot?: any;
    /** @hidden */
    form?: any;
    /** @hidden */
    resizeHint?: any;
    /** @hidden */
    dialogProps?: any;
    /** @hidden */
    formProps?: any;
    /**
     * Sets the currently visible views.
     */
    views?: SchedulerViewProps[];
    /**
     * Sets the currently selected view. The value is matched with the `name` property of the view.
     */
    view?: string;
    /**
     * Sets the data of the Scheduler component. The data is then parsed and rendered as a visual Scheduler items.
     */
    dataItems?: DataItem[];
    /**
     * Sets if the Scheduler component is editable. The value can be either a `boolean` or an Object to specify different types of editing.
     */
    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`
     */
    defaultView?: string;
    /**
     * Sets the current selected `Date`. The current selected date is passed to the selected view and transformed in to a range.
     */
    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.
     */
    defaultDate?: Date;
    /**
     * Function that returns custom validator for the form.
     */
    validator?: Function;
    /**
     * Function that returns custom initial values for the fields of the form.
     */
    modifyInitialFormValues?: Function;
    /**
     * Force a `rtl` mode. For more information refer to [RTL Support]({% slug globalization_scheduler %}#toc-right-to-left-support)
     */
    rtl?: boolean;
    /**
     * Sets the `height` of the Scheduler.
     */
    height?: number | string;
    /**
     * Specifies the id of the timezone that will be displayed in the Scheduler.
     * For example, `Europe/Sofia`.
     *
     * Defaults to `Etc/UTC`.
     */
    timezone?: string;
    /**
     * Specifies the groups of the Scheduler.
     */
    group?: SchedulerGroup;
    /**
     * Specifies the resources of the Scheduler.
     */
    resources?: SchedulerResource[];
    /**
     * The names of the model fields from which the Scheduler will read its data
     * ([see example]({% slug data_binding_scheduler %})).
     */
    modelFields?: SchedulerModelFields;
    /**
     * Called when new `date` is selected.
     */
    onDateChange?: (args: SchedulerDateChangeEvent) => void;
    /**
     * Called when new `view` is selected. [(see example)]({% slug views_scheduler %}#toc-controlling-the-selected-view)
     */
    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.
     */
    onDataChange?: (event: SchedulerDataChangeEvent) => void;
}

/**
 * @hidden
 */
export declare const SchedulerRemoveDialog: DefineComponent<ExtractPropTypes<    {
dataItem: PropType<any>;
onClose: PropType<(event: SchedulerRemoveDialogStateChangeEvent<null>) => void>;
onCancel: PropType<(event: SchedulerRemoveDialogStateChangeEvent<null>) => void>;
onConfirm: PropType<(event: SchedulerRemoveDialogStateChangeEvent<DataItem | null>) => void>;
}>, {
kendoLocalizationService: {};
}, {}, {}, {
handleClose({ event }: DialogCloseEvent): void;
handleCancel(event: any): void;
handleConfirm(event: any): void;
}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
dataItem: PropType<any>;
onClose: PropType<(event: SchedulerRemoveDialogStateChangeEvent<null>) => void>;
onCancel: PropType<(event: SchedulerRemoveDialogStateChangeEvent<null>) => void>;
onConfirm: PropType<(event: SchedulerRemoveDialogStateChangeEvent<DataItem | null>) => void>;
}>> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

/** @hidden */
export declare type SchedulerRemoveDialogHandle = {
    props: SchedulerRemoveDialogProps;
};

/**
 * Represents the props of the Kendo UI for Vue [SchedulerRemoveDialog]({% slug api_scheduler_schedulerremovedialogprops %}) 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;
}

declare interface SchedulerRemoveDialogStateChangeEvent<T> {
    target: SchedulerRemoveDialogHandle;
    value: T;
    event: any;
}

/** @hidden */
export declare const SchedulerResize: DefineComponent<ExtractPropTypes<    {
ignoreIsAllDay: PropType<boolean>;
dataItem: PropType<any>;
format: PropType<string>;
vertical: PropType<boolean>;
viewItem: PropType<any>;
item: {
type: PropType<any>;
default: () => DefineComponent<ExtractPropTypes<    {
uid: PropType<string | number>;
start: PropType<Date>;
end: PropType<Date>;
originalStart: PropType<Date>;
startTimezone: PropType<string>;
endTimezone: PropType<string>;
isAllDay: PropType<boolean>;
title: PropType<string>;
description: PropType<string>;
occurrenceId: PropType<string>;
recurrenceExceptions: PropType<Date[]>;
recurrenceRule: PropType<string>;
recurrenceId: PropType<string | number>;
dataItem: PropType<any>;
head: PropType<boolean>;
tail: PropType<boolean>;
order: PropType<number>;
zonedStart: PropType<ZonedDate>;
zonedEnd: PropType<ZonedDate>;
slots: PropType<Slot_3[]>;
group: PropType<Group_3>;
range: PropType<Range_4>;
isException: PropType<boolean>;
isRecurring: PropType<boolean>;
id: PropType<string>;
tabIndex: PropType<number>;
className: PropType<string>;
itemStyle: PropType<any>;
editable: PropType<boolean | EditableProp_2>;
selected: PropType<boolean>;
vertical: PropType<boolean>;
dragHint: PropType<boolean>;
resizeHint: PropType<boolean>;
format: PropType<string>;
maxSiblingsPerSlot: PropType<number>;
itemTitle: PropType<string>;
formItem: PropType<object>;
dragItem: PropType<object>;
resizeItem: PropType<object>;
removeItem: PropType<object>;
ignoreIsAllDay: PropType<boolean>;
item: PropType<string | object | Function>;
showOccurrenceDialog: {
type: PropType<boolean>;
default: any;
};
showRemoveDialog: {
type: PropType<boolean>;
default: any;
};
}>, {}, {}, {
currentEditable(): EditableProp_2;
resource(): any;
color(): any;
currentTabIndex(): any;
itemClassName(): {
[x: number]: any;
'k-event': boolean;
'k-selected': any;
'k-event-drag-hint': any;
'k-scheduler-marquee': any;
'k-marquee': any;
'k-first': boolean;
'k-last': boolean;
};
eventLabel(): string;
computedStyle(): any;
}, {
getElement(): any;
handleFocus(event: any): void;
handleBlur(event: any): void;
handleMouseDown(event: any): void;
handleClick(event: any): void;
handleMouseUp(event: any): void;
handleMouseOver(event: any): void;
handleMouseOut(event: any): void;
handleMouseEnter(event: any): void;
handleMouseLeave(event: any): void;
handleDoubleClick(event: any): void;
handleRemoveClick(event: any): void;
handleKeyDown(event: any): void;
handleKeyPress(event: any): void;
handleKeyUp(event: any): void;
handlePress(dragEvent: any): void;
handleDrag(dragEvent: any): void;
handleRelease(dragEvent: any): void;
handleResizePress(dragEvent: any): void;
handleResizeStartDrag(dragEvent: any): void;
handleResizeEndDrag(dragEvent: any): void;
handleResizeRelease(dragEvent: any): void;
handleFormClose(event: SchedulerFormStateChangeEvent_2<null> | SchedulerOccurrenceDialogStateChangeEvent_2<null>): void;
handleFormSubmit(event: SchedulerFormStateChangeEvent_2<any>): void;
handleFormCancel(event: SchedulerFormStateChangeEvent_2<null> | SchedulerOccurrenceDialogStateChangeEvent_2<null>): void;
}, ComponentOptionsMixin, ComponentOptionsMixin, {
focus: any;
blur: any;
mousedown: any;
mouseup: any;
mouseover: any;
mouseout: any;
mouseenter: any;
mouseleave: any;
click: any;
doubleclick: any;
removeclick: any;
keydown: any;
keypress: any;
keyup: any;
press: any;
drag: any;
release: any;
resizepress: any;
resizestartdrag: any;
resizeenddrag: any;
resizerelease: any;
cancel: any;
close: any;
formsubmit: any;
}, string, PublicProps, Readonly<ExtractPropTypes<    {
uid: PropType<string | number>;
start: PropType<Date>;
end: PropType<Date>;
originalStart: PropType<Date>;
startTimezone: PropType<string>;
endTimezone: PropType<string>;
isAllDay: PropType<boolean>;
title: PropType<string>;
description: PropType<string>;
occurrenceId: PropType<string>;
recurrenceExceptions: PropType<Date[]>;
recurrenceRule: PropType<string>;
recurrenceId: PropType<string | number>;
dataItem: PropType<any>;
head: PropType<boolean>;
tail: PropType<boolean>;
order: PropType<number>;
zonedStart: PropType<ZonedDate>;
zonedEnd: PropType<ZonedDate>;
slots: PropType<Slot_3[]>;
group: PropType<Group_3>;
range: PropType<Range_4>;
isException: PropType<boolean>;
isRecurring: PropType<boolean>;
id: PropType<string>;
tabIndex: PropType<number>;
className: PropType<string>;
itemStyle: PropType<any>;
editable: PropType<boolean | EditableProp_2>;
selected: PropType<boolean>;
vertical: PropType<boolean>;
dragHint: PropType<boolean>;
resizeHint: PropType<boolean>;
format: PropType<string>;
maxSiblingsPerSlot: PropType<number>;
itemTitle: PropType<string>;
formItem: PropType<object>;
dragItem: PropType<object>;
resizeItem: PropType<object>;
removeItem: PropType<object>;
ignoreIsAllDay: PropType<boolean>;
item: PropType<string | object | Function>;
showOccurrenceDialog: {
type: PropType<boolean>;
default: any;
};
showRemoveDialog: {
type: PropType<boolean>;
default: any;
};
}>> & Readonly<{
onPress?: (...args: any[] | unknown[]) => any;
onDrag?: (...args: any[] | unknown[]) => any;
onRelease?: (...args: any[] | unknown[]) => any;
onClick?: (...args: any[] | unknown[]) => any;
onBlur?: (...args: any[] | unknown[]) => any;
onCancel?: (...args: any[] | unknown[]) => any;
onClose?: (...args: any[] | unknown[]) => any;
onFocus?: (...args: any[] | unknown[]) => any;
onKeydown?: (...args: any[] | unknown[]) => any;
onKeypress?: (...args: any[] | unknown[]) => any;
onKeyup?: (...args: any[] | unknown[]) => any;
onMousedown?: (...args: any[] | unknown[]) => any;
onMouseenter?: (...args: any[] | unknown[]) => any;
onMouseleave?: (...args: any[] | unknown[]) => any;
onMouseout?: (...args: any[] | unknown[]) => any;
onMouseover?: (...args: any[] | unknown[]) => any;
onMouseup?: (...args: any[] | unknown[]) => any;
onDoubleclick?: (...args: any[] | unknown[]) => any;
onFormsubmit?: (...args: any[] | unknown[]) => any;
onRemoveclick?: (...args: any[] | unknown[]) => any;
onResizepress?: (...args: any[] | unknown[]) => any;
onResizestartdrag?: (...args: any[] | unknown[]) => any;
onResizeenddrag?: (...args: any[] | unknown[]) => any;
onResizerelease?: (...args: any[] | unknown[]) => any;
}>, {
showOccurrenceDialog: boolean;
showRemoveDialog: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
};
}>, {}, {}, {
occurrences(): Occurrence_3[];
items(): Item_2[];
}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
ignoreIsAllDay: PropType<boolean>;
dataItem: PropType<any>;
format: PropType<string>;
vertical: PropType<boolean>;
viewItem: PropType<any>;
item: {
type: PropType<any>;
default: () => DefineComponent<ExtractPropTypes<    {
uid: PropType<string | number>;
start: PropType<Date>;
end: PropType<Date>;
originalStart: PropType<Date>;
startTimezone: PropType<string>;
endTimezone: PropType<string>;
isAllDay: PropType<boolean>;
title: PropType<string>;
description: PropType<string>;
occurrenceId: PropType<string>;
recurrenceExceptions: PropType<Date[]>;
recurrenceRule: PropType<string>;
recurrenceId: PropType<string | number>;
dataItem: PropType<any>;
head: PropType<boolean>;
tail: PropType<boolean>;
order: PropType<number>;
zonedStart: PropType<ZonedDate>;
zonedEnd: PropType<ZonedDate>;
slots: PropType<Slot_3[]>;
group: PropType<Group_3>;
range: PropType<Range_4>;
isException: PropType<boolean>;
isRecurring: PropType<boolean>;
id: PropType<string>;
tabIndex: PropType<number>;
className: PropType<string>;
itemStyle: PropType<any>;
editable: PropType<boolean | EditableProp_2>;
selected: PropType<boolean>;
vertical: PropType<boolean>;
dragHint: PropType<boolean>;
resizeHint: PropType<boolean>;
format: PropType<string>;
maxSiblingsPerSlot: PropType<number>;
itemTitle: PropType<string>;
formItem: PropType<object>;
dragItem: PropType<object>;
resizeItem: PropType<object>;
removeItem: PropType<object>;
ignoreIsAllDay: PropType<boolean>;
item: PropType<string | object | Function>;
showOccurrenceDialog: {
type: PropType<boolean>;
default: any;
};
showRemoveDialog: {
type: PropType<boolean>;
default: any;
};
}>, {}, {}, {
currentEditable(): EditableProp_2;
resource(): any;
color(): any;
currentTabIndex(): any;
itemClassName(): {
[x: number]: any;
'k-event': boolean;
'k-selected': any;
'k-event-drag-hint': any;
'k-scheduler-marquee': any;
'k-marquee': any;
'k-first': boolean;
'k-last': boolean;
};
eventLabel(): string;
computedStyle(): any;
}, {
getElement(): any;
handleFocus(event: any): void;
handleBlur(event: any): void;
handleMouseDown(event: any): void;
handleClick(event: any): void;
handleMouseUp(event: any): void;
handleMouseOver(event: any): void;
handleMouseOut(event: any): void;
handleMouseEnter(event: any): void;
handleMouseLeave(event: any): void;
handleDoubleClick(event: any): void;
handleRemoveClick(event: any): void;
handleKeyDown(event: any): void;
handleKeyPress(event: any): void;
handleKeyUp(event: any): void;
handlePress(dragEvent: any): void;
handleDrag(dragEvent: any): void;
handleRelease(dragEvent: any): void;
handleResizePress(dragEvent: any): void;
handleResizeStartDrag(dragEvent: any): void;
handleResizeEndDrag(dragEvent: any): void;
handleResizeRelease(dragEvent: any): void;
handleFormClose(event: SchedulerFormStateChangeEvent_2<null> | SchedulerOccurrenceDialogStateChangeEvent_2<null>): void;
handleFormSubmit(event: SchedulerFormStateChangeEvent_2<any>): void;
handleFormCancel(event: SchedulerFormStateChangeEvent_2<null> | SchedulerOccurrenceDialogStateChangeEvent_2<null>): void;
}, ComponentOptionsMixin, ComponentOptionsMixin, {
focus: any;
blur: any;
mousedown: any;
mouseup: any;
mouseover: any;
mouseout: any;
mouseenter: any;
mouseleave: any;
click: any;
doubleclick: any;
removeclick: any;
keydown: any;
keypress: any;
keyup: any;
press: any;
drag: any;
release: any;
resizepress: any;
resizestartdrag: any;
resizeenddrag: any;
resizerelease: any;
cancel: any;
close: any;
formsubmit: any;
}, string, PublicProps, Readonly<ExtractPropTypes<    {
uid: PropType<string | number>;
start: PropType<Date>;
end: PropType<Date>;
originalStart: PropType<Date>;
startTimezone: PropType<string>;
endTimezone: PropType<string>;
isAllDay: PropType<boolean>;
title: PropType<string>;
description: PropType<string>;
occurrenceId: PropType<string>;
recurrenceExceptions: PropType<Date[]>;
recurrenceRule: PropType<string>;
recurrenceId: PropType<string | number>;
dataItem: PropType<any>;
head: PropType<boolean>;
tail: PropType<boolean>;
order: PropType<number>;
zonedStart: PropType<ZonedDate>;
zonedEnd: PropType<ZonedDate>;
slots: PropType<Slot_3[]>;
group: PropType<Group_3>;
range: PropType<Range_4>;
isException: PropType<boolean>;
isRecurring: PropType<boolean>;
id: PropType<string>;
tabIndex: PropType<number>;
className: PropType<string>;
itemStyle: PropType<any>;
editable: PropType<boolean | EditableProp_2>;
selected: PropType<boolean>;
vertical: PropType<boolean>;
dragHint: PropType<boolean>;
resizeHint: PropType<boolean>;
format: PropType<string>;
maxSiblingsPerSlot: PropType<number>;
itemTitle: PropType<string>;
formItem: PropType<object>;
dragItem: PropType<object>;
resizeItem: PropType<object>;
removeItem: PropType<object>;
ignoreIsAllDay: PropType<boolean>;
item: PropType<string | object | Function>;
showOccurrenceDialog: {
type: PropType<boolean>;
default: any;
};
showRemoveDialog: {
type: PropType<boolean>;
default: any;
};
}>> & Readonly<{
onPress?: (...args: any[] | unknown[]) => any;
onDrag?: (...args: any[] | unknown[]) => any;
onRelease?: (...args: any[] | unknown[]) => any;
onClick?: (...args: any[] | unknown[]) => any;
onBlur?: (...args: any[] | unknown[]) => any;
onCancel?: (...args: any[] | unknown[]) => any;
onClose?: (...args: any[] | unknown[]) => any;
onFocus?: (...args: any[] | unknown[]) => any;
onKeydown?: (...args: any[] | unknown[]) => any;
onKeypress?: (...args: any[] | unknown[]) => any;
onKeyup?: (...args: any[] | unknown[]) => any;
onMousedown?: (...args: any[] | unknown[]) => any;
onMouseenter?: (...args: any[] | unknown[]) => any;
onMouseleave?: (...args: any[] | unknown[]) => any;
onMouseout?: (...args: any[] | unknown[]) => any;
onMouseover?: (...args: any[] | unknown[]) => any;
onMouseup?: (...args: any[] | unknown[]) => any;
onDoubleclick?: (...args: any[] | unknown[]) => any;
onFormsubmit?: (...args: any[] | unknown[]) => any;
onRemoveclick?: (...args: any[] | unknown[]) => any;
onResizepress?: (...args: any[] | unknown[]) => any;
onResizestartdrag?: (...args: any[] | unknown[]) => any;
onResizeenddrag?: (...args: any[] | unknown[]) => any;
onResizerelease?: (...args: any[] | unknown[]) => any;
}>, {
showOccurrenceDialog: boolean;
showRemoveDialog: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
};
}>> & Readonly<{}>, {
item: any;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

/**
 * Represents the props of the Kendo UI for Vue [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?: any;
    /**
     * Overrides the default component responsible for positioning the item inside the view.
     *
     * The default Component is: [SchedulerViewItem]().
     */
    viewItem?: any;
}

/**
 * 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;
}

/**
 * @hidden
 */
export declare const SchedulerSlot: DefineComponent<ExtractPropTypes<    {
refTo: PropType<any>;
items: PropType<Item_4[]>;
row: PropType<number>;
group: PropType<Group_2>;
range: PropType<Range_5>;
className: PropType<string>;
isWorkDay: {
type: PropType<boolean>;
default: boolean;
};
isWorkHour: {
type: PropType<boolean>;
default: boolean;
};
selected: PropType<boolean>;
tabIndex: {
type: PropType<number>;
default: any;
};
col: PropType<number>;
index: PropType<number>;
start: PropType<Date>;
end: PropType<Date>;
zonedStart: PropType<ZonedDate>;
zonedEnd: PropType<ZonedDate>;
isAllDay: PropType<boolean>;
navDay: PropType<boolean>;
editable: PropType<boolean | EditableProp>;
itemsPerSlot: PropType<number>;
formItem: PropType<object>;
slotStyle: PropType<any>;
viewSlot: PropType<any>;
}>, {}, {
hasMounted: boolean;
}, {
cSlot(): any;
currentTabIndex(): any;
slotClass(): {
[x: number]: any;
'k-scheduler-cell k-slot-cell': boolean;
'k-nonwork-hour': boolean;
'k-selected': any;
};
slotLabel(): string;
}, {
handleShowMoreItemsClick(event: any): void;
handleFocus(event: any): void;
handleBlur(event: any): void;
handleClick(event: any): void;
handleMouseOver(event: any): void;
handleMouseOut(event: any): void;
handleMouseEnter(event: any): void;
handleMouseLeave(event: any): void;
handleDoubleClick(event: any): void;
handleKeyDown(event: any): void;
handleKeyPress(event: any): void;
handleKeyUp(event: any): void;
handleFormClose(event: any): void;
handleFormSubmit(event: any): void;
handleFormCancel(event: any): void;
}, ComponentOptionsMixin, ComponentOptionsMixin, {
focus: any;
blur: any;
click: any;
showmoreitems: any;
mouseover: any;
mouseout: any;
mouseenter: any;
mouseleave: any;
doubleclick: any;
keydown: any;
keypress: any;
keyup: any;
cancel: any;
close: any;
formsubmit: any;
}, string, PublicProps, Readonly<ExtractPropTypes<    {
refTo: PropType<any>;
items: PropType<Item_4[]>;
row: PropType<number>;
group: PropType<Group_2>;
range: PropType<Range_5>;
className: PropType<string>;
isWorkDay: {
type: PropType<boolean>;
default: boolean;
};
isWorkHour: {
type: PropType<boolean>;
default: boolean;
};
selected: PropType<boolean>;
tabIndex: {
type: PropType<number>;
default: any;
};
col: PropType<number>;
index: PropType<number>;
start: PropType<Date>;
end: PropType<Date>;
zonedStart: PropType<ZonedDate>;
zonedEnd: PropType<ZonedDate>;
isAllDay: PropType<boolean>;
navDay: PropType<boolean>;
editable: PropType<boolean | EditableProp>;
itemsPerSlot: PropType<number>;
formItem: PropType<object>;
slotStyle: PropType<any>;
viewSlot: PropType<any>;
}>> & Readonly<{
onClick?: (...args: any[] | unknown[]) => any;
onBlur?: (...args: any[] | unknown[]) => any;
onCancel?: (...args: any[] | unknown[]) => any;
onClose?: (...args: any[] | unknown[]) => any;
onFocus?: (...args: any[] | unknown[]) => any;
onKeydown?: (...args: any[] | unknown[]) => any;
onKeypress?: (...args: any[] | unknown[]) => any;
onKeyup?: (...args: any[] | unknown[]) => any;
onMouseenter?: (...args: any[] | unknown[]) => any;
onMouseleave?: (...args: any[] | unknown[]) => any;
onMouseout?: (...args: any[] | unknown[]) => any;
onMouseover?: (...args: any[] | unknown[]) => any;
onDoubleclick?: (...args: any[] | unknown[]) => any;
onShowmoreitems?: (...args: any[] | unknown[]) => any;
onFormsubmit?: (...args: any[] | unknown[]) => any;
}>, {
tabIndex: number;
isWorkDay: boolean;
isWorkHour: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

/**
 * 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
 */
declare interface SchedulerSlotFocusEvent {
    target: SchedulerSlotHandle;
    event: any;
}

/** @hidden */
export declare interface SchedulerSlotHandle {
    element: HTMLDivElement | null;
    props: SchedulerSlotProps;
}

/** @hidden */
declare interface SchedulerSlotKeyboardEvent {
    target: SchedulerSlotHandle;
    event: any;
}

/**
 * @hidden
 */
declare interface SchedulerSlotMouseEvent {
    target: SchedulerSlotHandle;
    event: any;
}

/**
 * Represents the props of the Kendo UI for Vue [SchedulerSlot]({% slug api_scheduler_schedulerslotprops %}) component.
 */
export declare interface SchedulerSlotProps extends Slot_2 {
    /** @hidden */
    refTo: any;
    /** @hidden */
    navDay?: boolean;
    /** @hidden */
    itemsPerSlot?: number;
    /** @hidden */
    formItem?: object;
    /** @hidden */
    viewSlot?: any;
    /** @hidden */
    slotStyle?: any;
    /** @hidden */
    className?: string;
    /**
     * 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;
    /**
     * 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: any;
}

/**
 * Represents the object passed to the `slots-select` reducer.
 */
export declare interface SchedulerSlotsSelectAction {
    type: SLOTS_SELECT_ACTION;
    slot?: any;
}

/**
 * @hidden
 */
export declare const SchedulerTask: DefineComponent<ExtractPropTypes<    {
refTo: PropType<any>;
id: PropType<string>;
tabIndex: PropType<number>;
head: PropType<boolean>;
tail: PropType<boolean>;
order: PropType<number>;
zonedStart: PropType<ZonedDate>;
zonedEnd: PropType<ZonedDate>;
slots: PropType<Slot_4[]>;
group: PropType<Group_2>;
range: PropType<Range_5>;
isException: PropType<boolean>;
isRecurring: PropType<boolean>;
isAllDay: PropType<boolean>;
uid: PropType<string | number>;
start: PropType<Date>;
end: PropType<Date>;
originalStart: PropType<Date>;
startTimezone: PropType<string>;
endTimezone: PropType<string>;
title: PropType<string>;
description: PropType<string>;
occurrenceId: PropType<string>;
recurrenceExceptions: PropType<Date[]>;
recurrenceRule: PropType<string>;
recurrenceId: PropType<string | number>;
dataItem: PropType<any>;
removeItem: PropType<object>;
editable: PropType<boolean | EditableProp>;
showOccurrenceDialog: {
type: PropType<boolean>;
default: any;
};
showRemoveDialog: {
type: PropType<boolean>;
default: any;
};
onRemoveclick: PropType<(event: SchedulerTaskMouseEvent) => void>;
}>, {}, {}, {}, {
handleRemoveClick(event: any): void;
handleClick(event: any): void;
handleDoubleClick(event: any): void;
}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
refTo: PropType<any>;
id: PropType<string>;
tabIndex: PropType<number>;
head: PropType<boolean>;
tail: PropType<boolean>;
order: PropType<number>;
zonedStart: PropType<ZonedDate>;
zonedEnd: PropType<ZonedDate>;
slots: PropType<Slot_4[]>;
group: PropType<Group_2>;
range: PropType<Range_5>;
isException: PropType<boolean>;
isRecurring: PropType<boolean>;
isAllDay: PropType<boolean>;
uid: PropType<string | number>;
start: PropType<Date>;
end: PropType<Date>;
originalStart: PropType<Date>;
startTimezone: PropType<string>;
endTimezone: PropType<string>;
title: PropType<string>;
description: PropType<string>;
occurrenceId: PropType<string>;
recurrenceExceptions: PropType<Date[]>;
recurrenceRule: PropType<string>;
recurrenceId: PropType<string | number>;
dataItem: PropType<any>;
removeItem: PropType<object>;
editable: PropType<boolean | EditableProp>;
showOccurrenceDialog: {
type: PropType<boolean>;
default: any;
};
showRemoveDialog: {
type: PropType<boolean>;
default: any;
};
onRemoveclick: PropType<(event: SchedulerTaskMouseEvent) => void>;
}>> & Readonly<{}>, {
showOccurrenceDialog: boolean;
showRemoveDialog: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

/** @hidden */
export declare interface SchedulerTaskHandle {
    element: HTMLDivElement | null;
    props: SchedulerTaskProps;
}

declare interface SchedulerTaskMouseEvent {
    target: SchedulerTaskHandle;
    event: any;
}

/**
 * Represents the props of the Kendo UI for Vue SchedulerTask.
 */
export declare interface SchedulerTaskProps extends Item_2 {
    /**
     * 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;
    /**
     * 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;
    /** @hidden */
    refTo: any;
    /** @hidden */
    removeDialog?: any;
    /** @hidden */
    occurrenceDialog?: any;
    /** @hidden */
    showRemoveDialog?: boolean;
    /** @hidden */
    showOccurrenceDialog?: boolean;
    /** @hidden */
    removeItem?: object;
}

/**
 * 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.
 */
declare interface SchedulerViewDateRangeArgs {
    date: Date;
    intl: IntlService;
    timezone?: string;
    numberOfDays?: number;
    workWeekStart?: Day;
    workWeekEnd?: Day;
}

/**
 * @hidden
 */
export declare const SchedulerViewItem: DefineComponent<ExtractPropTypes<    {
ignoreIsAllDay: PropType<boolean>;
item: PropType<any>;
uid: PropType<string | number>;
start: PropType<Date>;
end: PropType<Date>;
originalStart: PropType<Date>;
startTimezone: PropType<string>;
endTimezone: PropType<string>;
isAllDay: PropType<boolean>;
title: PropType<string>;
description: PropType<string>;
occurrenceId: PropType<string>;
recurrenceExceptions: PropType<Date[]>;
recurrenceRule: PropType<string>;
recurrenceId: PropType<string | number>;
dataItem: PropType<any>;
head: PropType<boolean>;
tail: PropType<boolean>;
order: PropType<number>;
zonedStart: PropType<ZonedDate>;
zonedEnd: PropType<ZonedDate>;
slots: PropType<Slot_4[]>;
group: PropType<Group_2>;
range: PropType<Range_5>;
isException: PropType<boolean>;
isRecurring: PropType<boolean>;
id: PropType<string>;
tabIndex: PropType<number>;
className: PropType<string>;
itemStyle: PropType<any>;
editable: PropType<boolean | EditableProp_3>;
selected: PropType<boolean>;
vertical: PropType<boolean>;
dragHint: PropType<boolean>;
resizeHint: PropType<boolean>;
format: PropType<string>;
showOccurrenceDialog: {
type: PropType<boolean>;
default: any;
};
showRemoveDialog: {
type: PropType<boolean>;
default: any;
};
formItem: PropType<object>;
dragItem: PropType<object>;
resizeItem: PropType<object>;
removeItem: PropType<object>;
itemRef: PropType<any>;
onKeydown: PropType<(e: any) => void>;
onKeyup: PropType<(e: any) => void>;
onFocus: PropType<(e: any) => void>;
onMouseup: PropType<(e: any) => void>;
onMousedown: PropType<(e: any) => void>;
onClick: PropType<(e: any) => void>;
onDoubleclick: PropType<(e: any) => void>;
onRemoveclick: PropType<(e: any) => void>;
onPress: PropType<(e: any) => void>;
onDrag: PropType<(e: any) => void>;
onRelease: PropType<(e: any) => void>;
onResizepress: PropType<(e: any) => void>;
onResizeenddrag: PropType<(e: any) => void>;
onResizestartdrag: PropType<(e: any) => void>;
onResizerelease: PropType<(e: any) => void>;
}>, {}, {
timeout: any;
currentItem: any;
viewItem: any;
display: boolean;
visible: boolean;
maxSiblingsPerSlot: number;
}, {
itemTime(): any;
itemTitle(): string;
}, {
getElement(): any;
handleFocus(e: any): void;
handleBlur(e: any): void;
handleMouseDown(e: any): void;
handleClick(e: any): void;
handleMouseUp(e: any): void;
handleMouseOver(e: any): void;
handleMouseOut(e: any): void;
handleMouseEnter(e: any): void;
handleMouseLeave(e: any): void;
handleDoubleClick(e: any): void;
handleRemoveClick(e: any): void;
handleKeyDown(e: any): void;
handleKeyPress(e: any): void;
handleKeyUp(e: any): void;
handlePress(e: any): void;
handleDrag(e: any): void;
handleRelease(e: any): void;
handleResizePress(e: any): void;
handleResizeStartDrag(e: any): void;
handleResizeEndDrag(e: any): void;
handleResizeRelease(e: any): void;
calculateMostSiblings(slots: any[], items: any[]): number;
getSiblingsInAllSlots(slots: any[], items: any[]): SchedulerItemHandle[][];
inSlot(slot: SchedulerSlotProps, current: SchedulerItemProps): any;
align(): void;
position(): void;
handleResize(): void;
}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
ignoreIsAllDay: PropType<boolean>;
item: PropType<any>;
uid: PropType<string | number>;
start: PropType<Date>;
end: PropType<Date>;
originalStart: PropType<Date>;
startTimezone: PropType<string>;
endTimezone: PropType<string>;
isAllDay: PropType<boolean>;
title: PropType<string>;
description: PropType<string>;
occurrenceId: PropType<string>;
recurrenceExceptions: PropType<Date[]>;
recurrenceRule: PropType<string>;
recurrenceId: PropType<string | number>;
dataItem: PropType<any>;
head: PropType<boolean>;
tail: PropType<boolean>;
order: PropType<number>;
zonedStart: PropType<ZonedDate>;
zonedEnd: PropType<ZonedDate>;
slots: PropType<Slot_4[]>;
group: PropType<Group_2>;
range: PropType<Range_5>;
isException: PropType<boolean>;
isRecurring: PropType<boolean>;
id: PropType<string>;
tabIndex: PropType<number>;
className: PropType<string>;
itemStyle: PropType<any>;
editable: PropType<boolean | EditableProp_3>;
selected: PropType<boolean>;
vertical: PropType<boolean>;
dragHint: PropType<boolean>;
resizeHint: PropType<boolean>;
format: PropType<string>;
showOccurrenceDialog: {
type: PropType<boolean>;
default: any;
};
showRemoveDialog: {
type: PropType<boolean>;
default: any;
};
formItem: PropType<object>;
dragItem: PropType<object>;
resizeItem: PropType<object>;
removeItem: PropType<object>;
itemRef: PropType<any>;
onKeydown: PropType<(e: any) => void>;
onKeyup: PropType<(e: any) => void>;
onFocus: PropType<(e: any) => void>;
onMouseup: PropType<(e: any) => void>;
onMousedown: PropType<(e: any) => void>;
onClick: PropType<(e: any) => void>;
onDoubleclick: PropType<(e: any) => void>;
onRemoveclick: PropType<(e: any) => void>;
onPress: PropType<(e: any) => void>;
onDrag: PropType<(e: any) => void>;
onRelease: PropType<(e: any) => void>;
onResizepress: PropType<(e: any) => void>;
onResizeenddrag: PropType<(e: any) => void>;
onResizestartdrag: PropType<(e: any) => void>;
onResizerelease: PropType<(e: any) => void>;
}>> & Readonly<{}>, {
showOccurrenceDialog: boolean;
showRemoveDialog: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

/** @hidden */
export declare interface SchedulerViewItemHandle {
    element: HTMLDivElement | null;
    props: SchedulerViewItemProps;
}

/**
 * Represents the props of the Kendo UI for Vue [SchedulerViewItem]({% slug api_scheduler_schedulerviewitemprops %}) component.
 */
export declare interface SchedulerViewItemProps extends SchedulerItemProps {
    /** @hidden */
    ignoreIsAllDay?: boolean;
    /** @hidden */
    onKeydown?: (e: any) => void;
    /** @hidden */
    onKeyup?: (e: any) => void;
    /** @hidden */
    onFocus?: (e: any) => void;
    /** @hidden */
    onMouseup?: (e: any) => void;
    /** @hidden */
    onMousedown?: (e: any) => void;
    /** @hidden */
    onClick?: (e: any) => void;
    /** @hidden */
    onDoubleclick?: (e: any) => void;
    /** @hidden */
    onRemoveclick?: (e: any) => void;
    /** @hidden */
    onPress?: (e: any) => void;
    /** @hidden */
    onDrag?: (e: any) => void;
    /** @hidden */
    onRelease?: (e: any) => void;
    /** @hidden */
    onResizepress?: (e: any) => void;
    /** @hidden */
    onResizeenddrag?: (e: any) => void;
    /** @hidden */
    onResizestartdrag?: (e: any) => void;
    /** @hidden */
    onResizerelease?: (e: any) => void;
    /**
     * Overrides the default component responsible for visualizing a single item.
     *
     * The default Component is: [SchedulerItem]({% slug api_scheduler_scheduleritemprops %}).
     */
    item?: any;
}

/**
 * Represents the required props which every [SchedulerView]({% slug api_scheduler_schedulerviewprops %}) must accept.
 */
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?: any;
    /** @hidden */
    footer?: any;
    /** @hidden */
    slotDivisions?: number;
    /** @hidden */
    slotDuration?: number;
    /** @hidden */
    workWeekStart?: Day;
    /** @hidden */
    workWeekEnd?: Day;
    /** @hidden */
    format?: string;
    /**
     * Overrides the `dragItem` prop of the Scheduler for the specified view only.
     */
    dragItem?: any;
    /**
     * Overrides the `resizeItem` prop of the Scheduler for the specified view only.
     */
    resizeItem?: any;
}

/**
 * @hidden
 */
export declare const SchedulerViewSelector: DefineComponent<    {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

/** @hidden */
export declare interface SchedulerViewSelectorProps {
}

/**
 * @hidden
 */
export declare const SchedulerViewSlot: DefineComponent<ExtractPropTypes<    {
refTo: PropType<any>;
className: PropType<string>;
items: PropType<Item_4[]>;
row: PropType<number>;
group: PropType<Group_2>;
range: PropType<Range_5>;
isWorkDay: {
type: PropType<boolean>;
default: boolean;
};
isWorkHour: {
type: PropType<boolean>;
default: boolean;
};
selected: PropType<boolean>;
col: PropType<number>;
index: PropType<number>;
start: PropType<Date>;
end: PropType<Date>;
zonedStart: PropType<ZonedDate>;
zonedEnd: PropType<ZonedDate>;
slotRender: PropType<any>;
expandable: PropType<boolean | SchedulerSlotExpandableConfig>;
isAllDay: PropType<boolean>;
navDay: PropType<boolean>;
editable: PropType<boolean | EditableProp_3>;
itemsPerSlot: PropType<number>;
formItem: PropType<object>;
tabIndex: {
type: PropType<number>;
default: any;
};
slotStyle: PropType<any>;
}>, {}, {
timeout: any;
}, {
cSlot(): any;
}, {
handleShowMoreItemsClick(event: any): void;
handleDoubleClick(args: any): void;
handleKeyDown(args: any): void;
handleFocus(args: any): void;
handleResize(): void;
}, ComponentOptionsMixin, ComponentOptionsMixin, {
focus: any;
showmoreitems: any;
doubleclick: any;
keydown: any;
}, string, PublicProps, Readonly<ExtractPropTypes<    {
refTo: PropType<any>;
className: PropType<string>;
items: PropType<Item_4[]>;
row: PropType<number>;
group: PropType<Group_2>;
range: PropType<Range_5>;
isWorkDay: {
type: PropType<boolean>;
default: boolean;
};
isWorkHour: {
type: PropType<boolean>;
default: boolean;
};
selected: PropType<boolean>;
col: PropType<number>;
index: PropType<number>;
start: PropType<Date>;
end: PropType<Date>;
zonedStart: PropType<ZonedDate>;
zonedEnd: PropType<ZonedDate>;
slotRender: PropType<any>;
expandable: PropType<boolean | SchedulerSlotExpandableConfig>;
isAllDay: PropType<boolean>;
navDay: PropType<boolean>;
editable: PropType<boolean | EditableProp_3>;
itemsPerSlot: PropType<number>;
formItem: PropType<object>;
tabIndex: {
type: PropType<number>;
default: any;
};
slotStyle: PropType<any>;
}>> & Readonly<{
onFocus?: (...args: any[] | unknown[]) => any;
onKeydown?: (...args: any[] | unknown[]) => any;
onDoubleclick?: (...args: any[] | unknown[]) => any;
onShowmoreitems?: (...args: any[] | unknown[]) => any;
}>, {
tabIndex: number;
isWorkDay: boolean;
isWorkHour: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

/** @hidden */
export declare interface SchedulerViewSlotHandle {
    props: SchedulerViewSlotProps;
}

/**
 * Represents the props of the Kendo UI for Vue [SchedulerViewSlot]({% slug api_scheduler_schedulerviewslotprops %}) component.
 */
export declare interface SchedulerViewSlotProps extends SchedulerSlotProps {
    /**
     * Overrides the default component responsible for view-specific functionality.
     *
     * The default Component is: [SchedulerSlot]({% slug api_scheduler_schedulerslotprops %}).
     */
    slotRender?: any;
    /**
     * Set to `false` will render the `slot` as is, without expanding depending on the `items` inside it.
     */
    expandable?: boolean | SchedulerSlotExpandableConfig;
}

/**
 * @hidden
 */
export declare const SchedulerViewTask: DefineComponent<ExtractPropTypes<    {
itemRef: PropType<any>;
id: PropType<string>;
tabIndex: PropType<number>;
head: PropType<boolean>;
tail: PropType<boolean>;
order: PropType<number>;
zonedStart: PropType<ZonedDate>;
zonedEnd: PropType<ZonedDate>;
slots: PropType<Slot_4[]>;
group: PropType<Group_2>;
range: PropType<Range_5>;
isException: PropType<boolean>;
isRecurring: PropType<boolean>;
isAllDay: PropType<boolean>;
uid: PropType<string | number>;
start: PropType<Date>;
end: PropType<Date>;
originalStart: PropType<Date>;
startTimezone: PropType<string>;
endTimezone: PropType<string>;
title: PropType<string>;
description: PropType<string>;
occurrenceId: PropType<string>;
recurrenceExceptions: PropType<Date[]>;
recurrenceRule: PropType<string>;
recurrenceId: PropType<string | number>;
dataItem: PropType<any>;
removeItem: PropType<object>;
task: PropType<any>;
editable: PropType<boolean | EditableProp_3>;
showOccurrenceDialog: {
type: PropType<boolean>;
default: any;
};
showRemoveDialog: {
type: PropType<boolean>;
default: any;
};
onRemoveclick: PropType<Function>;
}>, {}, {}, {}, {
handleRemoveClick(event: SchedulerTaskMouseEvent): void;
}, ComponentOptionsMixin, ComponentOptionsMixin, "removeclick"[], "removeclick", PublicProps, Readonly<ExtractPropTypes<    {
itemRef: PropType<any>;
id: PropType<string>;
tabIndex: PropType<number>;
head: PropType<boolean>;
tail: PropType<boolean>;
order: PropType<number>;
zonedStart: PropType<ZonedDate>;
zonedEnd: PropType<ZonedDate>;
slots: PropType<Slot_4[]>;
group: PropType<Group_2>;
range: PropType<Range_5>;
isException: PropType<boolean>;
isRecurring: PropType<boolean>;
isAllDay: PropType<boolean>;
uid: PropType<string | number>;
start: PropType<Date>;
end: PropType<Date>;
originalStart: PropType<Date>;
startTimezone: PropType<string>;
endTimezone: PropType<string>;
title: PropType<string>;
description: PropType<string>;
occurrenceId: PropType<string>;
recurrenceExceptions: PropType<Date[]>;
recurrenceRule: PropType<string>;
recurrenceId: PropType<string | number>;
dataItem: PropType<any>;
removeItem: PropType<object>;
task: PropType<any>;
editable: PropType<boolean | EditableProp_3>;
showOccurrenceDialog: {
type: PropType<boolean>;
default: any;
};
showRemoveDialog: {
type: PropType<boolean>;
default: any;
};
onRemoveclick: PropType<Function>;
}>> & Readonly<{
onRemoveclick?: (...args: any[]) => any;
}>, {
showOccurrenceDialog: boolean;
showRemoveDialog: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

/** @hidden */
export declare interface SchedulerViewTaskHandle {
    element: HTMLDivElement | null;
    props: SchedulerViewTaskProps;
}

/**
 * Represents the props of the Kendo UI for Vue [SchedulerViewTask]({% slug api_scheduler_schedulerviewtaskprops %}) 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_schedulertaskprops %}).
     */
    task?: any;
    /** @hidden */
    onRemoveclick?: Function;
}

/**
 * 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 */
declare interface Slot_2 {
    /** @hidden */
    refTo: any;
    /** @hidden */
    cSlot?: any;
    /**
     * 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_2[];
    /**
     * Represents the current group in which the slot is rendered.
     */
    group: Group;
    /**
     * Represents the current range in which the slot is rendered.
     */
    range: Range_3;
    /**
     * 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
 */
export declare const TimeHeaderCell: DefineComponent<ExtractPropTypes<    {
as: PropType<any>;
format: {
type: PropType<string | DateFormatOptions>;
default: string;
};
date: PropType<Date>;
start: PropType<Date>;
end: PropType<Date>;
}>, {
kendoIntlService: {};
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
as: PropType<any>;
format: {
type: PropType<string | DateFormatOptions>;
default: string;
};
date: PropType<Date>;
start: PropType<Date>;
end: PropType<Date>;
}>> & Readonly<{}>, {
format: string;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

/** @hidden */
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` component.
 */
export declare interface TimeHeaderCellProps {
    /** @hidden */
    as?: any;
    /**
     * 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 const TimelineView: DefineComponent<ExtractPropTypes<    {
name: {
type: PropType<string>;
default: string;
};
title: {
type: PropType<string | ((localization: LocalizationService) => string)>;
default: string;
};
currentTimeMarker: {
type: PropType<boolean>;
default: boolean;
};
dateRange: {
type: PropType<DateRange_2 | ((args: SchedulerViewDateRangeArgs_3) => DateRange_2)>;
default: () => any;
};
showWorkHours: {
type: PropType<boolean>;
default: boolean;
};
selectedDateFormat: {
type: PropType<string>;
default: string;
};
selectedShortDateFormat: {
type: PropType<string>;
default: string;
};
step: {
type: PropType<number>;
default: number;
};
numberOfDays: {
type: PropType<number>;
default: number;
};
startTime: {
type: PropType<string>;
default: string;
};
endTime: {
type: PropType<string>;
default: string;
};
workDayStart: {
type: PropType<string>;
default: string;
};
workDayEnd: {
type: PropType<string>;
default: string;
};
workWeekStart: {
type: PropType<Day>;
default: Day;
};
workWeekEnd: {
type: PropType<Day>;
default: Day;
};
slotDivisions: {
type: PropType<number>;
default: number;
};
slotDuration: {
type: PropType<number>;
default: number;
};
defaultShowWorkHours: {
type: PropType<boolean>;
default: boolean;
};
columnWidth: {
type: PropType<number>;
default: number;
};
dragItem: {
type: PropType<any>;
default: () => any;
};
resizeItem: {
type: PropType<any>;
default: () => any;
};
dateHeaderCell: PropType<any>;
timeHeaderCell: PropType<any>;
slotRender: PropType<any>;
viewSlot: PropType<any>;
resizeHint: PropType<any>;
item: PropType<any>;
viewItem: PropType<any>;
editable: PropType<boolean | EditableProp_2>;
}>, {}, {}, {}, {
handleDataAction(action: DataAction): void;
}, ComponentOptionsMixin, ComponentOptionsMixin, {
dataaction: any;
}, string, PublicProps, Readonly<ExtractPropTypes<    {
name: {
type: PropType<string>;
default: string;
};
title: {
type: PropType<string | ((localization: LocalizationService) => string)>;
default: string;
};
currentTimeMarker: {
type: PropType<boolean>;
default: boolean;
};
dateRange: {
type: PropType<DateRange_2 | ((args: SchedulerViewDateRangeArgs_3) => DateRange_2)>;
default: () => any;
};
showWorkHours: {
type: PropType<boolean>;
default: boolean;
};
selectedDateFormat: {
type: PropType<string>;
default: string;
};
selectedShortDateFormat: {
type: PropType<string>;
default: string;
};
step: {
type: PropType<number>;
default: number;
};
numberOfDays: {
type: PropType<number>;
default: number;
};
startTime: {
type: PropType<string>;
default: string;
};
endTime: {
type: PropType<string>;
default: string;
};
workDayStart: {
type: PropType<string>;
default: string;
};
workDayEnd: {
type: PropType<string>;
default: string;
};
workWeekStart: {
type: PropType<Day>;
default: Day;
};
workWeekEnd: {
type: PropType<Day>;
default: Day;
};
slotDivisions: {
type: PropType<number>;
default: number;
};
slotDuration: {
type: PropType<number>;
default: number;
};
defaultShowWorkHours: {
type: PropType<boolean>;
default: boolean;
};
columnWidth: {
type: PropType<number>;
default: number;
};
dragItem: {
type: PropType<any>;
default: () => any;
};
resizeItem: {
type: PropType<any>;
default: () => any;
};
dateHeaderCell: PropType<any>;
timeHeaderCell: PropType<any>;
slotRender: PropType<any>;
viewSlot: PropType<any>;
resizeHint: PropType<any>;
item: PropType<any>;
viewItem: PropType<any>;
editable: PropType<boolean | EditableProp_2>;
}>> & Readonly<{
onDataaction?: (...args: any[] | unknown[]) => any;
}>, {
name: string;
title: string | ((localization: LocalizationService) => string);
step: number;
startTime: string;
columnWidth: number;
dragItem: any;
resizeItem: any;
numberOfDays: number;
selectedDateFormat: string;
selectedShortDateFormat: string;
dateRange: DateRange_2 | ((args: SchedulerViewDateRangeArgs_3) => DateRange_2);
slotDivisions: number;
slotDuration: number;
workWeekStart: Day;
workWeekEnd: Day;
currentTimeMarker: boolean;
workDayStart: string;
workDayEnd: string;
showWorkHours: boolean;
endTime: string;
defaultShowWorkHours: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

/** @hidden */
export declare const WeekView: DefineComponent<ExtractPropTypes<    {
name: {
type: PropType<string>;
default: string;
};
slotDuration: {
type: PropType<number>;
default: number;
};
slotDivisions: {
type: PropType<number>;
default: number;
};
numberOfDays: {
type: PropType<number>;
default: number;
};
dateRange: {
type: PropType<DateRange | ((args: SchedulerViewDateRangeArgs) => DateRange)>;
default: () => ({ intl, date, timezone }: SchedulerViewDateRangeArgs) => DateRange;
};
title: PropType<string | ((localization: LocalizationService) => string)>;
selectedDateFormat: {
type: PropType<string>;
default: string;
};
selectedShortDateFormat: {
type: PropType<string>;
default: string;
};
showWorkHours: {
type: PropType<boolean>;
default: boolean;
};
currentTimeMarker: {
type: PropType<boolean>;
default: boolean;
};
startTime: {
type: PropType<string>;
default: string;
};
endTime: {
type: PropType<string>;
default: string;
};
workDayStart: {
type: PropType<string>;
default: string;
};
workDayEnd: {
type: PropType<string>;
default: string;
};
workWeekStart: {
type: PropType<Day>;
default: Day;
};
workWeekEnd: {
type: PropType<Day>;
default: Day;
};
defaultShowWorkHours: {
type: PropType<boolean>;
default: boolean;
};
dateHeaderCell: PropType<any>;
timeHeaderCell: PropType<any>;
slotRender: PropType<any>;
viewSlot: PropType<any>;
resizeHint: PropType<any>;
item: PropType<any>;
viewItem: PropType<any>;
editable: {
type: PropType<boolean>;
default: boolean;
};
format: PropType<string>;
}>, {}, {}, {}, {
handleDataAction(action: DataAction): void;
}, ComponentOptionsMixin, ComponentOptionsMixin, {
dataaction: any;
}, string, PublicProps, Readonly<ExtractPropTypes<    {
name: {
type: PropType<string>;
default: string;
};
slotDuration: {
type: PropType<number>;
default: number;
};
slotDivisions: {
type: PropType<number>;
default: number;
};
numberOfDays: {
type: PropType<number>;
default: number;
};
dateRange: {
type: PropType<DateRange | ((args: SchedulerViewDateRangeArgs) => DateRange)>;
default: () => ({ intl, date, timezone }: SchedulerViewDateRangeArgs) => DateRange;
};
title: PropType<string | ((localization: LocalizationService) => string)>;
selectedDateFormat: {
type: PropType<string>;
default: string;
};
selectedShortDateFormat: {
type: PropType<string>;
default: string;
};
showWorkHours: {
type: PropType<boolean>;
default: boolean;
};
currentTimeMarker: {
type: PropType<boolean>;
default: boolean;
};
startTime: {
type: PropType<string>;
default: string;
};
endTime: {
type: PropType<string>;
default: string;
};
workDayStart: {
type: PropType<string>;
default: string;
};
workDayEnd: {
type: PropType<string>;
default: string;
};
workWeekStart: {
type: PropType<Day>;
default: Day;
};
workWeekEnd: {
type: PropType<Day>;
default: Day;
};
defaultShowWorkHours: {
type: PropType<boolean>;
default: boolean;
};
dateHeaderCell: PropType<any>;
timeHeaderCell: PropType<any>;
slotRender: PropType<any>;
viewSlot: PropType<any>;
resizeHint: PropType<any>;
item: PropType<any>;
viewItem: PropType<any>;
editable: {
type: PropType<boolean>;
default: boolean;
};
format: PropType<string>;
}>> & Readonly<{
onDataaction?: (...args: any[] | unknown[]) => any;
}>, {
name: string;
startTime: string;
editable: boolean;
numberOfDays: number;
selectedDateFormat: string;
selectedShortDateFormat: string;
dateRange: DateRange | ((args: SchedulerViewDateRangeArgs) => DateRange);
slotDivisions: number;
slotDuration: number;
workWeekStart: Day;
workWeekEnd: Day;
currentTimeMarker: boolean;
workDayStart: string;
workDayEnd: string;
showWorkHours: boolean;
endTime: string;
defaultShowWorkHours: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

/** @hidden */
export declare const WorkWeekView: DefineComponent<ExtractPropTypes<    {
name: {
type: PropType<string>;
default: string;
};
slotDuration: {
type: PropType<number>;
default: number;
};
slotDivisions: {
type: PropType<number>;
default: number;
};
numberOfDays: {
type: PropType<number>;
default: number;
};
dateRange: {
type: PropType<DateRange | ((args: SchedulerViewDateRangeArgs) => DateRange)>;
default: () => ({ intl, date, timezone, ...other }: SchedulerViewDateRangeArgs) => DateRange;
};
title: PropType<string | ((localization: LocalizationService) => string)>;
workWeekStart: {
type: PropType<Day>;
default: Day;
};
workWeekEnd: {
type: PropType<Day>;
default: Day;
};
selectedDateFormat: {
type: PropType<string>;
default: string;
};
selectedShortDateFormat: {
type: PropType<string>;
default: string;
};
showWorkHours: {
type: PropType<boolean>;
default: boolean;
};
dateHeaderCell: PropType<any>;
timeHeaderCell: PropType<any>;
slotRender: PropType<any>;
viewSlot: PropType<any>;
resizeHint: PropType<any>;
item: PropType<any>;
viewItem: PropType<any>;
editable: {
type: PropType<boolean>;
default: boolean;
};
}>, {}, {}, {}, {
handleDataAction(action: DataAction): void;
}, ComponentOptionsMixin, ComponentOptionsMixin, {
dataaction: any;
}, string, PublicProps, Readonly<ExtractPropTypes<    {
name: {
type: PropType<string>;
default: string;
};
slotDuration: {
type: PropType<number>;
default: number;
};
slotDivisions: {
type: PropType<number>;
default: number;
};
numberOfDays: {
type: PropType<number>;
default: number;
};
dateRange: {
type: PropType<DateRange | ((args: SchedulerViewDateRangeArgs) => DateRange)>;
default: () => ({ intl, date, timezone, ...other }: SchedulerViewDateRangeArgs) => DateRange;
};
title: PropType<string | ((localization: LocalizationService) => string)>;
workWeekStart: {
type: PropType<Day>;
default: Day;
};
workWeekEnd: {
type: PropType<Day>;
default: Day;
};
selectedDateFormat: {
type: PropType<string>;
default: string;
};
selectedShortDateFormat: {
type: PropType<string>;
default: string;
};
showWorkHours: {
type: PropType<boolean>;
default: boolean;
};
dateHeaderCell: PropType<any>;
timeHeaderCell: PropType<any>;
slotRender: PropType<any>;
viewSlot: PropType<any>;
resizeHint: PropType<any>;
item: PropType<any>;
viewItem: PropType<any>;
editable: {
type: PropType<boolean>;
default: boolean;
};
}>> & Readonly<{
onDataaction?: (...args: any[] | unknown[]) => any;
}>, {
name: string;
editable: boolean;
numberOfDays: number;
selectedDateFormat: string;
selectedShortDateFormat: string;
dateRange: DateRange | ((args: SchedulerViewDateRangeArgs) => DateRange);
slotDivisions: number;
slotDuration: number;
workWeekStart: Day;
workWeekEnd: Day;
showWorkHours: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export { }