@primeui/vue-scheduler 0.0.1-alpha.1

package/dist/Scheduler.utility-context.d.mts

@@ -0,0 +1,112 @@
+import { type ComputedRef, type InjectionKey, type PropType } from 'vue';
+import type { EventCategory, SchedulerEvent } from '@primeui/scheduler-core';
+import type { SchedulerOutletRendererProps } from './shell/outletRenderers';
+export type SchedulerUtilityPartId = string | number;
+export interface SchedulerSelectionToolbarContext {
+    selectedEventIds: SchedulerUtilityPartId[];
+    selectedEvents: SchedulerEvent[];
+    selectedCount: number;
+    clearSelection: () => void;
+    selectAll: () => void;
+    invertSelection: () => void;
+    totalEvents: number;
+    selectionEnabled: boolean;
+    selectionMode: string;
+    selectionModeActive: boolean;
+    selectedCountLabel: string;
+    clearLabel: string;
+}
+export interface SchedulerCategoryLegendContext {
+    categories: EventCategory[];
+    counts: Record<SchedulerUtilityPartId, number>;
+    activeIds: SchedulerUtilityPartId[];
+    categoryHoverId: SchedulerUtilityPartId | null;
+    categoryFilterable: boolean;
+    isFilterable: boolean;
+    toggle: (id: SchedulerUtilityPartId) => void;
+    toggleCategory: (id: SchedulerUtilityPartId) => void;
+    isActive: (id: SchedulerUtilityPartId) => boolean;
+    setCategoryHover: (id: SchedulerUtilityPartId) => void;
+    clearCategoryHover: () => void;
+    clear: () => void;
+}
+export interface SchedulerAgendaDateHeaderContext {
+    date: Date;
+    dayNumber: number;
+    dayNumberLabel: string;
+    dayOfMonth: number;
+    dayOfMonthLabel: string;
+    dayName: string;
+    formattedDate: string;
+    isToday: boolean;
+    eventCount: number;
+    eventCountText: string;
+    formatDate: (date: Date, options?: Intl.DateTimeFormatOptions) => string;
+    'day-number': number;
+    'day-number-label': string;
+    'day-of-month': number;
+    'day-of-month-label': string;
+    'event-count': number;
+    'format-date': (date: Date, options?: Intl.DateTimeFormatOptions) => string;
+}
+export declare const SCHEDULER_SELECTION_TOOLBAR_CONTEXT_KEY: InjectionKey<ComputedRef<SchedulerSelectionToolbarContext>>;
+export declare const SCHEDULER_CATEGORY_LEGEND_CONTEXT_KEY: InjectionKey<ComputedRef<SchedulerCategoryLegendContext>>;
+export declare const SCHEDULER_AGENDA_DATE_HEADER_CONTEXT_KEY: InjectionKey<ComputedRef<SchedulerAgendaDateHeaderContext>>;
+export declare function useSchedulerSelectionToolbarContext(options: {
+    optional: true;
+}): ComputedRef<SchedulerSelectionToolbarContext> | null;
+export declare function useSchedulerSelectionToolbarContext(options?: {
+    optional?: false;
+}): ComputedRef<SchedulerSelectionToolbarContext>;
+export declare function useSchedulerCategoryLegendContext(options: {
+    optional: true;
+}): ComputedRef<SchedulerCategoryLegendContext> | null;
+export declare function useSchedulerCategoryLegendContext(options?: {
+    optional?: false;
+}): ComputedRef<SchedulerCategoryLegendContext>;
+export declare function useSchedulerAgendaDateHeaderContext(options: {
+    optional: true;
+}): ComputedRef<SchedulerAgendaDateHeaderContext> | null;
+export declare function useSchedulerAgendaDateHeaderContext(options?: {
+    optional?: false;
+}): ComputedRef<SchedulerAgendaDateHeaderContext>;
+export declare const SchedulerSelectionToolbarContextProvider: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    value: {
+        type: PropType<SchedulerSelectionToolbarContext>;
+        required: true;
+    };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>[] | undefined, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    value: {
+        type: PropType<SchedulerSelectionToolbarContext>;
+        required: true;
+    };
+}>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export declare const SchedulerCategoryLegendContextProvider: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    value: {
+        type: PropType<SchedulerCategoryLegendContext>;
+        required: true;
+    };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>[] | undefined, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    value: {
+        type: PropType<SchedulerCategoryLegendContext>;
+        required: true;
+    };
+}>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export declare const SchedulerAgendaDateHeaderContextProvider: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    value: {
+        type: PropType<SchedulerAgendaDateHeaderContext>;
+        required: true;
+    };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>[] | undefined, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    value: {
+        type: PropType<SchedulerAgendaDateHeaderContext>;
+        required: true;
+    };
+}>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export declare function createSchedulerAgendaDateHeaderContext(runtimeProps: SchedulerOutletRendererProps): SchedulerAgendaDateHeaderContext | null;

