import { EventEmitter } from "events";
import { EKCalendar } from "./EKCalendar";
import { EKSource } from "./EKSource";
import { EKEntityType } from "./EKEntityType";
import { EKAuthorizationStatus } from "./EKAuthorizationStatus";
import { EKSpan } from "./EKSpan";
import { EKEvent } from "./EKEvent";
import { EKReminder } from "./EKReminder";
import { NSPredicate } from "./NSPredicate";
export type EKEventStoreEvents = {
    change: [];
};
export declare class EKEventStore extends EventEmitter {
    __brand: string;
    private _changeSubscriptionId;
    on(event: "change", listener: () => void): this;
    off(event: "change", listener: () => void): this;
    removeAllListeners(event?: string | symbol): this;
    static init(): EKEventStore;
    static init(sources: EKSource[]): EKEventStore;
    requestWriteOnlyAccessToEvents(): Promise<boolean>;
    requestFullAccessToEvents(): Promise<boolean>;
    requestFullAccessToReminders(): Promise<boolean>;
    authorizationStatus(forEntityType: EKEntityType): EKAuthorizationStatus;
    static authorizationStatus(forEntityType: EKEntityType): EKAuthorizationStatus;
    source(withIdentifier: string): EKSource | null;
    commit(): void;
    reset(): void;
    refreshSourcesIfNecessary(): void;
    defaultCalendarForNewReminders(): EKCalendar;
    calendars(forEntityType: EKEntityType): EKCalendar[];
    calendar(withIdentifier: string): EKCalendar | null;
    saveCalendar(calendar: EKCalendar, commit: boolean): void;
    removeCalendar(calendar: EKCalendar, commit: boolean): void;
    event(withIdentifier: String): EKEvent | null;
    calendarItem(withIdentifier: string): EKEvent | EKReminder | null;
    calendarItems(withExternalIdentifier: string): (EKEvent | EKReminder)[];
    save(event: EKEvent, span: EKSpan, commit?: boolean): void;
    save(reminder: EKReminder, commit: boolean): void;
    remove(event: EKEvent, span: EKSpan, commit?: boolean): void;
    remove(reminder: EKReminder, commit: boolean): void;
    enumerateEvents(matching: NSPredicate, block: (event: EKEvent) => void): Promise<void>;
    eventsMatchingPredicate(matching: NSPredicate): EKEvent[];
    eventsMatchingPredicateAsync(matching: NSPredicate, options?: {
        signal?: AbortSignal;
    }): Promise<EKEvent[]>;
    fetchReminders(matching: NSPredicate, options?: {
        signal?: AbortSignal;
    }): Promise<EKReminder[]>;
    cancelFetchRequest(fetchIdentifier: any): void;
    predicateForEvents(startDate: Date, endDate: Date, calendars: EKCalendar[]): NSPredicate;
    predicateForReminders(inCalendars: EKCalendar[] | null): NSPredicate;
    predicateForCompletedReminders(startDate: Date | null, endDate: Date | null, calendars: EKCalendar[] | null): NSPredicate;
    predicateForIncompleteReminders(startDate: Date | null, endDate: Date | null, calendars: EKCalendar[] | null): NSPredicate;
    get eventStoreIdentifier(): string;
    get defaultCalendarForNewEvents(): EKCalendar;
    get sources(): EKSource[];
    get delegateSources(): EKSource[];
}
//# sourceMappingURL=EKEventStore.d.ts.map