// #region Imports
var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
    return c > 3 && r && Object.defineProperty(target, key, r), r;
};
var __metadata = (this && this.__metadata) || function (k, v) {
    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
};
import { calculateTimeHeight, calculateTimePosition, formatDateToIso, generateTimeSlots, generateVisibleDates, getDayKey, getStartOfWeek } from '../../../../../Extensions/DateExtensions';
import { TimeFormatter } from '../../../../../Intl/Formatters/TimeFormatter';
import { Attribute } from '../../../../Decorators/AttributeDecorator';
import { Component } from '../../../../Decorators/ComponentDecorator';
import { Watch } from '../../../../Decorators/WatchDecorator';
import { AllDayVisibility } from '../../../../Types/AllDayVisibility';
import { SchedulerNowIndicatorElement } from '../SchedulerNowIndicatorElement';
import { SchedulerTimescaleElement } from '../SchedulerTimescaleElement';
import { SchedulerViewBaseElement } from './Abstracts/SchedulerViewBaseElement';
import { ISchedulerTimeGridViewElementProps } from './ISchedulerTimeGridViewElementProps';
import { schedulerTimeGridViewElementTemplate } from './SchedulerTimeGridViewElementTemplate';
import { schedulerTimeGridViewElementCosmopolitanStyle } from './Themes/SchedulerTimeGridViewElement.Cosmopolitan';
import { schedulerTimeGridViewElementJoyStyle } from './Themes/SchedulerTimeGridViewElement.Joy';
import { schedulerTimeGridViewElementMemphisStyle } from './Themes/SchedulerTimeGridViewElement.Memphis';
// #endregion
/**
 * Scheduler TimeGrid View - A time grid view with configurable day columns.
 *
 * @description
 * The TimeGrid view displays events in a time-based grid layout with columns representing days.
 * It supports day view (single column), work week view (5 columns), and week view (7 columns).
 * Events are positioned vertically based on their time and horizontally based on overlap detection.
 *
 * @name Scheduler TimeGrid View
 * @element mosaik-scheduler-time-grid-view
 * @category Scheduler
 *
 * @slot - Default slot for event content
 * @slot allday-${event.eventKey} - The allday-${event.eventKey} slot.
 * @slot event-${event.eventKey} - The event-${event.eventKey} slot.
 *
 * @csspart all-day-events - Container for all-day event chips
 * @csspart all-day-label - The "All day" label
 * @csspart all-day-panel - The all-day events panel
 * @csspart all-day-row - Container for all-day cells
 * @csspart appointment-column - Column container for events of a day
 * @csspart appointments - Overlay container for positioned events
 * @csspart body - The scrollable body area
 * @csspart container - The main container
 * @csspart all-day-event - Individual all-day event chip
 * @csspart events-slot - The events-slot part.
 * @csspart grid - The time slot grid
 * @csspart grid-wrapper - Container for grid and appointments overlay
 * @csspart header - The header row with day labels
 * @csspart header-columns - Container for day header cells
 * @csspart header-day - The day number in the header
 * @csspart header-row - The header-row part.
 * @csspart header-spacer - Spacer aligned with timescale width
 * @csspart header-weekday - The weekday name in the header
 * @csspart indicator - The now indicator
 * @csspart timescale - The time labels on the left
 *
 * @cssprop {Color} --scheduler-time-grid-view-background-color - Background color of the view
 * @cssprop {Color} --scheduler-time-grid-view-border-color - Border color
 * @cssprop {String} --scheduler-time-grid-view-border-radius - Border radius
 * @cssprop {String} --scheduler-time-grid-view-border-style - Border style
 * @cssprop {String} --scheduler-time-grid-view-border-width - Border width
 * @cssprop {Color} --scheduler-time-grid-view-cell-border-color - Border color for time cells
 * @cssprop {String} --scheduler-time-grid-view-cell-border-radius - Border radius for time cells
 * @cssprop {String} --scheduler-time-grid-view-cell-border-style - Border style for time cells
 * @cssprop {String} --scheduler-time-grid-view-cell-border-width - Border width for time cells
 * @cssprop {String} --scheduler-time-grid-view-cell-height - Height of time slot cells
 * @cssprop {String} --scheduler-time-grid-view-column-min-width - Minimum width of day columns
 * @cssprop {String} --scheduler-time-grid-view-font-family - The time grid view font family CSS custom property.
 * @cssprop {String} --scheduler-time-grid-view-font-letter-spacing - The time grid view font letter spacing CSS custom property.
 * @cssprop {String} --scheduler-time-grid-view-font-line-height - The time grid view font line height CSS custom property.
 * @cssprop {String} --scheduler-time-grid-view-font-size - The time grid view font size CSS custom property.
 * @cssprop {String} --scheduler-time-grid-view-font-text-decoration - The time grid view font text decoration CSS custom property.
 * @cssprop {String} --scheduler-time-grid-view-font-text-transform - The time grid view font text transform CSS custom property.
 * @cssprop {String} --scheduler-time-grid-view-font-weight - The time grid view font weight CSS custom property.
 * @cssprop {Color} --scheduler-time-grid-view-foreground-color - Foreground/text color
 * @cssprop {String} --scheduler-time-grid-view-gap - Gap between elements
 * @cssprop {String} --scheduler-time-grid-view-header-cell-padding-bottom - Bottom padding for header cells
 * @cssprop {String} --scheduler-time-grid-view-header-cell-padding-left - Left padding for header cells
 * @cssprop {String} --scheduler-time-grid-view-header-cell-padding-right - Right padding for header cells
 * @cssprop {String} --scheduler-time-grid-view-header-cell-padding-top - Top padding for header cells
 * @cssprop {String} --scheduler-time-grid-view-header-day-font-family - Font family for day number in header
 * @cssprop {String} --scheduler-time-grid-view-header-day-font-letter-spacing - Letter spacing for day number
 * @cssprop {String} --scheduler-time-grid-view-header-day-font-line-height - Line height for day number
 * @cssprop {String} --scheduler-time-grid-view-header-day-font-size - Font size for day number
 * @cssprop {String} --scheduler-time-grid-view-header-day-font-text-decoration - Text decoration for day number
 * @cssprop {String} --scheduler-time-grid-view-header-day-font-text-transform - Text transform for day number
 * @cssprop {String} --scheduler-time-grid-view-header-day-font-weight - Font weight for day number
 * @cssprop {String} --scheduler-time-grid-view-header-font-family - Font family for header
 * @cssprop {String} --scheduler-time-grid-view-header-font-letter-spacing - Letter spacing for header
 * @cssprop {String} --scheduler-time-grid-view-header-font-line-height - Line height for header
 * @cssprop {String} --scheduler-time-grid-view-header-font-size - Font size for header
 * @cssprop {String} --scheduler-time-grid-view-header-font-text-decoration - Text decoration for header
 * @cssprop {String} --scheduler-time-grid-view-header-font-text-transform - Text transform for header
 * @cssprop {String} --scheduler-time-grid-view-header-font-weight - Font weight for header
 * @cssprop {String} --scheduler-time-grid-view-header-weekday-font-family - Font family for weekday labels
 * @cssprop {String} --scheduler-time-grid-view-header-weekday-font-letter-spacing - Letter spacing for weekday labels
 * @cssprop {String} --scheduler-time-grid-view-header-weekday-font-line-height - Line height for weekday labels
 * @cssprop {String} --scheduler-time-grid-view-header-weekday-font-size - Font size for weekday labels
 * @cssprop {String} --scheduler-time-grid-view-header-weekday-font-text-decoration - Text decoration for weekday labels
 * @cssprop {String} --scheduler-time-grid-view-header-weekday-font-text-transform - Text transform for weekday labels
 * @cssprop {String} --scheduler-time-grid-view-header-weekday-font-weight - Font weight for weekday labels
 * @cssprop {Color} --scheduler-time-grid-view-hour-border-color - Border color for hour boundaries
 * @cssprop {String} --scheduler-time-grid-view-hour-border-radius - Border radius for hour boundaries
 * @cssprop {String} --scheduler-time-grid-view-hour-border-style - Border style for hour boundaries
 * @cssprop {String} --scheduler-time-grid-view-hour-border-width - Border width for hour boundaries
 * @cssprop {String} --scheduler-time-grid-view-padding-bottom - Bottom padding
 * @cssprop {String} --scheduler-time-grid-view-padding-left - Left padding
 * @cssprop {String} --scheduler-time-grid-view-padding-right - Right padding
 * @cssprop {String} --scheduler-time-grid-view-padding-top - Top padding
 * @cssprop {String} --scheduler-time-grid-view-shadow - The time grid view shadow CSS custom property.
 * @cssprop {String} --scheduler-time-grid-view-shadow-blur - The time grid view shadow blur CSS custom property.
 * @cssprop {String} --scheduler-time-grid-view-shadow-color - The time grid view shadow color CSS custom property.
 * @cssprop {String} --scheduler-time-grid-view-shadow-offset-x - The time grid view shadow offset x CSS custom property.
 * @cssprop {String} --scheduler-time-grid-view-shadow-offset-y - The time grid view shadow offset y CSS custom property.
 * @cssprop {String} --scheduler-time-grid-view-shadow-spread - The time grid view shadow spread CSS custom property.
 * @cssprop {String} --scheduler-time-grid-view-timescale-width - Width of the timescale column
 * @cssprop {Color} --scheduler-time-grid-view-today-background-color - Background color for today's column
 * @cssprop {String} --scheduler-time-grid-view-transition-duration - Duration for transitions
 * @cssprop {String} --scheduler-time-grid-view-transition-mode - Timing function for transitions
 * @cssprop {String} --scheduler-time-grid-view-transition-property - CSS properties to transition
 * @cssprop {String} --scheduler-time-grid-view-translate - The time grid view translate CSS custom property.
 *
 * @dependency mosaik-scheduler-now-indicator - The Scheduler Now Indicator element.
 * @dependency mosaik-scheduler-timescale - The Scheduler Timescale element.
 *
 * @example
 * ```html
 * <mosaik-scheduler-time-grid-view days="5" hour-start="8" hour-end="18"></mosaik-scheduler-time-grid-view>
 * ```
 *
 * @public
 */
