@progress/kendo-angular-scheduler 3.0.3-dev.202203091424 → 4.0.0-next.202204010908

package/dist/es2015/views/agenda/agenda-view.component.js

@@ -1,104 +0,0 @@
-/**-----------------------------------------------------------------------------------------
-* Copyright © 2021 Progress Software Corporation. All rights reserved.
-* Licensed under commercial license. See LICENSE.md in the project root for more information
-*-------------------------------------------------------------------------------------------*/
-import * as tslib_1 from "tslib";
-var AgendaViewComponent_1;
-import { Component, forwardRef, Input, ContentChild, ChangeDetectionStrategy, ChangeDetectorRef } from '@angular/core';
-import { LocalizationService } from '@progress/kendo-angular-l10n';
-import { ConfigurationViewBase } from '../common/configuration-view-base';
-import { SchedulerView } from '../../types';
-import { ViewContextService } from '../view-context.service';
-import { ViewStateService } from '../view-state.service';
-import { EventTemplateDirective, AgendaTimeTemplateDirective, AgendaDateTemplateDirective } from '../templates';
-/**
- * The component for rendering the **Agenda** view.
- */
-let AgendaViewComponent = AgendaViewComponent_1 = class AgendaViewComponent extends ConfigurationViewBase {
-    constructor(localization, changeDetector, viewContext, viewState) {
-        super(localization, changeDetector, viewContext, viewState);
-        /**
-         * The long-date format for displaying the
-         * selected date in the Scheduler toolbar.
-         * Defaults to `{0:D} - {1:D}`,
-         * where `0` is the start and `1` is the end date
-         * ([more information]({% slug parsingandformatting_intl %}#toc-date-formatting)).
-         */
-        this.selectedDateFormat = '{0:D} - {1:D}';
-        /**
-         * The short-date format for displaying the
-         * selected date in the Scheduler toolbar.
-         * Defaults to `{0:d} - {1:d}`,
-         * where `0` is the start and `1` is the end date
-         * ([more information]({% slug parsingandformatting_intl %}#toc-date-formatting)).
-         */
-        this.selectedShortDateFormat = '{0:d} - {1:d}';
-        /**
-         * Specifies the number of days that the view will render.
-         * Defaults to `7`.
-         */
-        this.numberOfDays = 7;
-        /**
-         * The invariant name for this view (`agenda`).
-         */
-        this.name = 'agenda';
-    }
-    /**
-     * @hidden
-     */
-    get title() {
-        return this.localization.get('agendaViewTitle');
-    }
-};
-tslib_1.__decorate([
-    Input(),
-    tslib_1.__metadata("design:type", String)
-], AgendaViewComponent.prototype, "selectedDateFormat", void 0);
-tslib_1.__decorate([
-    Input(),
-    tslib_1.__metadata("design:type", String)
-], AgendaViewComponent.prototype, "selectedShortDateFormat", void 0);
-tslib_1.__decorate([
-    Input(),
-    tslib_1.__metadata("design:type", Number)
-], AgendaViewComponent.prototype, "numberOfDays", void 0);
-tslib_1.__decorate([
-    ContentChild(EventTemplateDirective, { static: false }),
-    tslib_1.__metadata("design:type", EventTemplateDirective)
-], AgendaViewComponent.prototype, "eventTemplate", void 0);
-tslib_1.__decorate([
-    ContentChild(AgendaTimeTemplateDirective, { static: false }),
-    tslib_1.__metadata("design:type", AgendaTimeTemplateDirective)
-], AgendaViewComponent.prototype, "agendaTimeTemplate", void 0);
-tslib_1.__decorate([
-    ContentChild(AgendaDateTemplateDirective, { static: false }),
-    tslib_1.__metadata("design:type", AgendaDateTemplateDirective)
-], AgendaViewComponent.prototype, "agendaDateTemplate", void 0);
-AgendaViewComponent = AgendaViewComponent_1 = tslib_1.__decorate([
-    Component({
-        changeDetection: ChangeDetectionStrategy.OnPush,
-        selector: 'kendo-scheduler-agenda-view',
-        providers: [{
-                provide: SchedulerView,
-                // tslint:disable-next-line:no-forward-ref
-                useExisting: forwardRef(() => AgendaViewComponent_1)
-            }],
-        template: `
-        <ng-template #content>
-            <agenda-view-internal
-                [numberOfDays]="numberOfDays"
-                [eventTemplate]="eventTemplate?.templateRef"
-                [slotClass]="viewSlotClass"
-                [eventClass]="viewEventClass"
-                [eventStyles]="viewEventStyles"
-                [agendaTimeTemplate]="agendaTimeTemplate?.templateRef"
-                [agendaDateTemplate]="agendaDateTemplate?.templateRef"
-                [selectedDateFormat]="selectedDateFormat"
-                [selectedShortDateFormat]="selectedShortDateFormat">
-            </agenda-view-internal>
-        </ng-template>
-    `
-    }),
-    tslib_1.__metadata("design:paramtypes", [LocalizationService, ChangeDetectorRef, ViewContextService, ViewStateService])
-], AgendaViewComponent);
-export { AgendaViewComponent };

