@mintplayer/ng-bootstrap 21.22.0 → 21.23.1

package/types/mintplayer-ng-bootstrap-web-components-scheduler-core.d.ts

@@ -0,0 +1,890 @@
+/**
+ * View types for the scheduler
+ */
+type ViewType = 'year' | 'month' | 'week' | 'day' | 'timeline';
+/**
+ * Display mode for events
+ */
+type DisplayMode = 'grid' | 'timeline';
+/**
+ * Time format options
+ */
+type TimeFormat = '12h' | '24h';
+/**
+ * Days of the week (0 = Sunday, 1 = Monday, etc.)
+ */
+type DayOfWeek = 0 | 1 | 2 | 3 | 4 | 5 | 6;
+/**
+ * Drag operation types
+ */
+type DragOperationType = 'create' | 'move' | 'resize-start' | 'resize-end';
+
+/**
+ * Represents a scheduler event
+ */
+interface SchedulerEvent {
+    /** Unique identifier for the event */
+    id: string;
+    /** Event title displayed in the calendar */
+    title: string;
+    /** Start date and time */
+    start: Date;
+    /** End date and time */
+    end: Date;
+    /** Whether this is an all-day event */
+    allDay?: boolean;
+    /** Background color of the event */
+    color?: string;
+    /** Text color of the event */
+    textColor?: string;
+    /** ID of the resource this event belongs to */
+    resourceId?: string;
+    /** Whether the event can be edited */
+    editable?: boolean;
+    /** Whether the event can be dragged */
+    draggable?: boolean;
+    /** Whether the event can be resized */
+    resizable?: boolean | {
+        start: boolean;
+        end: boolean;
+    };
+    /** Additional CSS class names */
+    classNames?: string[];
+    /** Custom properties for extending event data */
+    extendedProps?: Record<string, unknown>;
+}
+/**
+ * Represents a part of an event that spans multiple days
+ */
+interface SchedulerEventPart {
+    /** Unique identifier for this part */
+    id: string;
+    /** Reference to the parent event */
+    event: SchedulerEvent;
+    /** Start of this part (may differ from event.start for multi-day events) */
+    start: Date;
+    /** End of this part (may be midnight for multi-day events) */
+    end: Date;
+    /** Whether this is the first day of the event */
+    isStart: boolean;
+    /** Whether this is the last day of the event */
+    isEnd: boolean;
+    /** Which day in the sequence (0-based) */
+    dayIndex: number;
+    /** Total number of days this event spans */
+    totalDays: number;
+}
+/**
+ * An event with its daily parts
+ */
+interface SchedulerEventWithParts {
+    /** The original event */
+    event: SchedulerEvent;
+    /** Array of daily parts */
+    parts: SchedulerEventPart[];
+}
+/**
+ * A preview event shown during drag operations
+ */
+interface PreviewEvent {
+    /** Start of the preview */
+    start: Date;
+    /** End of the preview */
+    end: Date;
+    /** Optional resource ID for resource-based views */
+    resourceId?: string;
+}
+/**
+ * A track/rail containing non-overlapping events
+ */
+interface TimelineTrack {
+    /** Track index (0 = first/leftmost track) */
+    index: number;
+    /** Events in this track (guaranteed non-overlapping) */
+    events: SchedulerEvent[];
+}
+/**
+ * Position information for rendering an event
+ */
+interface EventPosition {
+    /** Top position in pixels or percentage */
+    top: number;
+    /** Left position in pixels or percentage */
+    left: number;
+    /** Width in pixels or percentage */
+    width: number;
+    /** Height in pixels or percentage */
+    height: number;
+    /** Z-index for stacking */
+    zIndex: number;
+}
+/**
+ * Layout information for an event within its overlap group
+ * Used for colspan-based positioning algorithm
+ */
+interface EventLayoutInfo {
+    /** Column index within the overlap group (0-based) */
+    col: number;
+    /** Number of columns this event can span */
+    colspan: number;
+    /** Total number of columns in the overlap group */
+    columnCount: number;
+}
+
+/**
+ * Represents a resource (e.g., a room, employee, machine)
+ */
+interface Resource {
+    /** Unique identifier for the resource */
+    id: string;
+    /** Display title of the resource */
+    title: string;
+    /** Events assigned to this resource */
+    events?: SchedulerEvent[];
+    /** Background color for this resource's events */
+    color?: string;
+    /** Default event color for this resource */
+    eventColor?: string;
+    /** Sort order */
+    order?: number;
+    /** Custom properties for extending resource data */
+    extendedProps?: Record<string, unknown>;
+}
+/**
+ * Represents a group of resources (e.g., a department, category)
+ */
+interface ResourceGroup {
+    /** Unique identifier for the group */
+    id: string;
+    /** Display title of the group */
+    title: string;
+    /** Child resources or nested groups */
+    children: (Resource | ResourceGroup)[];
+    /** Whether the group is collapsed in the UI */
+    collapsed?: boolean;
+    /** Background color for the group header */
+    color?: string;
+    /** Sort order */
+    order?: number;
+}
+/**
+ * Type guard to check if an item is a Resource
+ */
+declare function isResource(item: Resource | ResourceGroup): item is Resource;
+/**
+ * Type guard to check if an item is a ResourceGroup
+ */
+declare function isResourceGroup(item: Resource | ResourceGroup): item is ResourceGroup;
+/**
+ * Flattened resource with depth information for rendering
+ */
+interface FlattenedResource {
+    /** The resource or group */
+    item: Resource | ResourceGroup;
+    /** Nesting depth (0 = top level) */
+    depth: number;
+    /** Whether this item is visible (not in a collapsed group) */
+    visible: boolean;
+    /** Parent group ID if any */
+    parentId?: string;
+}
+
+/**
+ * Represents a time slot in the scheduler grid
+ */
+interface TimeSlot {
+    /** Start of the time slot */
+    start: Date;
+    /** End of the time slot */
+    end: Date;
+}
+/**
+ * A row of time slots with associated metadata
+ */
+interface TimeSlotRow {
+    /** The time stamp for this row (e.g., 09:00) */
+    time: Date;
+    /** Label to display (e.g., "9:00 AM") */
+    label: string;
+    /** Individual slots for each column (day) */
+    slots: TimeSlot[];
+}
+/**
+ * Grid structure for the scheduler
+ */
+interface SchedulerGrid {
+    /** Column headers (days) */
+    columns: Date[];
+    /** Row headers (times) */
+    rows: TimeSlotRow[];
+    /** All time slots flattened */
+    allSlots: TimeSlot[];
+}
+
+/**
+ * Business hours configuration
+ */
+interface BusinessHours {
+    /** Days of the week when business hours apply (0 = Sunday) */
+    daysOfWeek: DayOfWeek[];
+    /** Start time in HH:mm format */
+    startTime: string;
+    /** End time in HH:mm format */
+    endTime: string;
+}
+/**
+ * Header toolbar configuration
+ */
+interface HeaderToolbar {
+    /** Left section content */
+    start?: string;
+    /** Center section content */
+    center?: string;
+    /** Right section content */
+    end?: string;
+}
+/**
+ * Configuration options for the scheduler
+ */
+interface SchedulerOptions {
+    /** Initial view to display */
+    initialView?: ViewType;
+    /** Initial date to display */
+    initialDate?: Date;
+    /** Locale for date formatting (e.g., 'en-US') */
+    locale?: string;
+    /** First day of the week (0 = Sunday, 1 = Monday) */
+    firstDayOfWeek?: DayOfWeek;
+    /** Timezone identifier (e.g., 'America/New_York') */
+    timeZone?: string;
+    /** Duration of each time slot in seconds (default: 1800 = 30 minutes) */
+    slotDuration?: number;
+    /** Interval between slot labels in seconds */
+    slotLabelInterval?: number;
+    /** Minimum time to display (e.g., '00:00:00') */
+    slotMinTime?: string;
+    /** Maximum time to display (e.g., '24:00:00') */
+    slotMaxTime?: string;
+    /** Time format (12h or 24h) */
+    timeFormat?: TimeFormat;
+    /** Business hours configuration */
+    businessHours?: BusinessHours;
+    /** Height of the scheduler ('auto', number in px, or CSS value) */
+    height?: 'auto' | number | string;
+    /** Height of the content area */
+    contentHeight?: 'auto' | number;
+    /** Aspect ratio for auto-sizing */
+    aspectRatio?: number;
+    /** Whether to expand rows to fill available space */
+    expandRows?: boolean;
+    /** Header toolbar configuration */
+    headerToolbar?: HeaderToolbar;
+    /** Whether events can be edited */
+    editable?: boolean;
+    /** Whether date ranges can be selected */
+    selectable?: boolean;
+    /** Whether to show a mirror element during selection */
+    selectMirror?: boolean;
+    /** Whether event duration can be changed */
+    eventDurationEditable?: boolean;
+    /** Whether event start time can be changed */
+    eventStartEditable?: boolean;
+    /** Duration of revert animation in ms */
+    dragRevertDuration?: number;
+    /** Whether to scroll during drag */
+    dragScroll?: boolean;
+    /** Snap duration in seconds */
+    snapDuration?: number;
+    /** Whether to show current time indicator */
+    nowIndicator?: boolean;
+    /** Whether to show week numbers */
+    weekNumbers?: boolean;
+    /** Text to display before week number */
+    weekText?: string;
+    /** Maximum events to show per day (true = show "+X more" link) */
+    dayMaxEvents?: boolean | number;
+}
+/**
+ * Default options for the scheduler
+ */
+declare const DEFAULT_OPTIONS: Required<SchedulerOptions>;
+
+/**
+ * State of a drag operation
+ */
+interface DragState {
+    /** Type of drag operation */
+    type: DragOperationType;
+    /** Event being dragged (null for create operations) */
+    event: SchedulerEvent | null;
+    /** Starting time slot */
+    startSlot: TimeSlot;
+    /** Current time slot (updated during drag) */
+    currentSlot: TimeSlot;
+    /** Preview event showing where the event will be placed */
+    preview: PreviewEvent;
+    /** Resource being dragged to (for resource views) */
+    resource?: Resource;
+    /** Original event data (for reverting on cancel) */
+    originalEvent?: SchedulerEvent;
+    /** Metadata for the drag operation */
+    meta?: {
+        /** For resize: which end is being resized */
+        resizeHandle?: 'start' | 'end';
+        /** Offset from event start when drag began */
+        offsetMs?: number;
+    };
+}
+/**
+ * Result of a completed drag operation
+ */
+interface DragResult {
+    /** Type of operation that was completed */
+    type: DragOperationType;
+    /** The event that was created or modified */
+    event: SchedulerEvent;
+    /** The previous event state (for move/resize) */
+    previousEvent?: SchedulerEvent;
+    /** Whether the operation was cancelled */
+    cancelled: boolean;
+}
+
+/**
+ * Base event detail interface
+ */
+interface BaseEventDetail {
+    /** Original DOM event */
+    originalEvent?: Event;
+}
+/**
+ * Event click event detail
+ */
+interface EventClickDetail extends BaseEventDetail {
+    /** The clicked event */
+    event: SchedulerEvent;
+}
+/**
+ * Event create event detail
+ */
+interface EventCreateDetail extends BaseEventDetail {
+    /** The newly created event */
+    event: SchedulerEvent;
+    /** Resource the event was created on (if applicable) */
+    resource?: Resource;
+}
+/**
+ * Event update event detail
+ */
+interface EventUpdateDetail extends BaseEventDetail {
+    /** The updated event */
+    event: SchedulerEvent;
+    /** The event before the update */
+    oldEvent: SchedulerEvent;
+}
+/**
+ * Event delete event detail
+ */
+interface EventDeleteDetail extends BaseEventDetail {
+    /** The deleted event */
+    event: SchedulerEvent;
+}
+/**
+ * Date click event detail
+ */
+interface DateClickDetail extends BaseEventDetail {
+    /** The clicked date */
+    date: Date;
+    /** Resource at the clicked location (if applicable) */
+    resource?: Resource;
+}
+/**
+ * Date select event detail
+ */
+interface DateSelectDetail extends BaseEventDetail {
+    /** Start of the selected range */
+    start: Date;
+    /** End of the selected range */
+    end: Date;
+    /** Resource at the selected location (if applicable) */
+    resource?: Resource;
+}
+/**
+ * View change event detail
+ */
+interface ViewChangeDetail {
+    /** The new view */
+    view: ViewType;
+    /** The current date in the new view */
+    date: Date;
+}
+/**
+ * Custom event map for the scheduler web component
+ */
+interface SchedulerEventMap {
+    'event-click': CustomEvent<EventClickDetail>;
+    'event-dblclick': CustomEvent<EventClickDetail>;
+    'event-create': CustomEvent<EventCreateDetail>;
+    'event-update': CustomEvent<EventUpdateDetail>;
+    'event-delete': CustomEvent<EventDeleteDetail>;
+    'date-click': CustomEvent<DateClickDetail>;
+    'date-select': CustomEvent<DateSelectDetail>;
+    'view-change': CustomEvent<ViewChangeDetail>;
+}
+
+/**
+ * Service for date calculations and formatting
+ */
+declare class DateService {
+    /**
+     * Get the start of the week for a given date
+     */
+    getWeekStart(date: Date, firstDayOfWeek?: DayOfWeek): Date;
+    /**
+     * Get all days in a week starting from a given date
+     */
+    getWeekDays(date: Date, firstDayOfWeek?: DayOfWeek): Date[];
+    /**
+     * Get the start of the month for a given date
+     */
+    getMonthStart(date: Date): Date;
+    /**
+     * Get the end of the month for a given date
+     */
+    getMonthEnd(date: Date): Date;
+    /**
+     * Get all days in a month
+     */
+    getMonthDays(date: Date): Date[];
+    /**
+     * Get weeks for a month view (includes days from adjacent months)
+     */
+    getMonthWeeks(date: Date, firstDayOfWeek?: DayOfWeek): Date[][];
+    /**
+     * Get the start of the year for a given date
+     */
+    getYearStart(date: Date): Date;
+    /**
+     * Get all months in a year
+     */
+    getYearMonths(date: Date): Date[];
+    /**
+     * Get time slots for a day
+     */
+    getTimeSlots(date: Date, slotDuration?: number, minTime?: string, maxTime?: string): TimeSlot[];
+    /**
+     * Generate a scheduler grid for week view
+     */
+    getWeekGrid(date: Date, firstDayOfWeek?: DayOfWeek, slotDuration?: number, minTime?: string, maxTime?: string, timeFormat?: TimeFormat): SchedulerGrid;
+    /**
+     * Round a date to the nearest slot
+     */
+    roundToSlot(date: Date, slotDuration: number): Date;
+    /**
+     * Floor a date to the slot start
+     */
+    floorToSlot(date: Date, slotDuration: number): Date;
+    /**
+     * Ceiling a date to the slot end
+     */
+    ceilToSlot(date: Date, slotDuration: number): Date;
+    /**
+     * Detect time format preference based on locale
+     * Uses the Intl API to determine if the locale uses 12-hour or 24-hour time
+     */
+    detectTimeFormat(locale?: string): TimeFormat;
+    /**
+     * Format time according to format preference
+     */
+    formatTime(date: Date, format?: TimeFormat): string;
+    /**
+     * Format date for display
+     */
+    formatDate(date: Date, locale?: string, options?: Intl.DateTimeFormatOptions): string;
+    /**
+     * Format date with weekday
+     */
+    formatDateWithWeekday(date: Date, locale?: string): string;
+    /**
+     * Get month name
+     */
+    getMonthName(date: Date, locale?: string, format?: 'long' | 'short'): string;
+    /**
+     * Get day name
+     */
+    getDayName(date: Date, locale?: string, format?: 'long' | 'short' | 'narrow'): string;
+    /**
+     * Check if two dates are the same day
+     */
+    isSameDay(date1: Date, date2: Date): boolean;
+    /**
+     * Check if two dates are the same month
+     */
+    isSameMonth(date1: Date, date2: Date): boolean;
+    /**
+     * Check if a date is today
+     */
+    isToday(date: Date): boolean;
+    /**
+     * Check if a date is in the past
+     */
+    isPast(date: Date): boolean;
+    /**
+     * Check if a date falls within a range
+     */
+    isInRange(date: Date, start: Date, end: Date): boolean;
+    /**
+     * Get the number of days between two dates
+     */
+    getDaysDifference(date1: Date, date2: Date): number;
+    /**
+     * Add days to a date
+     */
+    addDays(date: Date, days: number): Date;
+    /**
+     * Add weeks to a date
+     */
+    addWeeks(date: Date, weeks: number): Date;
+    /**
+     * Add months to a date
+     */
+    addMonths(date: Date, months: number): Date;
+    /**
+     * Add years to a date
+     */
+    addYears(date: Date, years: number): Date;
+    /**
+     * Get week number of the year
+     */
+    getWeekNumber(date: Date): number;
+    /**
+     * Get seconds from midnight for a date
+     */
+    getSecondsFromMidnight(date: Date): number;
+    /**
+     * Get duration in seconds between two dates
+     */
+    getDurationInSeconds(start: Date, end: Date): number;
+}
+/**
+ * Singleton instance of DateService
+ */
+declare const dateService: DateService;
+
+/**
+ * Service for timeline calculations and event track assignment
+ */
+declare class TimelineService {
+    /**
+     * Split an event into daily parts
+     * Each part represents one day of a multi-day event
+     */
+    splitInParts(event: SchedulerEvent | PreviewEvent): SchedulerEventWithParts;
+    /**
+     * Calculate total days an event spans
+     */
+    private getTotalDays;
+    /**
+     * Assign events to tracks (rails) to minimize overlapping
+     * This method should be called when events are updated, NOT during drag operations
+     */
+    getTimeline(events: SchedulerEvent[]): TimelineTrack[];
+    /**
+     * Get track assignment for event parts using colspan algorithm (for rendering)
+     *
+     * This uses a colspan-based algorithm similar to Outlook/Google Calendar:
+     * 1. Build overlap groups (connected components of overlapping events)
+     * 2. Assign columns within each group using a greedy algorithm
+     * 3. Compute colspan - how many columns each event can span
+     *
+     * This ensures events are displayed as wide as possible:
+     * - An event with no overlapping events gets 100% width
+     * - Events only share space with events they actually overlap with
+     * - An event can span multiple columns if there's no blocking event to its right
+     */
+    getTimelinedParts(eventParts: SchedulerEventPart[]): {
+        part: SchedulerEventPart;
+        trackIndex: number;
+        totalTracks: number;
+        colspan: number;
+    }[];
+    /**
+     * Compute colspan-based layout for events (Outlook/Google Calendar algorithm)
+     *
+     * Phase 1: Build overlap groups (connected components)
+     * Phase 2: Assign columns within each group
+     * Phase 3: Compute colspan for each event
+     */
+    getColspanLayout(events: SchedulerEvent[]): Map<string, EventLayoutInfo>;
+    /**
+     * Build overlap groups (connected components)
+     * Events belong to the same group if they overlap directly or indirectly
+     *
+     * Optimized to reduce comparisons by pre-sorting events by start time
+     * and breaking early when events can no longer overlap
+     */
+    private buildOverlapGroups;
+    /**
+     * Assign columns to events within an overlap group
+     * Uses a greedy algorithm: place each event in the first available column
+     * Returns the column assignments and total column count
+     */
+    private assignColumns;
+    /**
+     * Compute colspan for an event
+     * An event can span multiple columns if there's no overlapping event to its right
+     */
+    private computeColspan;
+    /**
+     * Check if two events overlap in time
+     */
+    private eventsOverlap;
+    /**
+     * Calculate the relative track position for an event part (legacy method)
+     * @deprecated Use getColspanLayout instead for better layout
+     */
+    private getRelativeTrackPosition;
+    /**
+     * Filter events that fall within a date range
+     */
+    filterByRange(events: SchedulerEvent[], start: Date, end: Date): SchedulerEvent[];
+    /**
+     * Filter event parts that fall within a date range
+     */
+    filterPartsByRange(parts: SchedulerEventPart[], start: Date, end: Date): SchedulerEventPart[];
+    /**
+     * Get all unique timestamps from events (both start and end times)
+     */
+    private getUniqueTimestamps;
+    /**
+     * Check if a track has space for an event (no overlapping)
+     */
+    private isTrackFreeForEvent;
+    /**
+     * Get events for a specific day
+     */
+    getEventsForDay(events: SchedulerEvent[], day: Date): SchedulerEvent[];
+    /**
+     * Get event parts for a specific day
+     */
+    getPartsForDay(parts: SchedulerEventPart[], day: Date): SchedulerEventPart[];
+}
+/**
+ * Singleton instance of TimelineService
+ */
+declare const timelineService: TimelineService;
+
+/**
+ * Service for calculating event positions within the grid
+ */
+declare class PositionService {
+    /**
+     * Calculate position for an event part in week/day view
+     */
+    calculateWeekPosition(part: SchedulerEventPart, trackIndex: number, totalTracks: number, dayIndex: number, totalDays: number, options?: Partial<SchedulerOptions>): EventPosition;
+    /**
+     * Calculate position for an event in timeline view
+     */
+    calculateTimelinePosition(part: SchedulerEventPart, trackIndex: number, totalTracks: number, viewStart: Date, viewEnd: Date, options?: Partial<SchedulerOptions>): EventPosition;
+    /**
+     * Calculate position for an all-day event in month view
+     */
+    calculateMonthEventPosition(part: SchedulerEventPart, rowIndex: number, maxRows: number, startDayIndex: number, endDayIndex: number, totalDays?: number): EventPosition;
+    /**
+     * Convert percentage-based position to pixel-based
+     */
+    toPixelPosition(position: EventPosition, containerWidth: number, containerHeight: number): EventPosition;
+    /**
+     * Generate CSS styles from position
+     */
+    toStyleString(position: EventPosition, unit?: 'px' | '%'): string;
+    /**
+     * Generate CSS object from position
+     */
+    toStyleObject(position: EventPosition, unit?: 'px' | '%'): Record<string, string>;
+}
+/**
+ * Singleton instance of PositionService
+ */
+declare const positionService: PositionService;
+
+/**
+ * Service for resource and resource group operations
+ */
+declare class ResourceService {
+    /**
+     * Flatten a hierarchical resource structure for rendering
+     */
+    flatten(items: (Resource | ResourceGroup)[], collapsedIds?: Set<string>, depth?: number, parentId?: string, parentCollapsed?: boolean): FlattenedResource[];
+    /**
+     * Get all resources (leaf nodes) from a hierarchical structure
+     */
+    getAllResources(items: (Resource | ResourceGroup)[]): Resource[];
+    /**
+     * Get all events from all resources
+     */
+    getAllEvents(items: (Resource | ResourceGroup)[]): SchedulerEvent[];
+    /**
+     * Find a resource by ID
+     */
+    findResourceById(items: (Resource | ResourceGroup)[], id: string): Resource | undefined;
+    /**
+     * Find a resource group by ID
+     */
+    findGroupById(items: (Resource | ResourceGroup)[], id: string): ResourceGroup | undefined;
+    /**
+     * Find any item (resource or group) by ID
+     */
+    findById(items: (Resource | ResourceGroup)[], id: string): Resource | ResourceGroup | undefined;
+    /**
+     * Add an event to a resource
+     */
+    addEventToResource(items: (Resource | ResourceGroup)[], resourceId: string, event: SchedulerEvent): (Resource | ResourceGroup)[];
+    /**
+     * Update an event in a resource
+     */
+    updateEventInResource(items: (Resource | ResourceGroup)[], event: SchedulerEvent): (Resource | ResourceGroup)[];
+    /**
+     * Remove an event from all resources
+     */
+    removeEvent(items: (Resource | ResourceGroup)[], eventId: string): (Resource | ResourceGroup)[];
+    /**
+     * Move an event from one resource to another
+     */
+    moveEventToResource(items: (Resource | ResourceGroup)[], eventId: string, newResourceId: string, updatedEvent?: Partial<SchedulerEvent>): (Resource | ResourceGroup)[];
+    /**
+     * Toggle collapse state of a group
+     */
+    toggleGroupCollapse(items: (Resource | ResourceGroup)[], groupId: string): (Resource | ResourceGroup)[];
+    /**
+     * Set collapse state of a group
+     */
+    setGroupCollapse(items: (Resource | ResourceGroup)[], groupId: string, collapsed: boolean): (Resource | ResourceGroup)[];
+    /**
+     * Collapse all groups
+     */
+    collapseAll(items: (Resource | ResourceGroup)[]): (Resource | ResourceGroup)[];
+    /**
+     * Expand all groups
+     */
+    expandAll(items: (Resource | ResourceGroup)[]): (Resource | ResourceGroup)[];
+    /**
+     * Map over all resources in the hierarchy
+     */
+    private mapResources;
+    /**
+     * Map over all groups in the hierarchy
+     */
+    private mapGroups;
+    /**
+     * Get the total count of visible resources
+     */
+    getVisibleResourceCount(items: (Resource | ResourceGroup)[], collapsedIds?: Set<string>): number;
+    /**
+     * Sort resources by order property
+     */
+    sortByOrder(items: (Resource | ResourceGroup)[]): (Resource | ResourceGroup)[];
+}
+/**
+ * Singleton instance of ResourceService
+ */
+declare const resourceService: ResourceService;
+
+/**
+ * Generate a unique ID
+ */
+declare function generateId(prefix?: string): string;
+/**
+ * Generate a unique event ID
+ */
+declare function generateEventId(): string;
+/**
+ * Generate a unique resource ID
+ */
+declare function generateResourceId(): string;
+/**
+ * Generate a unique group ID
+ */
+declare function generateGroupId(): string;
+
+/**
+ * Default colors for events
+ */
+declare const DEFAULT_COLORS: string[];
+/**
+ * Get a color by index (cycles through default colors)
+ */
+declare function getColorByIndex(index: number): string;
+/**
+ * Calculate contrasting text color (black or white) for a background
+ */
+declare function getContrastColor(backgroundColor: string): string;
+/**
+ * Lighten a color by a percentage
+ */
+declare function lightenColor(color: string, percent: number): string;
+/**
+ * Darken a color by a percentage
+ */
+declare function darkenColor(color: string, percent: number): string;
+/**
+ * Add alpha (opacity) to a color
+ */
+declare function addAlpha(color: string, alpha: number): string;
+
+/**
+ * Get element by data attributes (used for finding time slots)
+ */
+declare function getElementByData(container: Element, dataAttributes: Record<string, string>): Element | null;
+/**
+ * Get data attributes from an element
+ */
+declare function getDataAttributes(element: Element): Record<string, string>;
+/**
+ * Find closest ancestor with a data attribute
+ */
+declare function findClosestWithData(element: Element, dataAttribute: string): Element | null;
+/**
+ * Get scroll position relative to an element
+ */
+declare function getScrollPosition(element: Element): {
+    top: number;
+    left: number;
+};
+/**
+ * Scroll to a specific time in the scheduler
+ */
+declare function scrollToTime(container: Element, timeElement: Element, behavior?: ScrollBehavior): void;
+/**
+ * Check if an element is in viewport
+ */
+declare function isInViewport(element: Element, container?: Element): boolean;
+/**
+ * Get pointer position relative to an element
+ */
+declare function getRelativePosition(event: MouseEvent | TouchEvent, element: Element): {
+    x: number;
+    y: number;
+};
+/**
+ * Create a CSS variable setter for theming
+ */
+declare function setCSSVariable(element: HTMLElement, name: string, value: string): void;
+/**
+ * Get computed CSS variable value
+ */
+declare function getCSSVariable(element: HTMLElement, name: string): string;
+/**
+ * Add multiple CSS classes
+ */
+declare function addClasses(element: Element, ...classes: string[]): void;
+/**
+ * Remove multiple CSS classes
+ */
+declare function removeClasses(element: Element, ...classes: string[]): void;
+/**
+ * Toggle CSS class based on condition
+ */
+declare function toggleClass(element: Element, className: string, condition: boolean): void;
+
+export { DEFAULT_COLORS, DEFAULT_OPTIONS, DateService, PositionService, ResourceService, TimelineService, addAlpha, addClasses, darkenColor, dateService, findClosestWithData, generateEventId, generateGroupId, generateId, generateResourceId, getCSSVariable, getColorByIndex, getContrastColor, getDataAttributes, getElementByData, getRelativePosition, getScrollPosition, isInViewport, isResource, isResourceGroup, lightenColor, positionService, removeClasses, resourceService, scrollToTime, setCSSVariable, timelineService, toggleClass };
+export type { BaseEventDetail, BusinessHours, DateClickDetail, DateSelectDetail, DayOfWeek, DisplayMode, DragOperationType, DragResult, DragState, EventClickDetail, EventCreateDetail, EventDeleteDetail, EventLayoutInfo, EventPosition, EventUpdateDetail, FlattenedResource, HeaderToolbar, PreviewEvent, Resource, ResourceGroup, SchedulerEvent, SchedulerEventMap, SchedulerEventPart, SchedulerEventWithParts, SchedulerGrid, SchedulerOptions, TimeFormat, TimeSlot, TimeSlotRow, TimelineTrack, ViewChangeDetail, ViewType };