@symbiote-native/calendar 0.1.0

package/build/core/enums.d.ts

@@ -0,0 +1,141 @@
+export declare enum EntityTypes {
+    EVENT = "event",
+    REMINDER = "reminder"
+}
+export declare enum Frequency {
+    DAILY = "daily",
+    WEEKLY = "weekly",
+    MONTHLY = "monthly",
+    YEARLY = "yearly"
+}
+/** `NOT_SUPPORTED`/`UNAVAILABLE` are iOS-only. */
+export declare enum Availability {
+    NOT_SUPPORTED = "notSupported",
+    BUSY = "busy",
+    FREE = "free",
+    TENTATIVE = "tentative",
+    UNAVAILABLE = "unavailable"
+}
+/** @platform ios */
+export declare enum CalendarType {
+    LOCAL = "local",
+    CALDAV = "caldav",
+    EXCHANGE = "exchange",
+    SUBSCRIBED = "subscribed",
+    BIRTHDAYS = "birthdays",
+    UNKNOWN = "unknown"
+}
+export declare enum EventStatus {
+    NONE = "none",
+    CONFIRMED = "confirmed",
+    TENTATIVE = "tentative",
+    CANCELED = "canceled"
+}
+/** @platform ios */
+export declare enum SourceType {
+    LOCAL = "local",
+    EXCHANGE = "exchange",
+    CALDAV = "caldav",
+    MOBILEME = "mobileme",
+    SUBSCRIBED = "subscribed",
+    BIRTHDAYS = "birthdays"
+}
+/** iOS: UNKNOWN/REQUIRED/OPTIONAL/CHAIR/NON_PARTICIPANT. Android: the rest. */
+export declare enum AttendeeRole {
+    UNKNOWN = "unknown",
+    REQUIRED = "required",
+    OPTIONAL = "optional",
+    CHAIR = "chair",
+    NON_PARTICIPANT = "nonParticipant",
+    ATTENDEE = "attendee",
+    ORGANIZER = "organizer",
+    PERFORMER = "performer",
+    SPEAKER = "speaker",
+    NONE = "none"
+}
+/** iOS: UNKNOWN/PENDING/DELEGATED/COMPLETED/IN_PROCESS. Android: INVITED/NONE. */
+export declare enum AttendeeStatus {
+    UNKNOWN = "unknown",
+    PENDING = "pending",
+    ACCEPTED = "accepted",
+    DECLINED = "declined",
+    TENTATIVE = "tentative",
+    DELEGATED = "delegated",
+    COMPLETED = "completed",
+    IN_PROCESS = "inProcess",
+    INVITED = "invited",
+    NONE = "none"
+}
+/** iOS: UNKNOWN/PERSON/ROOM/GROUP. Android: OPTIONAL/REQUIRED/NONE. Both: RESOURCE. */
+export declare enum AttendeeType {
+    UNKNOWN = "unknown",
+    PERSON = "person",
+    ROOM = "room",
+    GROUP = "group",
+    RESOURCE = "resource",
+    OPTIONAL = "optional",
+    REQUIRED = "required",
+    NONE = "none"
+}
+/** @platform android */
+export declare enum AlarmMethod {
+    ALARM = "alarm",
+    ALERT = "alert",
+    EMAIL = "email",
+    SMS = "sms",
+    DEFAULT = "default"
+}
+/** @platform android */
+export declare enum EventAccessLevel {
+    CONFIDENTIAL = "confidential",
+    PRIVATE = "private",
+    PUBLIC = "public",
+    DEFAULT = "default"
+}
+/** @platform android */
+export declare enum CalendarAccessLevel {
+    CONTRIBUTOR = "contributor",
+    EDITOR = "editor",
+    FREEBUSY = "freebusy",
+    OVERRIDE = "override",
+    OWNER = "owner",
+    READ = "read",
+    RESPOND = "respond",
+    ROOT = "root",
+    NONE = "none"
+}
+/** @platform ios */
+export declare enum ReminderStatus {
+    COMPLETED = "completed",
+    INCOMPLETE = "incomplete"
+}
+export declare enum DayOfTheWeek {
+    Sunday = 1,
+    Monday = 2,
+    Tuesday = 3,
+    Wednesday = 4,
+    Thursday = 5,
+    Friday = 6,
+    Saturday = 7
+}
+export declare enum MonthOfTheYear {
+    January = 1,
+    February = 2,
+    March = 3,
+    April = 4,
+    May = 5,
+    June = 6,
+    July = 7,
+    August = 8,
+    September = 9,
+    October = 10,
+    November = 11,
+    December = 12
+}
+export declare enum CalendarDialogResultActions {
+    done = "done",
+    canceled = "canceled",
+    deleted = "deleted",
+    responded = "responded",
+    saved = "saved"
+}

