@uplink-protocol/calendar-controller/dist/types/Event/services/event-manager.service.d.ts

Flexible calendar and time picker API supporting both calendar, date-picker, and time-picker integrations for any JavaScript framework or library

/**
 * Event Manager Service
 *
 * Main service that orchestrates all event management functionality
 */
import { EventEmitter } from "@uplink-protocol/core";
import { CalendarEvent, CreateEventInput, UpdateEventInput, EventFilter, EventSort, EventResults, EventValidationResult } from '../interfaces/event.interfaces';
import { IEventManagerService, EventManagerConfig } from '../interfaces/event-manager.service.interfaces';
/**
 * Event Manager Service Implementation
 */
export declare class EventManagerService implements IEventManagerService {
    private initialized;
    private config;
    private storageService;
    private validationService;
    private formattingService;
    private searchService;
    private recurrenceService;
    private events;
    constructor();
    /**
     * Initialize the event manager
     */
    initialize(config?: EventManagerConfig): Promise<void>;
    /**
     * Get all events
     */
    getAllEvents(): Promise<CalendarEvent[]>;
    /**
     * Get event by ID
     */
    getEventById(id: string): Promise<CalendarEvent | null>;
    /**
     * Query events with filters and pagination
     */
    queryEvents(filter?: EventFilter, sort?: EventSort, page?: number, pageSize?: number): Promise<EventResults>;
    /**
     * Create a new event
     */
    createEvent(input: CreateEventInput): Promise<CalendarEvent>;
    /**
     * Update an event
     */
    updateEvent(input: UpdateEventInput): Promise<CalendarEvent>;
    /**
     * Delete an event
     */
    deleteEvent(id: string): Promise<void>;
    /**
     * Search events
     */
    searchEvents(query: string, filters?: EventFilter): Promise<CalendarEvent[]>;
    /**
     * Filter events
     */
    filterEvents(filter: EventFilter): Promise<CalendarEvent[]>;
    /**
     * Sort events
     */
    sortEvents(sort: EventSort): Promise<CalendarEvent[]>;
    /**
     * Get upcoming events
     */
    getUpcomingEvents(limit?: number): Promise<CalendarEvent[]>;
    /**
     * Validate event
     */
    validateEvent(input: CreateEventInput | UpdateEventInput): Promise<EventValidationResult>;
    /**
     * Get the events object for external access
     */
    getEvents(): {
        eventCreated: EventEmitter<CalendarEvent>;
        eventUpdated: EventEmitter<{
            event: CalendarEvent;
            oldEvent: CalendarEvent;
        }>;
        eventDeleted: EventEmitter<{
            eventId: string;
            event: CalendarEvent;
        }>;
        eventsLoaded: EventEmitter<CalendarEvent[]>;
        filterChanged: EventEmitter<EventFilter>;
        sortChanged: EventEmitter<EventSort>;
        searchPerformed: EventEmitter<{
            query: string;
            results: CalendarEvent[];
        }>;
        eventSelected: EventEmitter<CalendarEvent>;
        eventDeselected: EventEmitter<void>;
        validationFailed: EventEmitter<EventValidationResult>;
        conflictDetected: EventEmitter<any>;
        conflictResolved: EventEmitter<any>;
        syncStarted: EventEmitter<{
            providerId: string;
        }>;
        syncCompleted: EventEmitter<{
            providerId: string;
            results: any;
        }>;
        syncFailed: EventEmitter<{
            providerId: string;
            error: string;
        }>;
        bulkOperationCompleted: EventEmitter<{
            operation: string;
            count: number;
        }>;
        loadingChanged: EventEmitter<boolean>;
        errorOccurred: EventEmitter<Error>;
        statisticsUpdated: EventEmitter<any>;
        recurrenceCreated: EventEmitter<CalendarEvent>;
        reminderScheduled: EventEmitter<{
            eventId: string;
            reminder: any;
        }>;
        categoryAdded: EventEmitter<string>;
        tagAdded: EventEmitter<string>;
    };
    /**
     * Check if the service is initialized
     */
    isInitialized(): boolean;
    /**
     * Get current configuration
     */
    getConfig(): EventManagerConfig;
    /**
     * Clear all events
     */
    clearAllEvents(): Promise<void>;
    bulkCreateEvents(inputs: CreateEventInput[]): Promise<CalendarEvent[]>;
    bulkUpdateEvents(inputs: UpdateEventInput[]): Promise<CalendarEvent[]>;
    bulkDeleteEvents(ids: string[]): Promise<void>;
    getEventsForDateRange(start: Date, end: Date): Promise<CalendarEvent[]>;
    getEventsForDate(date: Date): Promise<CalendarEvent[]>;
    getOverdueEvents(): Promise<CalendarEvent[]>;
    getStatistics(dateRange?: {
        start: Date;
        end: Date;
    }): Promise<any>;
    importEvents(events: CalendarEvent[], options?: {
        merge?: boolean;
        skipDuplicates?: boolean;
    }): Promise<{
        imported: number;
        skipped: number;
        errors: string[];
    }>;
    exportEvents(filter?: EventFilter, format?: 'json' | 'ics' | 'csv'): Promise<{
        data: string;
        filename: string;
        mimeType: string;
    }>;
    getEventConflicts(_eventId: string): Promise<any[]>;
    resolveEventConflict(_conflictId: string, resolution: any): Promise<void>;
    onEventCreated(callback: (event: CalendarEvent) => void): () => void;
    onEventUpdated(callback: (event: CalendarEvent, oldEvent: CalendarEvent) => void): () => void;
    onEventDeleted(callback: (eventId: string) => void): () => void;
    onValidationFailed(callback: (result: EventValidationResult) => void): () => void;
    onError(callback: (error: Error) => void): () => void;
    getStatus(): {
        initialized: boolean;
        totalEvents: number;
        lastSyncTime?: Date;
        errors: string[];
        health: 'good' | 'warning' | 'error';
    };
    backup(): Promise<string>;
    restore(backupData: string): Promise<void>;
    initializeEvents(): {
        eventCreated: EventEmitter<CalendarEvent>;
        eventUpdated: EventEmitter<{
            event: CalendarEvent;
            oldEvent: CalendarEvent;
        }>;
        eventDeleted: EventEmitter<{
            eventId: string;
            event: CalendarEvent;
        }>;
        validationFailed: EventEmitter<EventValidationResult>;
        errorOccurred: EventEmitter<Error>;
        bulkOperationCompleted: EventEmitter<{
            operation: string;
            count: number;
        }>;
    };
}