package/dist/es2015/views/agenda/agenda-view.module.d.ts

@@ -1,9 +0,0 @@
-/**-----------------------------------------------------------------------------------------
-* Copyright © 2021 Progress Software Corporation. All rights reserved.
-* Licensed under commercial license. See LICENSE.md in the project root for more information
-*-------------------------------------------------------------------------------------------*/
-/**
- * @hidden
- */
-export declare class AgendaViewModule {
-}

package/dist/es2015/views/agenda/agenda-view.module.js

@@ -1,36 +0,0 @@
-/**-----------------------------------------------------------------------------------------
-* Copyright © 2021 Progress Software Corporation. All rights reserved.
-* Licensed under commercial license. See LICENSE.md in the project root for more information
-*-------------------------------------------------------------------------------------------*/
-import * as tslib_1 from "tslib";
-import { CommonModule } from '@angular/common';
-import { NgModule } from '@angular/core';
-import { IntlModule } from '@progress/kendo-angular-intl';
-import { AgendaHeaderItemComponent } from './agenda-header-item.component';
-import { AgendaHeaderComponent } from './agenda-header.component';
-import { AgendaTaskItemComponent } from './agenda-task-item.component';
-import { AgendaListComponent } from './agenda-view-list.component';
-import { AgendaViewComponent } from './agenda-view.component';
-import { AgendaViewInternalComponent } from './agenda-view-internal.component';
-import { SharedModule } from '../../shared.module';
-const COMPONENTS = [
-    AgendaHeaderComponent,
-    AgendaHeaderItemComponent,
-    AgendaListComponent,
-    AgendaTaskItemComponent,
-    AgendaViewComponent,
-    AgendaViewInternalComponent
-];
-/**
- * @hidden
- */
-let AgendaViewModule = class AgendaViewModule {
-};
-AgendaViewModule = tslib_1.__decorate([
-    NgModule({
-        imports: [CommonModule, IntlModule, SharedModule],
-        exports: [AgendaViewComponent],
-        declarations: [COMPONENTS]
-    })
-], AgendaViewModule);
-export { AgendaViewModule };

package/dist/es2015/views/agenda/tasks.collection.d.ts