package/build/core/enums.js

@@ -0,0 +1,157 @@
+export var EntityTypes;
+(function (EntityTypes) {
+    EntityTypes["EVENT"] = "event";
+    EntityTypes["REMINDER"] = "reminder";
+})(EntityTypes || (EntityTypes = {}));
+export var Frequency;
+(function (Frequency) {
+    Frequency["DAILY"] = "daily";
+    Frequency["WEEKLY"] = "weekly";
+    Frequency["MONTHLY"] = "monthly";
+    Frequency["YEARLY"] = "yearly";
+})(Frequency || (Frequency = {}));
+/** `NOT_SUPPORTED`/`UNAVAILABLE` are iOS-only. */
+export var Availability;
+(function (Availability) {
+    Availability["NOT_SUPPORTED"] = "notSupported";
+    Availability["BUSY"] = "busy";
+    Availability["FREE"] = "free";
+    Availability["TENTATIVE"] = "tentative";
+    Availability["UNAVAILABLE"] = "unavailable";
+})(Availability || (Availability = {}));
+/** @platform ios */
+export var CalendarType;
+(function (CalendarType) {
+    CalendarType["LOCAL"] = "local";
+    CalendarType["CALDAV"] = "caldav";
+    CalendarType["EXCHANGE"] = "exchange";
+    CalendarType["SUBSCRIBED"] = "subscribed";
+    CalendarType["BIRTHDAYS"] = "birthdays";
+    CalendarType["UNKNOWN"] = "unknown";
+})(CalendarType || (CalendarType = {}));
+export var EventStatus;
+(function (EventStatus) {
+    EventStatus["NONE"] = "none";
+    EventStatus["CONFIRMED"] = "confirmed";
+    EventStatus["TENTATIVE"] = "tentative";
+    EventStatus["CANCELED"] = "canceled";
+})(EventStatus || (EventStatus = {}));
+/** @platform ios */
+export var SourceType;
+(function (SourceType) {
+    SourceType["LOCAL"] = "local";
+    SourceType["EXCHANGE"] = "exchange";
+    SourceType["CALDAV"] = "caldav";
+    SourceType["MOBILEME"] = "mobileme";
+    SourceType["SUBSCRIBED"] = "subscribed";
+    SourceType["BIRTHDAYS"] = "birthdays";
+})(SourceType || (SourceType = {}));
+/** iOS: UNKNOWN/REQUIRED/OPTIONAL/CHAIR/NON_PARTICIPANT. Android: the rest. */
+export var AttendeeRole;
+(function (AttendeeRole) {
+    AttendeeRole["UNKNOWN"] = "unknown";
+    AttendeeRole["REQUIRED"] = "required";
+    AttendeeRole["OPTIONAL"] = "optional";
+    AttendeeRole["CHAIR"] = "chair";
+    AttendeeRole["NON_PARTICIPANT"] = "nonParticipant";
+    AttendeeRole["ATTENDEE"] = "attendee";
+    AttendeeRole["ORGANIZER"] = "organizer";
+    AttendeeRole["PERFORMER"] = "performer";
+    AttendeeRole["SPEAKER"] = "speaker";
+    AttendeeRole["NONE"] = "none";
+})(AttendeeRole || (AttendeeRole = {}));
+/** iOS: UNKNOWN/PENDING/DELEGATED/COMPLETED/IN_PROCESS. Android: INVITED/NONE. */
+export var AttendeeStatus;
+(function (AttendeeStatus) {
+    AttendeeStatus["UNKNOWN"] = "unknown";
+    AttendeeStatus["PENDING"] = "pending";
+    AttendeeStatus["ACCEPTED"] = "accepted";
+    AttendeeStatus["DECLINED"] = "declined";
+    AttendeeStatus["TENTATIVE"] = "tentative";
+    AttendeeStatus["DELEGATED"] = "delegated";
+    AttendeeStatus["COMPLETED"] = "completed";
+    AttendeeStatus["IN_PROCESS"] = "inProcess";
+    AttendeeStatus["INVITED"] = "invited";
+    AttendeeStatus["NONE"] = "none";
+})(AttendeeStatus || (AttendeeStatus = {}));
+/** iOS: UNKNOWN/PERSON/ROOM/GROUP. Android: OPTIONAL/REQUIRED/NONE. Both: RESOURCE. */
+export var AttendeeType;
+(function (AttendeeType) {
+    AttendeeType["UNKNOWN"] = "unknown";
+    AttendeeType["PERSON"] = "person";
+    AttendeeType["ROOM"] = "room";
+    AttendeeType["GROUP"] = "group";
+    AttendeeType["RESOURCE"] = "resource";
+    AttendeeType["OPTIONAL"] = "optional";
+    AttendeeType["REQUIRED"] = "required";
+    AttendeeType["NONE"] = "none";
+})(AttendeeType || (AttendeeType = {}));
+/** @platform android */
+export var AlarmMethod;
+(function (AlarmMethod) {
+    AlarmMethod["ALARM"] = "alarm";
+    AlarmMethod["ALERT"] = "alert";
+    AlarmMethod["EMAIL"] = "email";
+    AlarmMethod["SMS"] = "sms";
+    AlarmMethod["DEFAULT"] = "default";
+})(AlarmMethod || (AlarmMethod = {}));
+/** @platform android */
+export var EventAccessLevel;
+(function (EventAccessLevel) {
+    EventAccessLevel["CONFIDENTIAL"] = "confidential";
+    EventAccessLevel["PRIVATE"] = "private";
+    EventAccessLevel["PUBLIC"] = "public";
+    EventAccessLevel["DEFAULT"] = "default";
+})(EventAccessLevel || (EventAccessLevel = {}));
+/** @platform android */
+export var CalendarAccessLevel;
+(function (CalendarAccessLevel) {
+    CalendarAccessLevel["CONTRIBUTOR"] = "contributor";
+    CalendarAccessLevel["EDITOR"] = "editor";
+    CalendarAccessLevel["FREEBUSY"] = "freebusy";
+    CalendarAccessLevel["OVERRIDE"] = "override";
+    CalendarAccessLevel["OWNER"] = "owner";
+    CalendarAccessLevel["READ"] = "read";
+    CalendarAccessLevel["RESPOND"] = "respond";
+    CalendarAccessLevel["ROOT"] = "root";
+    CalendarAccessLevel["NONE"] = "none";
+})(CalendarAccessLevel || (CalendarAccessLevel = {}));
+/** @platform ios */
+export var ReminderStatus;
+(function (ReminderStatus) {
+    ReminderStatus["COMPLETED"] = "completed";
+    ReminderStatus["INCOMPLETE"] = "incomplete";
+})(ReminderStatus || (ReminderStatus = {}));
+export var DayOfTheWeek;
+(function (DayOfTheWeek) {
+    DayOfTheWeek[DayOfTheWeek["Sunday"] = 1] = "Sunday";
+    DayOfTheWeek[DayOfTheWeek["Monday"] = 2] = "Monday";
+    DayOfTheWeek[DayOfTheWeek["Tuesday"] = 3] = "Tuesday";
+    DayOfTheWeek[DayOfTheWeek["Wednesday"] = 4] = "Wednesday";
+    DayOfTheWeek[DayOfTheWeek["Thursday"] = 5] = "Thursday";
+    DayOfTheWeek[DayOfTheWeek["Friday"] = 6] = "Friday";
+    DayOfTheWeek[DayOfTheWeek["Saturday"] = 7] = "Saturday";
+})(DayOfTheWeek || (DayOfTheWeek = {}));
+export var MonthOfTheYear;
+(function (MonthOfTheYear) {
+    MonthOfTheYear[MonthOfTheYear["January"] = 1] = "January";
+    MonthOfTheYear[MonthOfTheYear["February"] = 2] = "February";
+    MonthOfTheYear[MonthOfTheYear["March"] = 3] = "March";
+    MonthOfTheYear[MonthOfTheYear["April"] = 4] = "April";
+    MonthOfTheYear[MonthOfTheYear["May"] = 5] = "May";
+    MonthOfTheYear[MonthOfTheYear["June"] = 6] = "June";
+    MonthOfTheYear[MonthOfTheYear["July"] = 7] = "July";
+    MonthOfTheYear[MonthOfTheYear["August"] = 8] = "August";
+    MonthOfTheYear[MonthOfTheYear["September"] = 9] = "September";
+    MonthOfTheYear[MonthOfTheYear["October"] = 10] = "October";
+    MonthOfTheYear[MonthOfTheYear["November"] = 11] = "November";
+    MonthOfTheYear[MonthOfTheYear["December"] = 12] = "December";
+})(MonthOfTheYear || (MonthOfTheYear = {}));
+export var CalendarDialogResultActions;
+(function (CalendarDialogResultActions) {
+    CalendarDialogResultActions["done"] = "done";
+    CalendarDialogResultActions["canceled"] = "canceled";
+    CalendarDialogResultActions["deleted"] = "deleted";
+    CalendarDialogResultActions["responded"] = "responded";
+    CalendarDialogResultActions["saved"] = "saved";
+})(CalendarDialogResultActions || (CalendarDialogResultActions = {}));

