@ebarooni/capacitor-calendar/dist/esm/web.d.ts

A capacitor plugin for managing calendar events on iOS and Android, with reminders support on iOS.

import type { PermissionState } from '@capacitor/core';
import { WebPlugin } from '@capacitor/core';
import type { CapacitorCalendarPlugin } from './definitions';
import type { CalendarPermissionScope } from './schemas/enums/calendar-permission-scope';
import type { Calendar } from './schemas/interfaces/calendar';
import type { CalendarEvent } from './schemas/interfaces/calendar-event';
import type { CalendarSource } from './schemas/interfaces/calendar-source';
import type { CreateCalendarOptions } from './schemas/interfaces/create-calendar-options';
import type { CreateEventOptions } from './schemas/interfaces/create-event-options';
import type { CreateEventWithPromptOptions } from './schemas/interfaces/create-event-with-prompt-options';
import type { CreateReminderOptions } from './schemas/interfaces/create-reminder-options';
import type { DeleteCalendarOptions } from './schemas/interfaces/delete-calendar-options';
import type { DeleteEventOptions } from './schemas/interfaces/delete-event-options';
import type { DeleteEventWithPromptOptions } from './schemas/interfaces/delete-event-with-prompt-options';
import type { DeleteEventsByIdOptions } from './schemas/interfaces/delete-events-by-id-options';
import type { DeleteReminderOptions } from './schemas/interfaces/delete-reminder-options';
import type { DeleteReminderWithPromptOptions } from './schemas/interfaces/delete-reminder-with-prompt-options';
import type { DeleteRemindersByIdOptions } from './schemas/interfaces/delete-reminders-by-id-options';
import type { GetReminderByIdOptions } from './schemas/interfaces/get-reminder-by-id-options';
import type { GetRemindersFromListsOptions } from './schemas/interfaces/get-reminders-from-lists-options';
import type { ListEventsInRangeOptions } from './schemas/interfaces/list-events-in-range-options';
import type { ModifyCalendarOptions } from './schemas/interfaces/modify-calendar-options';
import type { ModifyEventOptions } from './schemas/interfaces/modify-event-options';
import type { ModifyEventWithPromptOptions } from './schemas/interfaces/modify-event-with-prompt-options';
import type { ModifyReminderOptions } from './schemas/interfaces/modify-reminder-options';
import type { OpenCalendarOptions } from './schemas/interfaces/open-calendar-options';
import type { Reminder } from './schemas/interfaces/reminder';
import type { RemindersList } from './schemas/interfaces/reminders-list';
import type { SelectCalendarsWithPromptOptions } from './schemas/interfaces/select-calendars-with-prompt-options';
import type { EventEditAction } from './schemas/types/event-edit-action';
import type { CheckAllPermissionsResult, RequestAllPermissionsResult } from './sub-definitions/calendar-access';
import type { DeleteEventsByIdResult } from './sub-definitions/event-operations';
import type { DeleteRemindersByIdResult } from './sub-definitions/reminders-operations';
export declare class CapacitorCalendarWeb extends WebPlugin implements CapacitorCalendarPlugin {
    checkPermission(_options: {
        scope: CalendarPermissionScope;
    }): Promise<{
        result: PermissionState;
    }>;
    checkAllPermissions(): Promise<{
        result: CheckAllPermissionsResult;
    }>;
    requestPermission(_options: {
        scope: CalendarPermissionScope;
    }): Promise<{
        result: PermissionState;
    }>;
    requestAllPermissions(): Promise<{
        result: RequestAllPermissionsResult;
    }>;
    requestWriteOnlyCalendarAccess(): Promise<{
        result: PermissionState;
    }>;
    requestReadOnlyCalendarAccess(): Promise<{
        result: PermissionState;
    }>;
    requestFullCalendarAccess(): Promise<{
        result: PermissionState;
    }>;
    requestFullRemindersAccess(): Promise<{
        result: PermissionState;
    }>;
    createEventWithPrompt(_options: CreateEventWithPromptOptions): Promise<{
        id: string | null;
    }>;
    modifyEventWithPrompt(_options: ModifyEventWithPromptOptions): Promise<{
        result: EventEditAction | null;
    }>;
    createEvent(_options: CreateEventOptions): Promise<{
        id: string;
    }>;
    commit(): Promise<void>;
    modifyEvent(_options: ModifyEventOptions): Promise<void>;
    selectCalendarsWithPrompt(_options?: SelectCalendarsWithPromptOptions): Promise<{
        result: Calendar[];
    }>;
    fetchAllCalendarSources(): Promise<{
        result: CalendarSource[];
    }>;
    listCalendars(): Promise<{
        result: Calendar[];
    }>;
    fetchAllRemindersSources(): Promise<{
        result: CalendarSource[];
    }>;
    getDefaultCalendar(): Promise<{
        result: Calendar | null;
    }>;
    getDefaultRemindersList(): Promise<{
        result: RemindersList | null;
    }>;
    openReminders(): Promise<void>;
    getRemindersLists(): Promise<{
        result: RemindersList[];
    }>;
    openCalendar(_options: OpenCalendarOptions): Promise<void>;
    createCalendar(_options: CreateCalendarOptions): Promise<{
        id: string;
    }>;
    deleteCalendar(_options: DeleteCalendarOptions): Promise<void>;
    createReminder(_options: CreateReminderOptions): Promise<{
        id: string;
    }>;
    deleteRemindersById(_options: DeleteRemindersByIdOptions): Promise<{
        result: DeleteRemindersByIdResult;
    }>;
    deleteReminder(_options: DeleteReminderOptions): Promise<void>;
    modifyReminder(_options: ModifyReminderOptions): Promise<void>;
    getReminderById(_options: GetReminderByIdOptions): Promise<{
        result: Reminder | null;
    }>;
    getRemindersFromLists(_options: GetRemindersFromListsOptions): Promise<{
        result: Reminder[];
    }>;
    deleteEventsById(_options: DeleteEventsByIdOptions): Promise<{
        result: DeleteEventsByIdResult;
    }>;
    deleteEvent(_options: DeleteEventOptions): Promise<void>;
    deleteEventWithPrompt(_options: DeleteEventWithPromptOptions): Promise<{
        deleted: boolean;
    }>;
    listEventsInRange(_options: ListEventsInRangeOptions): Promise<{
        result: CalendarEvent[];
    }>;
    modifyCalendar(_options: ModifyCalendarOptions): Promise<void>;
    deleteReminderWithPrompt(_options: DeleteReminderWithPromptOptions): Promise<{
        deleted: boolean;
    }>;
    private throwUnimplemented;
}