package/dist/Scheduler.utility-context.d.ts

@@ -0,0 +1,112 @@
+import { type ComputedRef, type InjectionKey, type PropType } from 'vue';
+import type { EventCategory, SchedulerEvent } from '@primeui/scheduler-core';
+import type { SchedulerOutletRendererProps } from './shell/outletRenderers';
+export type SchedulerUtilityPartId = string | number;
+export interface SchedulerSelectionToolbarContext {
+    selectedEventIds: SchedulerUtilityPartId[];
+    selectedEvents: SchedulerEvent[];
+    selectedCount: number;
+    clearSelection: () => void;
+    selectAll: () => void;
+    invertSelection: () => void;
+    totalEvents: number;
+    selectionEnabled: boolean;
+    selectionMode: string;
+    selectionModeActive: boolean;
+    selectedCountLabel: string;
+    clearLabel: string;
+}
+export interface SchedulerCategoryLegendContext {
+    categories: EventCategory[];
+    counts: Record<SchedulerUtilityPartId, number>;
+    activeIds: SchedulerUtilityPartId[];
+    categoryHoverId: SchedulerUtilityPartId | null;
+    categoryFilterable: boolean;
+    isFilterable: boolean;
+    toggle: (id: SchedulerUtilityPartId) => void;
+    toggleCategory: (id: SchedulerUtilityPartId) => void;
+    isActive: (id: SchedulerUtilityPartId) => boolean;
+    setCategoryHover: (id: SchedulerUtilityPartId) => void;
+    clearCategoryHover: () => void;
+    clear: () => void;
+}
+export interface SchedulerAgendaDateHeaderContext {
+    date: Date;
+    dayNumber: number;
+    dayNumberLabel: string;
+    dayOfMonth: number;
+    dayOfMonthLabel: string;
+    dayName: string;
+    formattedDate: string;
+    isToday: boolean;
+    eventCount: number;
+    eventCountText: string;
+    formatDate: (date: Date, options?: Intl.DateTimeFormatOptions) => string;
+    'day-number': number;
+    'day-number-label': string;
+    'day-of-month': number;
+    'day-of-month-label': string;
+    'event-count': number;
+    'format-date': (date: Date, options?: Intl.DateTimeFormatOptions) => string;
+}
+export declare const SCHEDULER_SELECTION_TOOLBAR_CONTEXT_KEY: InjectionKey<ComputedRef<SchedulerSelectionToolbarContext>>;
+export declare const SCHEDULER_CATEGORY_LEGEND_CONTEXT_KEY: InjectionKey<ComputedRef<SchedulerCategoryLegendContext>>;
+export declare const SCHEDULER_AGENDA_DATE_HEADER_CONTEXT_KEY: InjectionKey<ComputedRef<SchedulerAgendaDateHeaderContext>>;
+export declare function useSchedulerSelectionToolbarContext(options: {
+    optional: true;
+}): ComputedRef<SchedulerSelectionToolbarContext> | null;
+export declare function useSchedulerSelectionToolbarContext(options?: {
+    optional?: false;
+}): ComputedRef<SchedulerSelectionToolbarContext>;
+export declare function useSchedulerCategoryLegendContext(options: {
+    optional: true;
+}): ComputedRef<SchedulerCategoryLegendContext> | null;
+export declare function useSchedulerCategoryLegendContext(options?: {
+    optional?: false;
+}): ComputedRef<SchedulerCategoryLegendContext>;
+export declare function useSchedulerAgendaDateHeaderContext(options: {
+    optional: true;
+}): ComputedRef<SchedulerAgendaDateHeaderContext> | null;
+export declare function useSchedulerAgendaDateHeaderContext(options?: {
+    optional?: false;
+}): ComputedRef<SchedulerAgendaDateHeaderContext>;
+export declare const SchedulerSelectionToolbarContextProvider: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    value: {
+        type: PropType<SchedulerSelectionToolbarContext>;
+        required: true;
+    };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>[] | undefined, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    value: {
+        type: PropType<SchedulerSelectionToolbarContext>;
+        required: true;
+    };
+}>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export declare const SchedulerCategoryLegendContextProvider: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    value: {
+        type: PropType<SchedulerCategoryLegendContext>;
+        required: true;
+    };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>[] | undefined, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    value: {
+        type: PropType<SchedulerCategoryLegendContext>;
+        required: true;
+    };
+}>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export declare const SchedulerAgendaDateHeaderContextProvider: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    value: {
+        type: PropType<SchedulerAgendaDateHeaderContext>;
+        required: true;
+    };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>[] | undefined, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    value: {
+        type: PropType<SchedulerAgendaDateHeaderContext>;
+        required: true;
+    };
+}>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export declare function createSchedulerAgendaDateHeaderContext(runtimeProps: SchedulerOutletRendererProps): SchedulerAgendaDateHeaderContext | null;