package/build/core/event.d.ts

@@ -0,0 +1,14 @@
+import { expoCalendarNext } from './native-module';
+import type { NativeExpoCalendarEvent } from './native-module';
+import type { IAttendeeInput, IEventPatch, IRecurringEventOptions } from './types';
+import { ExpoCalendarAttendee } from './attendee';
+export declare class ExpoCalendarEvent extends expoCalendarNext.ExpoCalendarEvent {
+    getOccurrenceSync(options?: IRecurringEventOptions): ExpoCalendarEvent;
+    getAttendees(): Promise<ExpoCalendarAttendee[]>;
+    /** @platform android */
+    createAttendee(attendee: IAttendeeInput): Promise<ExpoCalendarAttendee>;
+    update(details: IEventPatch): Promise<void>;
+    delete(): Promise<void>;
+    static get(eventId: string): Promise<ExpoCalendarEvent>;
+}
+export declare function upgradeToExpoCalendarEvent(native: NativeExpoCalendarEvent): ExpoCalendarEvent;

package/build/core/event.js

@@ -0,0 +1,40 @@
+import { UnavailabilityError } from 'expo-modules-core';
+import { expoCalendarNext } from './native-module.js';
+import { getNullableDetailsFields, stringifyDateValues } from './utils.js';
+import { ExpoCalendarAttendee, upgradeToExpoCalendarAttendee, } from './attendee.js';
+export class ExpoCalendarEvent extends expoCalendarNext.ExpoCalendarEvent {
+    getOccurrenceSync(options = {}) {
+        const occurrence = super.getOccurrenceSync(stringifyDateValues(options));
+        return upgradeToExpoCalendarEvent(occurrence);
+    }
+    async getAttendees() {
+        const attendees = await super.getAttendees();
+        return attendees.map(upgradeToExpoCalendarAttendee);
+    }
+    /** @platform android */
+    async createAttendee(attendee) {
+        if (!super.createAttendee) {
+            throw new UnavailabilityError('ExpoCalendarEvent', 'createAttendee');
+        }
+        return upgradeToExpoCalendarAttendee(await super.createAttendee(attendee));
+    }
+    async update(details) {
+        return super.update(stringifyDateValues(details), getNullableDetailsFields(details));
+    }
+    async delete() {
+        return super.delete();
+    }
+    static async get(eventId) {
+        return upgradeToExpoCalendarEvent(await expoCalendarNext.getEventById(eventId));
+    }
+}
+function isExpoCalendarEvent(value) {
+    return value instanceof ExpoCalendarEvent;
+}
+export function upgradeToExpoCalendarEvent(native) {
+    Object.setPrototypeOf(native, ExpoCalendarEvent.prototype);
+    if (!isExpoCalendarEvent(native)) {
+        throw new Error('unreachable - just reassigned the prototype to ExpoCalendarEvent');
+    }
+    return native;
+}