@@ -1,44 +0,0 @@
-/**-----------------------------------------------------------------------------------------
-* Copyright © 2021 Progress Software Corporation. All rights reserved.
-* Licensed under commercial license. See LICENSE.md in the project root for more information
-*-------------------------------------------------------------------------------------------*/
-import { GroupResult } from '@progress/kendo-data-query';
-import { SchedulerEvent } from '../../types';
-/**
- * @hidden
- */
-export declare const compose: (...args: any[]) => (data: any) => any;
-/**
- * @hidden
- */
-export declare const processEvents: (start: any, end: any) => (data: any) => any;
-/** @hidden */
-export declare class EmptyIterator<T> {
-    toString(): string;
-}
-/** @hidden */
-export interface SchedulerTask extends SchedulerEvent {
-    head?: boolean;
-    tail?: boolean;
-    mid?: boolean;
-    startDate: Date;
-}
-/** @hidden */
-export interface AgendaViewItem {
-    type: "group" | "event";
-    dataItem: GroupResult | SchedulerTask;
-    rowSpan?: number;
-}
-/**
- * @hidden
- */
-export declare class TaskCollection {
-    protected start: Date;
-    protected end: Date;
-    protected events: SchedulerEvent[];
-    protected createIterator: Function;
-    static empty(): TaskCollection;
-    constructor(start: Date, end: Date, events: SchedulerEvent[]);
-    itemAt(index: number): any;
-    toString(): string;
-}

package/dist/es2015/views/agenda/tasks.collection.js

@@ -1,80 +0,0 @@
-/**-----------------------------------------------------------------------------------------
-* Copyright © 2021 Progress Software Corporation. All rights reserved.
-* Licensed under commercial license. See LICENSE.md in the project root for more information
-*-------------------------------------------------------------------------------------------*/
-import { groupBy, orderBy } from '@progress/kendo-data-query';
-import { iterator } from '../../common/util';
-const flip = fn => a => b => fn(b, a);
-const ɵ0 = flip;
-const sort = flip(orderBy);
-const group = flip(groupBy);
-/**
- * @hidden
- */
-export const compose = (...args) => (data) => args.reduceRight((acc, curr) => curr(acc), data);
-/**
- * @hidden
- */
-export const processEvents = (start, end) => compose(group([{ field: "startDate" }]), sort([{ field: "start", dir: "asc" }, { field: "end", dir: "asc" }]));
-function* flattenGroups(groups) {
-    for (let index = 0; index < groups.length; index++) {
-        const groupItem = groups[index];
-        yield {
-            type: "group",
-            dataItem: groupItem,
-            rowSpan: groupItem.items.length
-        };
-        for (let itemIndex = 1; itemIndex < groupItem.items.length; itemIndex++) {
-            const item = groupItem.items[itemIndex];
-            yield {
-                type: "event",
-                dataItem: item
-            };
-        }
-    }
-}
-/** @hidden */
-export class EmptyIterator {
-    [iterator]() {
-        return {
-            next: () => ({ done: true, value: null })
-        };
-    }
-    toString() {
-        return "Empty Iterator";
-    }
-}
-/**
- * @hidden
- */
-export class TaskCollection {
-    constructor(start, end, events) {
-        this.start = start;
-        this.end = end;
-        this.events = events;
-        this.createIterator = compose(flattenGroups, processEvents(this.start, this.end));
-    }
-    static empty() {
-        return (new EmptyIterator());
-    }
-    [iterator]() {
-        return this.createIterator(this.events);
-    }
-    itemAt(index) {
-        const taskIterator = this.createIterator(this.events);
-        let idx = 0;
-        let item;
-        do {
-            item = taskIterator.next();
-            if (item && idx === index) {
-                const value = item.value;
-                return value.type === 'group' ? value.dataItem.items[0] : value.dataItem;
-            }
-            idx++;
-        } while (item);
-    }
-    toString() {
-        return this.events.toString();
-    }
-}
-export { ɵ0 };

package/dist/es2015/views/agenda/utils.js

