@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 { CheckAllPermissionsResult, RequestAllPermissionsResult } from "./sub-definitions/calendar-access";
import { PermissionState, WebPlugin } from "@capacitor/core";
import type { Calendar } from "./schemas/interfaces/calendar";
import type { CalendarEvent } from "./schemas/interfaces/calendar-event";
import { CalendarPermissionScope } from "./schemas/enums/calendar-permission-scope";
import type { CalendarSource } from "./schemas/interfaces/calendar-source";
import type { CapacitorCalendarPlugin } from "./definitions";
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 { DeleteEventsByIdResult } from "./sub-definitions/event-operations";
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 { DeleteRemindersByIdResult } from "./sub-definitions/reminders-operations";
import type { EventEditAction } from "./schemas/types/event-edit-action";
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";
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;
}