package/build/core/index.d.ts

@@ -0,0 +1,6 @@
+export * from './enums';
+export * from './types';
+export { ExpoCalendarEvent } from './event';
+export { ExpoCalendarAttendee } from './attendee';
+export { ExpoCalendarReminder } from './reminder';
+export { ExpoCalendar, getDefaultCalendarSync, getCalendars, createCalendar, presentPicker, listEvents, requestCalendarPermissions, getCalendarPermissions, requestRemindersPermissions, getRemindersPermissions, getSourcesSync, } from './calendar';

package/build/core/index.js

@@ -0,0 +1,6 @@
+export * from './enums.js';
+export * from './types.js';
+export { ExpoCalendarEvent } from './event.js';
+export { ExpoCalendarAttendee } from './attendee.js';
+export { ExpoCalendarReminder } from './reminder.js';
+export { ExpoCalendar, getDefaultCalendarSync, getCalendars, createCalendar, presentPicker, listEvents, requestCalendarPermissions, getCalendarPermissions, requestRemindersPermissions, getRemindersPermissions, getSourcesSync, } from './calendar.js';

package/build/core/native-module.d.ts

@@ -0,0 +1,154 @@
+import type { PermissionResponse } from 'expo-modules-core';
+import type { IDialogEventResult, IOpenEventPresentationOptions, IPresentationOptions, IRecurringEventOptions, ISource } from './types';
+export declare class NativeExpoCalendar {
+    readonly id: string;
+    readonly title: string;
+    /** @platform android */
+    readonly name?: string | null;
+    readonly source?: ISource;
+    /** @platform ios */
+    readonly sourceId?: string;
+    /** @platform ios */
+    readonly type?: string;
+    readonly color?: string;
+    /** @platform ios */
+    readonly entityType?: string;
+    readonly allowsModifications: boolean;
+    readonly allowedAvailabilities: string[];
+    /** @platform android */
+    readonly isVisible?: boolean;
+    /** @platform android */
+    readonly isSynced?: boolean;
+    /** @platform android */
+    readonly timeZone?: string;
+    /** @platform android */
+    readonly isPrimary?: boolean;
+    /** @platform android */
+    readonly allowedReminders?: string[];
+    /** @platform android */
+    readonly allowedAttendeeTypes?: string[];
+    /** @platform android */
+    readonly ownerAccount?: string;
+    /** @platform android */
+    readonly accessLevel?: string;
+    listEvents(startDate: string | Date, endDate: string | Date): Promise<NativeExpoCalendarEvent[]>;
+    /** @platform ios - typed as always-present, guarded at runtime. */
+    listReminders(startDate: string | Date | null, endDate: string | Date | null, status: string | null): Promise<NativeExpoCalendarReminder[]>;
+    createEvent(record: Record<string, unknown>): Promise<NativeExpoCalendarEvent>;
+    /** @platform ios - typed as always-present, guarded at runtime. */
+    createReminder(record: Record<string, unknown>): Promise<NativeExpoCalendarReminder>;
+    addEventWithForm(options?: Record<string, unknown>): Promise<IDialogEventResult>;
+    update(patch: Record<string, unknown>): Promise<void>;
+    delete(): Promise<void>;
+}
+export declare class NativeExpoCalendarEvent {
+    readonly id: string;
+    readonly calendarId?: string;
+    readonly title?: string;
+    readonly location?: string;
+    /** @platform ios */
+    readonly creationDate?: string;
+    /** @platform ios */
+    readonly lastModifiedDate?: string;
+    readonly timeZone?: string;
+    /** @platform android */
+    readonly endTimeZone?: string;
+    /** @platform ios */
+    readonly url?: string;
+    readonly notes?: string;
+    readonly alarms?: unknown[];
+    readonly recurrenceRule?: Record<string, unknown> | null;
+    readonly startDate?: string;
+    readonly endDate?: string;
+    /** @platform ios */
+    readonly originalStartDate?: string;
+    /** @platform ios */
+    readonly isDetached?: boolean;
+    readonly allDay: boolean;
+    readonly availability?: string;
+    readonly status?: string;
+    /** @platform ios */
+    readonly organizer?: Record<string, unknown>;
+    /** @platform android */
+    readonly organizerEmail?: string;
+    /** @platform android */
+    readonly accessLevel?: string;
+    /** @platform android */
+    readonly guestsCanModify?: boolean;
+    /** @platform android */
+    readonly guestsCanInviteOthers?: boolean;
+    /** @platform android */
+    readonly guestsCanSeeGuests?: boolean;
+    /** @platform android */
+    readonly originalId?: string;
+    /** @platform android */
+    readonly instanceId?: string;
+    /** @platform android - typed as always-present, guarded at runtime. */
+    createAttendee(record: Record<string, unknown>): Promise<NativeExpoCalendarAttendee>;
+    openInCalendar(options?: IOpenEventPresentationOptions | null): Promise<IDialogEventResult>;
+    editInCalendar(options?: IPresentationOptions | null): Promise<IDialogEventResult>;
+    getOccurrenceSync(options?: IRecurringEventOptions): NativeExpoCalendarEvent;
+    getAttendees(): Promise<NativeExpoCalendarAttendee[]>;
+    update(patch: Record<string, unknown>, nullableFields: string[]): Promise<void>;
+    delete(): Promise<void>;
+}
+/** @platform android - iOS registers this class with no properties or methods. */
+export declare class NativeExpoCalendarAttendee {
+    constructor(record: Record<string, unknown>);
+    readonly id?: string;
+    readonly name?: string;
+    readonly role?: string;
+    readonly status?: string;
+    readonly type?: string;
+    readonly email?: string;
+    update(patch: Record<string, unknown>, nullableFields: string[]): Promise<void>;
+    delete(): Promise<void>;
+}
+/** @platform ios - Android registers this class with no properties or methods. */
+export declare class NativeExpoCalendarReminder {
+    constructor(id: string);
+    readonly id?: string;
+    readonly calendarId?: string;
+    readonly title?: string;
+    readonly location?: string;
+    readonly creationDate?: string;
+    readonly lastModifiedDate?: string;
+    readonly timeZone?: string;
+    readonly url?: string;
+    readonly notes?: string;
+    readonly alarms?: unknown[];
+    readonly recurrenceRule?: Record<string, unknown> | null;
+    readonly allDay: boolean;
+    readonly startDate?: string;
+    readonly dueDate?: string;
+    readonly completed: boolean;
+    readonly completionDate?: string;
+    update(patch: Record<string, unknown>, nullableFields: string[]): Promise<void>;
+    delete(): Promise<void>;
+}
+export type INativeCalendarNextModule = {
+    ExpoCalendar: typeof NativeExpoCalendar;
+    ExpoCalendarEvent: typeof NativeExpoCalendarEvent;
+    ExpoCalendarAttendee: typeof NativeExpoCalendarAttendee;
+    ExpoCalendarReminder: typeof NativeExpoCalendarReminder;
+    getCalendars(type: string | null): Promise<NativeExpoCalendar[]>;
+    getCalendarById(id: string): Promise<NativeExpoCalendar>;
+    createCalendar(record: Record<string, unknown>): Promise<NativeExpoCalendar>;
+    listEvents(calendarIds: string[], startDate: string, endDate: string): Promise<NativeExpoCalendarEvent[]>;
+    getEventById(id: string): Promise<NativeExpoCalendarEvent>;
+    getCalendarPermissions(writeOnly?: boolean): Promise<PermissionResponse>;
+    requestCalendarPermissions(writeOnly?: boolean): Promise<PermissionResponse>;
+    /** @platform ios */
+    getDefaultCalendarSync?(): NativeExpoCalendar;
+    /** @platform ios */
+    presentPicker?(): Promise<NativeExpoCalendar | null>;
+    /** @platform ios */
+    getReminderById?(id: string): Promise<NativeExpoCalendarReminder>;
+    /** @platform ios */
+    getRemindersPermissions?(): Promise<PermissionResponse>;
+    /** @platform ios */
+    requestRemindersPermissions?(): Promise<PermissionResponse>;
+    /** @platform ios */
+    getSourcesSync?(): ISource[];
+};
+export declare const expoCalendarNext: INativeCalendarNextModule;