@@ -1,178 +0,0 @@
-/**-----------------------------------------------------------------------------------------
-* Copyright © 2021 Progress Software Corporation. All rights reserved.
-* Licensed under commercial license. See LICENSE.md in the project root for more information
-*-------------------------------------------------------------------------------------------*/
-import { TaskCollection, compose } from './tasks.collection';
-import { MS_PER_DAY } from '@progress/kendo-date-math';
-import { intersects, eventResources, toUTCDate, addUTCDays, getUTCDate } from '../utils';
-import { getField } from '../../common/util';
-/**
- * @hidden
- */
-export function createResourceGroups(groupedResources) {
-    let result = [];
-    const firstResource = groupedResources[0];
-    const firstResourceData = firstResource.data;
-    for (let dataIdx = 0; dataIdx < firstResourceData.length; dataIdx++) {
-        const item = firstResourceData[dataIdx];
-        result.push({ resources: [getField(item, firstResource.textField)] });
-    }
-    for (let idx = 1; idx < groupedResources.length; idx++) {
-        const resource = groupedResources[idx];
-        const data = resource.data;
-        const current = [];
-        for (let resourceIdx = 0; resourceIdx < result.length; resourceIdx++) {
-            const resourceItem = result[resourceIdx];
-            for (let dataIdx = 0; dataIdx < data.length; dataIdx++) {
-                const item = data[dataIdx];
-                current.push({ resources: resourceItem.resources.concat(getField(item, resource.textField)) });
-            }
-        }
-        result = current;
-    }
-    return result;
-}
-function createTask(item, resourceIdx, resources, color) {
-    const event = item.event;
-    return {
-        event,
-        start: item.start.toUTCDate(),
-        end: item.end.toUTCDate(),
-        title: event.title,
-        isAllDay: event.isAllDay,
-        color,
-        resourceIdx,
-        resources
-    };
-}
-const durationInDays = ({ start, end, isAllDay = false }) => {
-    const eventEnd = isAllDay ? getUTCDate(end) : end;
-    const duration = Math.ceil((eventEnd - +getUTCDate(start)) / MS_PER_DAY);
-    if (isAllDay) {
-        return duration + 1;
-    }
-    return duration;
-};
-const ɵ0 = durationInDays;
-const curry = fn => {
-    const len = fn.length;
-    return (...args) => len === args.length
-        ? fn.apply(null, args)
-        : curry(fn.bind(null, ...args));
-};
-const ɵ1 = curry;
-const range = num => Array.from(new Array(num).keys());
-const ɵ2 = range;
-const cloneTask = (eventStart, eventEnd) => task => (Object.assign({}, task, { start: getUTCDate(eventStart), end: task.tail && !task.isAllDay ? eventEnd : addUTCDays(eventStart, 1), startDate: getUTCDate(eventStart) }));
-const ɵ3 = cloneTask;
-const previousEventEnd = (start, events) => events.length
-    ? events[events.length - 1].end
-    : start;
-const ɵ4 = previousEventEnd;
-const markAsTail = isLast => task => {
-    if (isLast) {
-        task.tail = true;
-    }
-    return task;
-};
-const ɵ5 = markAsTail;
-const markAsMid = task => {
-    if (!task.tail) {
-        task.mid = true;
-    }
-    return task;
-};
-const ɵ6 = markAsMid;
-const addTaskPart = (task, start) => (tasks, _, day, days) => tasks.concat(compose(markAsMid, cloneTask(previousEventEnd(start, tasks), task.end), markAsTail(day === days.length - 1))(task));
-const ɵ7 = addTaskPart;
-const splitMultiDayTask = (task, start) => range(durationInDays(task) - 1)
-    .reduce(addTaskPart(task, start), []);
-const ɵ8 = splitMultiDayTask;
-const ɵ9 = (periodStart, periodEnd, tasks) => {
-    const result = [];
-    for (let index = 0; index < tasks.length; index++) {
-        let task = Object.assign({}, tasks[index]);
-        task.startDate = getUTCDate(task.start);
-        if (task.start >= periodStart && task.start <= periodEnd) {
-            result.push(task);
-        }
-        if (durationInDays(task) > 1) {
-            task.end = addUTCDays(task.startDate, 1);
-            task.head = true;
-            result.push(...splitMultiDayTask(Object.assign({}, tasks[index]), task.end)
-                .filter(tsk => getUTCDate(tsk.end) <= periodEnd && tsk.start >= periodStart));
-        }
-    }
-    return result;
-};
-/**
- * @hidden
- */
-export const splitTasks = curry(ɵ9);
-function groupByResource(groupedResources, resourceGroups, dateRange) {
-    const groups = resourceGroups.filter(group => group.tasks && group.tasks.length);
-    if (!groups.length) {
-        return [];
-    }
-    const values = groups[0].resources.map(resource => ({ value: resource, span: 0, groupIdx: 0 }));
-    const periodStart = toUTCDate(dateRange.start);
-    const periodEnd = toUTCDate(dateRange.end);
-    for (let groupIdx = 0; groupIdx < groups.length; groupIdx++) {
-        const group = groups[groupIdx];
-        group.tasks = splitTasks(periodStart, periodEnd, group.tasks);
-        const count = group.tasks.length;
-        group.tasks = new TaskCollection(periodStart, periodEnd, group.tasks);
-        let invalidate = false;
-        for (let resourceIdx = 0; resourceIdx < groupedResources.length; resourceIdx++) {
-            const resourceValue = values[resourceIdx];
-            if (resourceValue.value !== group.resources[resourceIdx] || invalidate) {
-                resourceValue.value = group.resources[resourceIdx];
-                const spanGroup = groups[resourceValue.groupIdx];
-                spanGroup.spans = spanGroup.spans || [];
-                spanGroup.spans[resourceIdx] = resourceValue.span;
-                resourceValue.span = count;
-                resourceValue.groupIdx = groupIdx;
-                invalidate = true;
-            }
-            else {
-                resourceValue.span += count;
-            }
-        }
-    }
-    values.forEach((value, index) => {
-        const group = groups[value.groupIdx];
-        group.spans = group.spans || [];
-        group.spans[index] = value.span;
-    });
-    return groups;
-}
-/**
- * @hidden
- */
-export function groupEvents(items, { taskResources, resourceGroups, spans, allResources, dateRange }) {
-    const groups = resourceGroups || [{}];
-    const periodStart = toUTCDate(dateRange.start);
-    const periodEnd = toUTCDate(dateRange.end);
-    for (let idx = 0; idx < items.length; idx++) {
-        const item = items[idx];
-        const event = item.event;
-        if (!intersects(item.start.toUTCDate(), item.end.toUTCDate(), periodStart, periodEnd)) {
-            continue;
-        }
-        const resources = eventResources(event, { taskResources, hasGroups: resourceGroups && resourceGroups.length > 0, spans, allResources });
-        if (resources.length && resources[0].leafIdx >= 0) {
-            for (let resourceIdx = 0; resourceIdx < resources.length; resourceIdx++) {
-                const current = resources[resourceIdx];
-                const task = createTask(item, current.leafIdx, current.resources, current.color);
-                const tasks = groups[current.leafIdx].tasks = groups[current.leafIdx].tasks || [];
-                tasks.push(task);
-            }
-        }
-    }
-    if (resourceGroups) {
-        return groupByResource(taskResources, groups, dateRange);
-    }
-    groups[0].tasks = new TaskCollection(periodStart, periodEnd, splitTasks(periodStart, periodEnd, groups[0].tasks || []));
-    return groups;
-}
-export { ɵ0, ɵ1, ɵ2, ɵ3, ɵ4, ɵ5, ɵ6, ɵ7, ɵ8, ɵ9 };