let SchedulerTimeGridViewElement = class SchedulerTimeGridViewElement extends SchedulerViewBaseElement {
    // #region Fields
    _days;
    _hourStart;
    _hourEnd;
    _stepMinutes;
    _allDayVisibility;
    _visibleDates;
    _eventsByDay;
    _allDayEventsByDay;
    _nowIndicatorIntervalId;
    // #endregion
    // #region Ctor
    constructor() {
        super();
        this._days = ISchedulerTimeGridViewElementProps.DEFAULTS.days;
        this._hourStart = ISchedulerTimeGridViewElementProps.DEFAULTS.hourStart;
        this._hourEnd = ISchedulerTimeGridViewElementProps.DEFAULTS.hourEnd;
        this._stepMinutes = ISchedulerTimeGridViewElementProps.DEFAULTS.stepMinutes;
        this._allDayVisibility = ISchedulerTimeGridViewElementProps.DEFAULTS.allDayVisibility;
        this._visibleDates = [];
        this._eventsByDay = new Map();
        this._allDayEventsByDay = new Map();
        this._nowIndicatorIntervalId = null;
    }
    // #endregion
    // #region Properties
    /**
     * Returns the `is` property.
     *
     * @public
     * @static
     * @readonly
     */
    static get is() {
        return 'mosaik-scheduler-time-grid-view';
    }
    /**
     * Gets the layout mode for this view.
     *
     * @public
     * @override
     * @readonly
     */
    get view() {
        return 'timeGrid';
    }
    /**
     * Gets or sets the number of days to display.
     *
     * @public
     * @attr
     */
    get days() {
        return this._days;
    }
    set days(value) {
        if (this._days !== value) {
            this._days = value;
            this.requestUpdate('days');
        }
    }
    /**
     * Gets or sets the start hour of the time range.
     *
     * @public
     * @attr
     */
    get hourStart() {
        return this._hourStart;
    }
    set hourStart(value) {
        if (this._hourStart !== value) {
            this._hourStart = value;
            this.requestUpdate('hourStart');
        }
    }
    /**
     * Gets or sets the end hour of the time range.
     *
     * @public
     * @attr
     */
    get hourEnd() {
        return this._hourEnd;
    }
    set hourEnd(value) {
        if (this._hourEnd !== value) {
            this._hourEnd = value;
            this.requestUpdate('hourEnd');
        }
    }
    /**
     * Gets or sets the step interval in minutes.
     *
     * @public
     * @attr
     */
    get stepMinutes() {
        return this._stepMinutes;
    }
    set stepMinutes(value) {
        if (this._stepMinutes !== value) {
            this._stepMinutes = value;
            this.requestUpdate('stepMinutes');
        }
    }
    /**
     * Gets or sets the visibility mode for all-day events.
     *
     * @public
     * @attr
     */
    get allDayVisibility() {
        return this._allDayVisibility;
    }
    set allDayVisibility(value) {
        if (this._allDayVisibility !== value) {
            this._allDayVisibility = value;
            this.requestUpdate('allDayVisibility');
        }
    }
    /**
     * Gets the visible dates array.
     *
     * @public
     * @readonly
     */
    get visibleDates() {
        return this._visibleDates;
    }
    /**
     * Gets the events organized by day.
     *
     * @public
     * @readonly
     */
    get eventsByDay() {
        return this._eventsByDay;
    }
    /**
     * Gets the time slots for rendering the grid.
     *
     * @public
     * @readonly
     */
    get timeSlots() {
        return generateTimeSlots(this._hourStart, this._hourEnd, this._stepMinutes, this.locale, (date, locale) => TimeFormatter.format(date, this.timeFormat, locale));
    }
    /**
     * Returns whether there are any all-day events.
     *
     * @public
     * @readonly
     */
    get hasAllDayEvents() {
        return this._allDayEventsByDay.size > 0;
    }
    // #endregion
    // #region Methods
    /**
     * @public
     * @override
     */
    connectedCallback() {
        super.connectedCallback();
        this.updateVisibleDates();
        this.positionEvents();
        this.startNowIndicatorSync();
    }
    /**
     * @public
     * @override
     */
    disconnectedCallback() {
        this.stopNowIndicatorSync();
        super.disconnectedCallback();
    }
    /**
     * Gets events for a specific day.
     *
     * @public
     * @param dayKey - The day key (YYYY-MM-DD).
     * @returns Array of positioned events for that day.
     */
    getEventsForDay(dayKey) {
        return this._eventsByDay.get(dayKey) ?? [];
    }
    /**
     * Gets all all-day events across all visible days.
     *
     * @public
     * @returns Array of all all-day events.
     */
    getAllDayEvents() {
        const events = [];
        for (const dayEvents of this._allDayEventsByDay.values()) {
            events.push(...dayEvents);
        }
        return events;
    }
    /**
     * Calculates the now indicator top position as percentage.
     *
     * @public
     * @returns The top position percentage (0-100), or -1 if outside visible range.
     */
    getNowIndicatorTop() {
        const now = new Date();
        const currentHour = now.getHours() + now.getMinutes() / 60;
        if (currentHour < this._hourStart || currentHour > this._hourEnd) {
            return -1;
        }
        return calculateTimePosition(now, this._hourStart, this._hourEnd);
    }
    /**
     * Handles click on a grid cell to create a new event.
     *
     * @param date - The date of the cell.
     * @param time - The time slot string (e.g., "09:00").
     * @internal
     */
    onGridCellClick(date, time) {
        const [hours, minutes] = time.split(':').map(Number);
        const start = new Date(date.getFullYear(), date.getMonth(), date.getDate(), hours, minutes);
        const end = new Date(start.getTime() + this._stepMinutes * 60 * 1000);
        const dayKey = formatDateToIso(date);
        this.emitSelectRange(start, end, dayKey, false);
    }
    /**
     * Handles click on an all-day cell to create a new all-day event.
     *
     * @param date - The date of the cell.
     * @internal
     */
    onAllDayCellClick(date) {
        const start = new Date(date.getFullYear(), date.getMonth(), date.getDate(), 0, 0, 0);
        const end = new Date(date.getFullYear(), date.getMonth(), date.getDate(), 23, 59, 59);
        const dayKey = formatDateToIso(date);
        this.emitSelectRange(start, end, dayKey, true);
    }
    onDateChanged() {
        this.updateVisibleDates();
        this.positionEvents();
    }
    onEventChanged() {
        this.positionEvents();
    }
    updateVisibleDates() {
        let alignedStartDate = this.effectiveStartDate;
        if (this._days > 1) {
            alignedStartDate = getStartOfWeek(this.effectiveStartDate, this.firstDayOfWeek);
        }
        this._visibleDates = generateVisibleDates(alignedStartDate, this._days);
        this.requestUpdate('visibleDates');
    }
    positionEvents() {
        const timedEvents = this.collectedEvents.filter(e => !e.allDay);
        const allDayEvents = this.collectedEvents.filter(e => e.allDay);
        // Group timed events by day
        const eventsByDay = new Map();
        for (const event of timedEvents) {
            const dayKey = getDayKey(event.startTime);
            if (!eventsByDay.has(dayKey)) {
                eventsByDay.set(dayKey, []);
            }
            eventsByDay.get(dayKey).push({
                eventKey: event.eventKey,
                startTime: event.startTime,
                endTime: event.endTime,
                element: event.element
            });
        }
        // Calculate positions for timed events
        this._eventsByDay = new Map();
        for (const [dayKey, events] of eventsByDay) {
            const positioned = this.calculateEventLanes(events);
            this._eventsByDay.set(dayKey, positioned);
        }
        // Process all-day events
        this._allDayEventsByDay = new Map();
        const visibleStart = this._visibleDates[0];
        const visibleEnd = this._visibleDates[this._visibleDates.length - 1];
        for (const event of allDayEvents) {
            const eventStart = new Date(event.startTime.getFullYear(), event.startTime.getMonth(), event.startTime.getDate());
            const eventEnd = new Date(event.endTime.getFullYear(), event.endTime.getMonth(), event.endTime.getDate());
            const visibleStartNorm = new Date(visibleStart.getFullYear(), visibleStart.getMonth(), visibleStart.getDate());
            const visibleEndNorm = new Date(visibleEnd.getFullYear(), visibleEnd.getMonth(), visibleEnd.getDate());
            if (eventEnd < visibleStartNorm || eventStart > visibleEndNorm) {
                continue;
            }
            const overflowsStart = eventStart < visibleStartNorm;
            const overflowsEnd = eventEnd > visibleEndNorm;
            const effectiveStart = eventStart < visibleStartNorm ? visibleStartNorm : eventStart;
            const effectiveEnd = eventEnd > visibleEndNorm ? visibleEndNorm : eventEnd;
            const dayIndex = this._visibleDates.findIndex(d => {
                const dNorm = new Date(d.getFullYear(), d.getMonth(), d.getDate());
                return dNorm.getTime() === effectiveStart.getTime();
            });
            const spanDays = Math.max(1, Math.ceil((effectiveEnd.getTime() - effectiveStart.getTime()) / (1000 * 60 * 60 * 24)) + 1);
            const dayKey = getDayKey(effectiveStart);
            if (!this._allDayEventsByDay.has(dayKey)) {
                this._allDayEventsByDay.set(dayKey, []);
            }
            this._allDayEventsByDay.get(dayKey).push({
                eventKey: event.eventKey,
                startDate: event.startTime,
                endDate: event.endTime,
                spanDays: Math.min(spanDays, this._days - dayIndex),
                dayIndex,
                element: event.element,
                overflowStart: overflowsStart,
                overflowEnd: overflowsEnd
            });
        }
        this.requestUpdate('eventsByDay');
    }
    calculateEventLanes(events) {
        if (events.length === 0) {
            return [];
        }
        const totalMinutes = (this._hourEnd - this._hourStart) * 60;
        const minHeightPercent = (this._stepMinutes / totalMinutes) * 100;
        const ranges = events.map((e) => ({
            eventKey: e.eventKey,
            start: e.startTime.getHours() * 60 + e.startTime.getMinutes(),
            end: e.endTime.getHours() * 60 + e.endTime.getMinutes(),
            element: e.element,
            originalEvent: { startTime: e.startTime, endTime: e.endTime }
        }));
        ranges.sort((a, b) => {
            if (a.start !== b.start) {
                return a.start - b.start;
            }
            return (b.end - b.start) - (a.end - a.start);
        });
        const groups = [];
        let currentGroup = [];
        let groupEnd = 0;
        for (const range of ranges) {
            if (currentGroup.length === 0 || range.start < groupEnd) {
                currentGroup.push(range);
                groupEnd = Math.max(groupEnd, range.end);
            }
            else {
                groups.push(currentGroup);
                currentGroup = [range];
                groupEnd = range.end;
            }
        }
        if (currentGroup.length > 0) {
            groups.push(currentGroup);
        }
        const positioned = [];
        for (const group of groups) {
            const lanes = [];
            for (const range of group) {
                let assigned = false;
                for (let laneIndex = 0; laneIndex < lanes.length; laneIndex++) {
                    const lane = lanes[laneIndex];
                    const lastInLane = lane[lane.length - 1];
                    if (range.start >= lastInLane.end) {
                        lane.push(range);
                        assigned = true;
                        break;
                    }
                }
                if (!assigned) {
                    lanes.push([range]);
                }
            }
            const totalLanes = lanes.length;
            const laneWidth = 100 / totalLanes;
            for (let laneIndex = 0; laneIndex < lanes.length; laneIndex++) {
                for (const range of lanes[laneIndex]) {
                    const top = calculateTimePosition(range.originalEvent.startTime, this._hourStart, this._hourEnd);
                    const rawHeight = calculateTimeHeight(range.originalEvent.startTime, range.originalEvent.endTime, this._hourStart, this._hourEnd);
                    const height = Math.max(rawHeight, minHeightPercent);
                    positioned.push({
                        eventKey: range.eventKey,
                        top,
                        height,
                        left: laneIndex * laneWidth,
                        width: laneWidth,
                        startTime: range.originalEvent.startTime,
                        endTime: range.originalEvent.endTime,
                        element: range.element
                    });
                }
            }
        }
        return positioned;
    }
    startNowIndicatorSync() {
        this.stopNowIndicatorSync();
        this._nowIndicatorIntervalId = window.setInterval(() => {
            this.requestUpdate();
        }, 30_000);
    }
    stopNowIndicatorSync() {
        if (this._nowIndicatorIntervalId !== null) {
            clearInterval(this._nowIndicatorIntervalId);
            this._nowIndicatorIntervalId = null;
        }
    }
};
__decorate([
    Attribute({ type: Number }),
    __metadata("design:type", Number),
    __metadata("design:paramtypes", [Number])
], SchedulerTimeGridViewElement.prototype, "days", null);
__decorate([
    Attribute({ type: Number }),
    __metadata("design:type", Number),
    __metadata("design:paramtypes", [Number])
], SchedulerTimeGridViewElement.prototype, "hourStart", null);
__decorate([
    Attribute({ type: Number }),
    __metadata("design:type", Number),
    __metadata("design:paramtypes", [Number])
], SchedulerTimeGridViewElement.prototype, "hourEnd", null);
__decorate([
    Attribute({ type: Number }),
    __metadata("design:type", Number),
    __metadata("design:paramtypes", [Number])
], SchedulerTimeGridViewElement.prototype, "stepMinutes", null);
__decorate([
    Attribute({ type: AllDayVisibility }),
    __metadata("design:type", String),
    __metadata("design:paramtypes", [String])
], SchedulerTimeGridViewElement.prototype, "allDayVisibility", null);
__decorate([
    Watch('startDate'),
    Watch('days'),
    Watch('firstDayOfWeek'),
    __metadata("design:type", Function),
    __metadata("design:paramtypes", []),
    __metadata("design:returntype", void 0)
], SchedulerTimeGridViewElement.prototype, "onDateChanged", null);
__decorate([
    Watch('collectedEvents'),
    Watch('hourStart'),
    Watch('hourEnd'),
    Watch('stepMinutes'),
    __metadata("design:type", Function),
    __metadata("design:paramtypes", []),
    __metadata("design:returntype", void 0)
], SchedulerTimeGridViewElement.prototype, "onEventChanged", null);
SchedulerTimeGridViewElement = __decorate([
    Component({
        selector: 'mosaik-scheduler-time-grid-view',
        template: schedulerTimeGridViewElementTemplate,
        themes: {
            joy: schedulerTimeGridViewElementJoyStyle,
            cosmopolitan: schedulerTimeGridViewElementCosmopolitanStyle,
            memphis: schedulerTimeGridViewElementMemphisStyle
        },
        imports: [
            SchedulerTimescaleElement,
            SchedulerNowIndicatorElement
        ]
    }),
    __metadata("design:paramtypes", [])
], SchedulerTimeGridViewElement);
export { SchedulerTimeGridViewElement };
//# sourceMappingURL=SchedulerTimeGridViewElement.js.map