package/build/core/native-module.js

@@ -0,0 +1,3 @@
+import { requireNativeModule } from 'expo-modules-core';
+const EXPO_CALENDAR_NEXT_MODULE_NAME = 'CalendarNext';
+export const expoCalendarNext = requireNativeModule(EXPO_CALENDAR_NEXT_MODULE_NAME);

package/build/core/reminder.d.ts

@@ -0,0 +1,10 @@
+import { expoCalendarNext } from './native-module';
+import type { NativeExpoCalendarReminder } from './native-module';
+import type { IReminderPatch } from './types';
+/** @platform ios - Android registers this class with no properties or methods. */
+export declare class ExpoCalendarReminder extends expoCalendarNext.ExpoCalendarReminder {
+    update(details: IReminderPatch): Promise<void>;
+    delete(): Promise<void>;
+    static get(reminderId: string): Promise<ExpoCalendarReminder>;
+}
+export declare function upgradeToExpoCalendarReminder(native: NativeExpoCalendarReminder): ExpoCalendarReminder;

package/build/core/reminder.js

@@ -0,0 +1,34 @@
+import { Platform, UnavailabilityError } from 'expo-modules-core';
+import { expoCalendarNext } from './native-module.js';
+import { getNullableDetailsFields, stringifyDateValues } from './utils.js';
+/** @platform ios - Android registers this class with no properties or methods. */
+export class ExpoCalendarReminder extends expoCalendarNext.ExpoCalendarReminder {
+    async update(details) {
+        if (Platform.OS !== 'ios') {
+            throw new UnavailabilityError('ExpoCalendarReminder', 'update');
+        }
+        return super.update(stringifyDateValues(details), getNullableDetailsFields(details));
+    }
+    async delete() {
+        if (Platform.OS !== 'ios') {
+            throw new UnavailabilityError('ExpoCalendarReminder', 'delete');
+        }
+        return super.delete();
+    }
+    static async get(reminderId) {
+        if (Platform.OS !== 'ios' || !expoCalendarNext.getReminderById) {
+            throw new UnavailabilityError('ExpoCalendarReminder', 'get');
+        }
+        return upgradeToExpoCalendarReminder(await expoCalendarNext.getReminderById(reminderId));
+    }
+}
+function isExpoCalendarReminder(value) {
+    return value instanceof ExpoCalendarReminder;
+}
+export function upgradeToExpoCalendarReminder(native) {
+    Object.setPrototypeOf(native, ExpoCalendarReminder.prototype);
+    if (!isExpoCalendarReminder(native)) {
+        throw new Error('unreachable - just reassigned the prototype to ExpoCalendarReminder');
+    }
+    return native;
+}