package/dist/es2015/views/common/base-view.d.ts

@@ -1,172 +0,0 @@
-/**-----------------------------------------------------------------------------------------
-* Copyright © 2021 Progress Software Corporation. All rights reserved.
-* Licensed under commercial license. See LICENSE.md in the project root for more information
-*-------------------------------------------------------------------------------------------*/
-import { OnInit, AfterViewInit, OnDestroy, OnChanges, NgZone, ElementRef, Renderer2, TemplateRef, ChangeDetectorRef } from '@angular/core';
-import { IntlService } from '@progress/kendo-angular-intl';
-import { Day } from '@progress/kendo-date-math';
-import { Subscription, Subject, BehaviorSubject } from 'rxjs';
-import { DateRange, NavigationAction, ViewItem } from '../../types';
-import { BaseSlotService } from '../view-items/base-slot.service';
-import { ViewContextService } from '../view-context.service';
-import { ViewStateService } from '../view-state.service';
-import Draggable from '@telerik/kendo-draggable';
-import { HintContainerComponent } from '../common/hint-container.component';
-import { PDFService } from '../../pdf/pdf.service';
-import { LocalizationService } from '@progress/kendo-angular-l10n';
-import { TimeSlotDirective } from '../day-time/event-slot.directive';
-import { SlotSelectionCallback } from '../../types/slot-selection';
-/** @hidden */
-export declare abstract class BaseView implements OnInit, OnChanges, AfterViewInit, OnDestroy {
-    protected viewContext: ViewContextService;
-    protected viewState: ViewStateService;
-    protected intl: IntlService;
-    protected slotService: BaseSlotService;
-    protected zone: NgZone;
-    protected renderer: Renderer2;
-    protected element: ElementRef;
-    protected pdfService: PDFService;
-    protected localization: LocalizationService;
-    protected cdr: ChangeDetectorRef;
-    еventTemplate: TemplateRef<any>;
-    groupHeaderTemplate: TemplateRef<any>;
-    selectedDateFormat: string;
-    selectedShortDateFormat: string;
-    eventHeight: number;
-    slotClass: (args: any) => any;
-    eventClass: (args: any) => any;
-    eventStyles: (args: any) => any;
-    weekStart: Day;
-    content: ElementRef;
-    header: ElementRef;
-    contentTable: ElementRef;
-    times: ElementRef;
-    timesHeader: ElementRef;
-    timesTable: ElementRef;
-    headerWrap: ElementRef;
-    hintContainer: HintContainerComponent;
-    readonly eventTemplateRef: TemplateRef<any>;
-    readonly groupHeaderTemplateRef: TemplateRef<any>;
-    items: Subject<any[]>;
-    horizontalResources: any[];
-    verticalResources: any[];
-    dragHints: any[];
-    resizeHints: any[];
-    editable: any;
-    selectable: boolean;
-    getField: any;
-    protected changes: BehaviorSubject<any>;
-    protected viewRangeChange: BehaviorSubject<any>;
-    protected subs: Subscription;
-    protected groupedResources: any[];
-    protected spans: any[];
-    protected contentHeight: any;
-    protected tasks: any[];
-    protected group: any;
-    protected resources: any[];
-    protected domEvents: any[];
-    protected schedulerEventTemplate: any;
-    protected schedulerGroupHeaderTemplate: any;
-    protected min: any;
-    protected max: any;
-    protected selectedDate: Date;
-    protected resourcesCache: any;
-    protected timezone: string;
-    protected draggable: Draggable;
-    /**
-     * The event which is currently being resized.
-     */
-    protected resizing: any;
-    protected dragging: any;
-    protected dragArgs: any;
-    /**
-     * The slot which is currently being dragged over while selecting a range of slots.
-     */
-    protected dragSelecting: TimeSlotDirective;
-    /**
-     * The slot where the drag-selecting originated. Used for flipping the start and end of the emitted range.
-     */
-    protected dragSelectOrigin: TimeSlotDirective;
-    protected container: any;
-    protected containerOffset: any;
-    protected pressLocation: any;
-    protected pressTarget: any;
-    protected scrollInterval: any;
-    protected autoHeight: boolean;
-    protected rtl: boolean;
-    isSlotSelected: SlotSelectionCallback;
-    constructor(viewContext: ViewContextService, viewState: ViewStateService, intl: IntlService, slotService: BaseSlotService, zone: NgZone, renderer: Renderer2, element: ElementRef, pdfService: PDFService, localization: LocalizationService, cdr: ChangeDetectorRef);
-    protected abstract onSelectDate(date: Date): void;
-    protected abstract onAction(action: NavigationAction): void;
-    protected abstract onTasksChange(): void;
-    protected abstract createTasks(items: ViewItem[], dateRange: DateRange): any[];
-    protected abstract reflow(): void;
-    protected abstract slotByIndex(slotIndex: string, args: any): any;
-    protected abstract dateRange(date: Date): DateRange;
-    protected abstract dragHintSize(startSlot: any, endSlot: any): any;
-    protected abstract dragRanges(slot: any): any;
-    protected abstract slotByPosition(x: number, y: number, container?: any): TimeSlotDirective;
-    ngOnInit(): void;
-    ngOnChanges(changes: any): void;
-    ngAfterViewInit(): void;
-    ngOnDestroy(): void;
-    itemIndex(index: number, _: any): any;
-    resourcesByIndex(index: number): any[];
-    dragResourcesByIndex(index: number): any[];
-    getEventClasses(item: any, resources: any, isAllDay?: boolean): any;
-    getEventStyles(item: any, itemResource: any, isAllDay?: boolean): any;
-    toPlainDate(date: Date): Date;
-    toPlainDateTime(date: Date, time: Date): Date;
-    protected optionsChange(options: any): void;
-    protected toggleElement(visible: boolean): void;
-    protected onStable(): any;
-    protected updateView(): void;
-    protected assignResources(): void;
-    protected bindEvents(): void;
-    protected onPress(args: any): void;
-    protected onDrag(args: any): void;
-    protected onRelease(args: any): void;
-    protected setHintClass(className: string): void;
-    protected updateHintClass(): void;
-    protected removeHintClass(): void;
-    protected setSlotClass(className: string): void;
-    protected removeSlotClass(): void;
-    protected readonly hints: any;
-    protected initDrag(args: any): void;
-    protected updateDragContainer(args: any): void;
-    protected drag(args: any): void;
-    protected initDragSelect(args: any): void;
-    protected dragSelect(args: any): void;
-    protected dragHintClasses(): any;
-    protected dragHintEventStyleArgs(): any;
-    protected draggedIsAllDay(task: any, _slot: any): boolean;
-    protected dragResourceColor(task: any, slotResources: any[]): string;
-    protected resourceValues(task: any, currentResources: any[]): any;
-    protected initResize(args: any): void;
-    protected resize(args: any): void;
-    protected updateResizeHints(ranges: any[], start: Date, end: Date): void;
-    protected coordinatesOffset(x: number, y: number, container?: any, offset?: any): any;
-    protected scrollContainer(callback: any, args: any): void;
-    protected emitEvent(name: string, args: any): boolean;
-    protected targetTask(target: any): any;
-    protected updateHintContainer(): void;
-    /**
-     * Converts a "view date" (date stored in the UTC parts of a Date object) to a local date.
-     */
-    protected convertDate(date: Date): Date;
-    protected onClick(e: any, eventType?: string): void;
-    protected emitSlotEvent(e: any, eventType: string): void;
-    protected emitTaskEvent(e: any, eventType: string): void;
-    protected onKeydown(e: any): void;
-    protected syncTables(): void;
-    protected updateContentHeight(): void;
-    protected groupResources(): void;
-    protected readonly taskResources: any[];
-    protected resourceSpans(): number[];
-    protected isInRange(date: Date): boolean;
-    protected createPDFElement(): void;
-    protected pdfWidth(): number;
-    protected containerByPosition({ x, y }: any): any;
-    protected execute(e: any): void;
-    protected slotFields(slot: any): any;
-}