package/dist/Scheduler.vue.d.mts

@@ -0,0 +1,428 @@
+import type { CapacityExceededPayload, ConflictDetectedPayload, DateRange, EventDropPayload, EventResizeStopPayload, EventResourceChangePayload, EventSelectionLimitReachedPayload, InlineEditCancelPayload, InlineEditSavePayload, QuickInfoDeletePayload, QuickInfoEditPayload, QuickInfoHidePayload, RecurrenceDeletePayload, RecurrenceEditPayload, ResourceCollapsePayload, ResourceExpandPayload, SchedulerBulkDeletePayload, SchedulerBulkMovePayload, SchedulerBulkUpdatePayload, SchedulerEvent, SchedulerEventSelectionChangePayload, SchedulerResource, SchedulerSelectionChangePayload, SchedulerViewType, SlotBookPayload, SlotCancelPayload } from '@primeui/scheduler-core';
+import type { VueContextMenuContext, VueEventDragPayload, VueEventDragStartPayload, VueEventDragStopPayload, VueEventResizePayload, VueEventResizeStartPayload, VueInlineEditStartPayload, VueMoreClickPayload, VueQuickInfoShowPayload, VueResourceClickPayload, VueSchedulerDateClickPayload, VueSchedulerDateSelectPayload, VueSchedulerEventClickPayload, VueSchedulerEventMousePayload, VueSlotClickPayload } from './Scheduler.payloads';
+import { type VueSchedulerProps } from './Scheduler.props';
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<VueSchedulerProps, {
+    prev: () => void;
+    next: () => void;
+    today: () => void;
+    gotoDate: (date: Date) => void;
+    changeView: (view: SchedulerViewType) => void;
+    getEvents: () => SchedulerEvent[];
+    getEventById: (id: string | number) => SchedulerEvent | undefined;
+    addEvent: (event: SchedulerEvent) => void;
+    updateEvent: (event: SchedulerEvent) => void;
+    removeEvent: (id: string | number) => void;
+    getSelectedEventIds: () => (string | number)[];
+    clearEventSelection: () => void;
+    clearSelection: () => void;
+    getView: () => SchedulerViewType;
+    getDate: () => Date;
+    getDateRange: () => DateRange;
+    select: (start: Date, end?: Date) => void;
+    unselect: () => void;
+    getSelectedEvents: () => SchedulerEvent[];
+    selectAllEvents: () => void;
+    invertSelection: () => void;
+    print: (options?: import("@primeui/scheduler-core").PrintInvocationOptions) => void;
+    getResources: () => SchedulerResource[];
+    getResourceById: (id: string | number) => SchedulerResource | undefined;
+    popover: import("vue").Ref<any, any>;
+    quickInfo: import("vue").Ref<any, any>;
+    contextMenu: import("vue").Ref<any, any>;
+    recurrenceDialog: import("vue").Ref<({
+        $: import("vue").ComponentInternalInstance;
+        $data: {};
+        $props: Partial<{}> & Omit<{} & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>;
+        $attrs: import("vue").Attrs;
+        $refs: {
+            [x: string]: unknown;
+        };
+        $slots: Readonly<{
+            [name: string]: import("vue").Slot<any> | undefined;
+        }>;
+        $root: import("vue").ComponentPublicInstance | null;
+        $parent: import("vue").ComponentPublicInstance | null;
+        $host: Element | null;
+        $emit: (event: string, ...args: any[]) => void;
+        $el: any;
+        $options: import("vue").ComponentOptionsBase<Readonly<{}> & Readonly<{}>, {
+            open: (event: SchedulerEvent, action: "edit" | "delete") => void;
+            close: () => void;
+        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & {
+            beforeCreate?: (() => void) | (() => void)[];
+            created?: (() => void) | (() => void)[];
+            beforeMount?: (() => void) | (() => void)[];
+            mounted?: (() => void) | (() => void)[];
+            beforeUpdate?: (() => void) | (() => void)[];
+            updated?: (() => void) | (() => void)[];
+            activated?: (() => void) | (() => void)[];
+            deactivated?: (() => void) | (() => void)[];
+            beforeDestroy?: (() => void) | (() => void)[];
+            beforeUnmount?: (() => void) | (() => void)[];
+            destroyed?: (() => void) | (() => void)[];
+            unmounted?: (() => void) | (() => void)[];
+            renderTracked?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+            renderTriggered?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+            errorCaptured?: ((err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void)[];
+        };
+        $forceUpdate: () => void;
+        $nextTick: typeof import("vue").nextTick;
+        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import("@vue/reactivity").OnCleanup]) => any : (...args: [any, any, import("@vue/reactivity").OnCleanup]) => any, options?: import("vue").WatchOptions): import("vue").WatchStopHandle;
+    } & Readonly<{}> & Omit<Readonly<{}> & Readonly<{}>, "close" | "open"> & {
+        open: (event: SchedulerEvent, action: "edit" | "delete") => void;
+        close: () => void;
+    } & {} & import("vue").ComponentCustomProperties & {} & {
+        $slots: {
+            default?: (props: {
+                event: SchedulerEvent | null;
+                action: "delete" | "edit" | null;
+                scope: "this" | "all" | "future";
+                setScope: (s: "this" | "all" | "future") => "this" | "all" | "future";
+                confirm: () => void;
+                cancel: () => void;
+            }) => any;
+        };
+    }) | undefined, ({
+        $: import("vue").ComponentInternalInstance;
+        $data: {};
+        $props: Partial<{}> & Omit<{} & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>;
+        $attrs: import("vue").Attrs;
+        $refs: {
+            [x: string]: unknown;
+        };
+        $slots: Readonly<{
+            [name: string]: import("vue").Slot<any> | undefined;
+        }>;
+        $root: import("vue").ComponentPublicInstance | null;
+        $parent: import("vue").ComponentPublicInstance | null;
+        $host: Element | null;
+        $emit: (event: string, ...args: any[]) => void;
+        $el: any;
+        $options: import("vue").ComponentOptionsBase<Readonly<{}> & Readonly<{}>, {
+            open: (event: SchedulerEvent, action: "edit" | "delete") => void;
+            close: () => void;
+        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & {
+            beforeCreate?: (() => void) | (() => void)[];
+            created?: (() => void) | (() => void)[];
+            beforeMount?: (() => void) | (() => void)[];
+            mounted?: (() => void) | (() => void)[];
+            beforeUpdate?: (() => void) | (() => void)[];
+            updated?: (() => void) | (() => void)[];
+            activated?: (() => void) | (() => void)[];
+            deactivated?: (() => void) | (() => void)[];
+            beforeDestroy?: (() => void) | (() => void)[];
+            beforeUnmount?: (() => void) | (() => void)[];
+            destroyed?: (() => void) | (() => void)[];
+            unmounted?: (() => void) | (() => void)[];
+            renderTracked?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+            renderTriggered?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+            errorCaptured?: ((err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void)[];
+        };
+        $forceUpdate: () => void;
+        $nextTick: typeof import("vue").nextTick;
+        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import("@vue/reactivity").OnCleanup]) => any : (...args: [any, any, import("@vue/reactivity").OnCleanup]) => any, options?: import("vue").WatchOptions): import("vue").WatchStopHandle;
+    } & Readonly<{}> & Omit<Readonly<{}> & Readonly<{}>, "close" | "open"> & {
+        open: (event: SchedulerEvent, action: "edit" | "delete") => void;
+        close: () => void;
+    } & {} & import("vue").ComponentCustomProperties & {} & {
+        $slots: {
+            default?: (props: {
+                event: SchedulerEvent | null;
+                action: "delete" | "edit" | null;
+                scope: "this" | "all" | "future";
+                setScope: (s: "this" | "all" | "future") => "this" | "all" | "future";
+                confirm: () => void;
+                cancel: () => void;
+            }) => any;
+        };
+    }) | undefined>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    quickInfoEdit: (payload: QuickInfoEditPayload) => any;
+    quickInfoDelete: (payload: QuickInfoDeletePayload) => any;
+    recurrenceEdit: (payload: RecurrenceEditPayload) => any;
+    viewChange: (payload: {
+        view: SchedulerViewType;
+        dateRange: DateRange;
+    }) => any;
+    datesChange: (payload: DateRange) => any;
+    dateChange: (date: Date) => any;
+    selectionChange: (payload: SchedulerSelectionChangePayload) => any;
+    eventSelectionChange: (payload: SchedulerEventSelectionChangePayload) => any;
+    bulkMove: (payload: SchedulerBulkMovePayload) => any;
+    bulkUpdate: (payload: SchedulerBulkUpdatePayload) => any;
+    bulkDelete: (payload: SchedulerBulkDeletePayload) => any;
+    dateClick: (payload: VueSchedulerDateClickPayload) => any;
+    dateDblclick: (payload: VueSchedulerDateClickPayload) => any;
+    dateSelect: (payload: VueSchedulerDateSelectPayload) => any;
+    dateUnselect: (payload: {
+        view: SchedulerViewType;
+    }) => any;
+    eventClick: (payload: VueSchedulerEventClickPayload) => any;
+    eventDblclick: (payload: VueSchedulerEventClickPayload) => any;
+    eventMouseenter: (payload: VueSchedulerEventMousePayload) => any;
+    eventMouseleave: (payload: VueSchedulerEventMousePayload) => any;
+    eventAdd: (event: SchedulerEvent) => any;
+    eventChange: (payload: {
+        event: SchedulerEvent;
+        oldEvent: SchedulerEvent;
+    }) => any;
+    eventRemove: (payload: {
+        event: SchedulerEvent;
+    }) => any;
+    eventDragStart: (payload: VueEventDragStartPayload) => any;
+    eventDrag: (payload: VueEventDragPayload) => any;
+    eventDragStop: (payload: VueEventDragStopPayload) => any;
+    eventDrop: (payload: EventDropPayload) => any;
+    eventResizeStart: (payload: VueEventResizeStartPayload) => any;
+    eventResize: (payload: VueEventResizePayload) => any;
+    eventResizeStop: (payload: EventResizeStopPayload) => any;
+    resourceClick: (payload: VueResourceClickPayload) => any;
+    resourceExpand: (payload: ResourceExpandPayload) => any;
+    resourceCollapse: (payload: ResourceCollapsePayload) => any;
+    eventResourceChange: (payload: EventResourceChangePayload) => any;
+    resourceAdd: (payload: {
+        resource: SchedulerResource;
+        parentId?: string | number;
+    }) => any;
+    resourceUpdate: (payload: {
+        resource: SchedulerResource;
+        oldResource: SchedulerResource;
+    }) => any;
+    resourceRemove: (payload: {
+        resource: SchedulerResource;
+    }) => any;
+    resourcesRefetch: (payload: Record<string, never>) => any;
+    contextMenuShow: (payload: VueContextMenuContext) => any;
+    slotClick: (payload: VueSlotClickPayload) => any;
+    slotBook: (payload: SlotBookPayload) => any;
+    slotCancel: (payload: SlotCancelPayload) => any;
+    adaptiveAutoSelect: (payload: {
+        resource: SchedulerResource;
+    }) => any;
+    recurrenceDelete: (payload: RecurrenceDeletePayload) => any;
+    conflictDetected: (payload: ConflictDetectedPayload) => any;
+    capacityExceeded: (payload: CapacityExceededPayload) => any;
+    moreClick: (payload: VueMoreClickPayload) => any;
+    quickInfoShow: (payload: VueQuickInfoShowPayload) => any;
+    quickInfoHide: (payload: QuickInfoHidePayload) => any;
+    inlineEditStart: (payload: VueInlineEditStartPayload) => any;
+    inlineEditSave: (payload: InlineEditSavePayload) => any;
+    inlineEditCancel: (payload: InlineEditCancelPayload) => any;
+    eventTitleChange: (payload: {
+        event: SchedulerEvent;
+        oldTitle: string;
+        newTitle: string;
+        view: SchedulerViewType;
+    }) => any;
+    eventSelectionLimitReached: (payload: EventSelectionLimitReachedPayload) => any;
+}, string, import("vue").PublicProps, Readonly<VueSchedulerProps> & Readonly<{
+    onQuickInfoEdit?: ((payload: QuickInfoEditPayload) => any) | undefined;
+    onQuickInfoDelete?: ((payload: QuickInfoDeletePayload) => any) | undefined;
+    onRecurrenceEdit?: ((payload: RecurrenceEditPayload) => any) | undefined;
+    onViewChange?: ((payload: {
+        view: SchedulerViewType;
+        dateRange: DateRange;
+    }) => any) | undefined;
+    onDatesChange?: ((payload: DateRange) => any) | undefined;
+    onDateChange?: ((date: Date) => any) | undefined;
+    onSelectionChange?: ((payload: SchedulerSelectionChangePayload) => any) | undefined;
+    onEventSelectionChange?: ((payload: SchedulerEventSelectionChangePayload) => any) | undefined;
+    onBulkMove?: ((payload: SchedulerBulkMovePayload) => any) | undefined;
+    onBulkUpdate?: ((payload: SchedulerBulkUpdatePayload) => any) | undefined;
+    onBulkDelete?: ((payload: SchedulerBulkDeletePayload) => any) | undefined;
+    onDateClick?: ((payload: VueSchedulerDateClickPayload) => any) | undefined;
+    onDateDblclick?: ((payload: VueSchedulerDateClickPayload) => any) | undefined;
+    onDateSelect?: ((payload: VueSchedulerDateSelectPayload) => any) | undefined;
+    onDateUnselect?: ((payload: {
+        view: SchedulerViewType;
+    }) => any) | undefined;
+    onEventClick?: ((payload: VueSchedulerEventClickPayload) => any) | undefined;
+    onEventDblclick?: ((payload: VueSchedulerEventClickPayload) => any) | undefined;
+    onEventMouseenter?: ((payload: VueSchedulerEventMousePayload) => any) | undefined;
+    onEventMouseleave?: ((payload: VueSchedulerEventMousePayload) => any) | undefined;
+    onEventAdd?: ((event: SchedulerEvent) => any) | undefined;
+    onEventChange?: ((payload: {
+        event: SchedulerEvent;
+        oldEvent: SchedulerEvent;
+    }) => any) | undefined;
+    onEventRemove?: ((payload: {
+        event: SchedulerEvent;
+    }) => any) | undefined;
+    onEventDragStart?: ((payload: VueEventDragStartPayload) => any) | undefined;
+    onEventDrag?: ((payload: VueEventDragPayload) => any) | undefined;
+    onEventDragStop?: ((payload: VueEventDragStopPayload) => any) | undefined;
+    onEventDrop?: ((payload: EventDropPayload) => any) | undefined;
+    onEventResizeStart?: ((payload: VueEventResizeStartPayload) => any) | undefined;
+    onEventResize?: ((payload: VueEventResizePayload) => any) | undefined;
+    onEventResizeStop?: ((payload: EventResizeStopPayload) => any) | undefined;
+    onResourceClick?: ((payload: VueResourceClickPayload) => any) | undefined;
+    onResourceExpand?: ((payload: ResourceExpandPayload) => any) | undefined;
+    onResourceCollapse?: ((payload: ResourceCollapsePayload) => any) | undefined;
+    onEventResourceChange?: ((payload: EventResourceChangePayload) => any) | undefined;
+    onResourceAdd?: ((payload: {
+        resource: SchedulerResource;
+        parentId?: string | number;
+    }) => any) | undefined;
+    onResourceUpdate?: ((payload: {
+        resource: SchedulerResource;
+        oldResource: SchedulerResource;
+    }) => any) | undefined;
+    onResourceRemove?: ((payload: {
+        resource: SchedulerResource;
+    }) => any) | undefined;
+    onResourcesRefetch?: ((payload: Record<string, never>) => any) | undefined;
+    onContextMenuShow?: ((payload: VueContextMenuContext) => any) | undefined;
+    onSlotClick?: ((payload: VueSlotClickPayload) => any) | undefined;
+    onSlotBook?: ((payload: SlotBookPayload) => any) | undefined;
+    onSlotCancel?: ((payload: SlotCancelPayload) => any) | undefined;
+    onAdaptiveAutoSelect?: ((payload: {
+        resource: SchedulerResource;
+    }) => any) | undefined;
+    onRecurrenceDelete?: ((payload: RecurrenceDeletePayload) => any) | undefined;
+    onConflictDetected?: ((payload: ConflictDetectedPayload) => any) | undefined;
+    onCapacityExceeded?: ((payload: CapacityExceededPayload) => any) | undefined;
+    onMoreClick?: ((payload: VueMoreClickPayload) => any) | undefined;
+    onQuickInfoShow?: ((payload: VueQuickInfoShowPayload) => any) | undefined;
+    onQuickInfoHide?: ((payload: QuickInfoHidePayload) => any) | undefined;
+    onInlineEditStart?: ((payload: VueInlineEditStartPayload) => any) | undefined;
+    onInlineEditSave?: ((payload: InlineEditSavePayload) => any) | undefined;
+    onInlineEditCancel?: ((payload: InlineEditCancelPayload) => any) | undefined;
+    onEventTitleChange?: ((payload: {
+        event: SchedulerEvent;
+        oldTitle: string;
+        newTitle: string;
+        view: SchedulerViewType;
+    }) => any) | undefined;
+    onEventSelectionLimitReached?: ((payload: EventSelectionLimitReachedPayload) => any) | undefined;
+}>, {
+    date: Date;
+    inlineEdit: boolean | import("@primeui/scheduler-core").InlineEditOptions;
+    locale: string;
+    businessHours: import("@primeui/scheduler-core").BusinessHours;
+    blockedIntervals: import("@primeui/scheduler-core").BlockedIntervalsOptions;
+    height: import("@primeui/scheduler-core").SchedulerHeight;
+    aspectRatio: number;
+    view: SchedulerViewType;
+    views: SchedulerViewType[];
+    events: SchedulerEvent[];
+    calendar: import("@primeui/scheduler-core").SchedulerCalendarMode;
+    numberingSystem: import("@primeui/scheduler-core").SchedulerNumberingSystem;
+    text: Partial<import("@primeui/scheduler-core").SchedulerText>;
+    rtl: boolean;
+    firstDayOfWeek: 0 | 1 | 2 | 3 | 4 | 5 | 6;
+    weekNumbers: boolean;
+    weekNumbering: "iso" | "us" | "auto";
+    minDate: Date | null;
+    maxDate: Date | null;
+    disabled: boolean;
+    readonly: boolean;
+    selectable: boolean;
+    selectionMode: import("@primeui/scheduler-core").SchedulerSelectionMode;
+    unselectOnOutsideClick: boolean;
+    slotDuration: number;
+    slotMinTime: string;
+    slotMaxTime: string;
+    nowIndicator: boolean;
+    nowIndicatorInterval: number;
+    navLinks: boolean;
+    headerToolbar: import("@primeui/scheduler-core").SchedulerHeaderToolbar | false;
+    editable: boolean;
+    eventStartEditable: boolean;
+    eventDurationEditable: boolean;
+    eventOverlap: boolean;
+    snapDuration: number;
+    dragMinDistance: number;
+    dragRevertDuration: number;
+    dragScroll: boolean;
+    timezone: string;
+    displayTimezone: import("@primeui/scheduler-core").TimezoneDisplay;
+    selectConstraint: import("@primeui/scheduler-core").SelectConstraintConfig;
+    selectAllow: import("@primeui/scheduler-core").SelectAllowCallback;
+    eventConstraint: import("@primeui/scheduler-core").EventConstraint;
+    eventAllow: import("@primeui/scheduler-core").EventAllowCallback;
+    appointmentSlots: boolean | import("@primeui/scheduler-core").AppointmentSlotsOptions;
+    eventSelection: boolean | import("@primeui/scheduler-core").SchedulerEventSelectionOptions;
+    timelineSlotWidth: number;
+    timelineSlotWidthMode: import("@primeui/scheduler-core").TimelineSlotWidthMode;
+    timelineSlotDuration: number;
+    timelineSnapDuration: number;
+    timelineMinTime: string;
+    timelineMaxTime: string;
+    timelineVirtualScroll: boolean | "auto";
+    timelineVirtualThreshold: number;
+    timelineVirtualOverscan: number;
+    timelineVirtualEventBuffer: number;
+    timelineEventMinHeight: number;
+    showBusinessHours: boolean;
+    agendaDays: number;
+    showEmptyDays: boolean;
+    noEventsMessage: string;
+    agendaEventShell: "default" | "none";
+    eventShell: "default" | "none";
+    resources: SchedulerResource[];
+    resourceAreaWidth: number | string;
+    resourceOrder: "asc" | "desc" | ((a: SchedulerResource, b: SchedulerResource) => number);
+    horizontalResourceColumnMode: import("@primeui/scheduler-core").HorizontalResourceColumnMode;
+    horizontalResourceColumnWidth: number | string;
+    horizontalResourceMinColumnWidth: number | string;
+    horizontalResourceOverflowThreshold: number;
+    horizontalResourceGroupMinWidth: number | string;
+    horizontalResourceDayMinWidth: number | string;
+    byGroupId: boolean;
+    byGroupID: boolean;
+    resourceGroupField: string;
+    resourcesExpandable: boolean;
+    resourcesInitiallyExpanded: boolean;
+    showAggregatedEvents: boolean;
+    groupByResource: boolean;
+    groupByDate: boolean;
+    resourceAreaHeaderContent: string;
+    resourceConflict: boolean | Partial<import("@primeui/scheduler-core").ConflictOptions>;
+    adaptiveMode: boolean;
+    selectedResourceId: string | number | null;
+    resourceRowHeight: number;
+    rowAutoHeight: boolean;
+    resourceTimelineOverlapPolicy: import("@primeui/scheduler-core").ResourceTimelineOverlapPolicy;
+    showResourceFilter: boolean;
+    monthEventRowHeight: number;
+    monthMoreLinkHeight: number;
+    showMorePopover: boolean;
+    maxEventsVisible: number;
+    numberOfDays: number;
+    daysOfWeek: number[];
+    density: import("@primeui/scheduler-core").DensityMode;
+    autoHeight: boolean | import("@primeui/scheduler-core").AutoHeightOptions;
+    stacking: import("@primeui/scheduler-core").StackingOptions;
+    adaptiveRendering: import("@primeui/scheduler-core").AdaptiveRenderingOptions;
+    timeFormat: import("@primeui/scheduler-core").TimeFormatOptions;
+    dateDisplay: import("@primeui/scheduler-core").DateDisplayOptions;
+    eventPermission: import("./Scheduler.payloads").VueSchedulerPermissionResolver;
+    eventPopover: boolean;
+    eventPopoverDelay: number;
+    eventPopoverHideDelay: number;
+    eventPopoverPosition: "top" | "bottom" | "left" | "right";
+    eventPopoverShowOnMobile: boolean;
+    quickInfo: boolean | import("@primeui/scheduler-core").QuickInfoOptions;
+    quickInfoPosition: "top" | "bottom" | "left" | "right";
+    recurrenceEdit: boolean | Partial<import("@primeui/scheduler-core").RecurrenceEditOptions>;
+    eventCategories: import("@primeui/scheduler-core").EventCategory[];
+    categories: import("@primeui/scheduler-core").EventCategory[];
+    categoryField: string;
+    categoryAutoTextColor: boolean;
+    showCategoryLegend: boolean;
+    categoryLegendPosition: import("@primeui/scheduler-core").CategoryLegendPosition;
+    categoryFilterable: boolean;
+    ariaLabel: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};