@symbiote-native/calendar 0.1.0

package/build/core/types.d.ts

@@ -0,0 +1,184 @@
+import type { AlarmMethod, AttendeeRole, AttendeeStatus, AttendeeType, CalendarAccessLevel, CalendarDialogResultActions, DayOfTheWeek, Frequency, MonthOfTheYear } from './enums';
+export type ISource = {
+    id?: string;
+    type?: string;
+    name?: string;
+    isLocalAccount?: boolean;
+};
+export type IDaysOfTheWeek = {
+    dayOfTheWeek: DayOfTheWeek;
+    /** `-53` to `53`; `0` ignores this field. */
+    weekNumber?: number;
+};
+export type IRecurrenceRule = {
+    frequency: Frequency;
+    /** @default 1 */
+    interval?: number;
+    endDate?: string | Date | null;
+    occurrence?: number | null;
+    /** @platform ios */
+    daysOfTheWeek?: IDaysOfTheWeek[] | null;
+    /** @platform ios */
+    daysOfTheMonth?: number[] | null;
+    /** @platform ios */
+    monthsOfTheYear?: MonthOfTheYear[] | null;
+    /** @platform ios */
+    weeksOfTheYear?: number[] | null;
+    /** @platform ios */
+    daysOfTheYear?: number[] | null;
+    /** @platform ios */
+    setPositions?: number[] | null;
+};
+export type IAlarmLocation = {
+    title?: string;
+    proximity?: string;
+    radius?: number;
+    coords?: {
+        latitude?: number;
+        longitude?: number;
+    };
+};
+export type IAlarm = {
+    /** @platform ios */
+    absoluteDate?: string;
+    relativeOffset?: number;
+    structuredLocation?: IAlarmLocation;
+    /** @platform android */
+    method?: AlarmMethod;
+};
+/** Fields for `createCalendar()` - all optional, matches upstream's `Partial<Calendar>`. */
+export type ICalendarInput = {
+    title?: string;
+    /** @platform android */
+    name?: string;
+    source?: ISource;
+    color?: string;
+    /** @platform android */
+    isVisible?: boolean;
+    /** @platform android */
+    isSynced?: boolean;
+    /** @platform android */
+    timeZone?: string;
+    /** @platform android */
+    isPrimary?: boolean;
+    allowedAvailabilities?: string[];
+    /** @platform android */
+    allowedReminders?: AlarmMethod[];
+    /** @platform android */
+    allowedAttendeeTypes?: AttendeeType[];
+    /** @platform android */
+    ownerAccount?: string;
+    /** @platform android */
+    accessLevel?: CalendarAccessLevel;
+    /** @platform ios */
+    sourceId?: string;
+};
+/** Fields for `calendar.update()`; a field set to `null` clears it natively. */
+export type ICalendarPatch = {
+    title?: string | null;
+    /** @platform android */
+    name?: string | null;
+    color?: string | null;
+    /** @platform android */
+    isVisible?: boolean | null;
+    /** @platform android */
+    isSynced?: boolean | null;
+    /** @platform android */
+    timeZone?: string | null;
+};
+/** Fields for `calendar.createEvent()` - all optional, matches upstream's `Omit<Partial<...>>`. */
+export type IEventInput = {
+    startDate?: string | Date;
+    endDate?: string | Date;
+    title?: string;
+    location?: string;
+    timeZone?: string;
+    /** @platform android */
+    endTimeZone?: string;
+    notes?: string;
+    alarms?: IAlarm[];
+    recurrenceRule?: IRecurrenceRule;
+    allDay?: boolean;
+    availability?: string;
+    /** @platform android */
+    status?: string;
+    /** @platform android */
+    organizerEmail?: string;
+    /** @platform android */
+    accessLevel?: string;
+    /** @platform android */
+    guestsCanModify?: boolean;
+    /** @platform android */
+    guestsCanInviteOthers?: boolean;
+    /** @platform android */
+    guestsCanSeeGuests?: boolean;
+};
+/** Fields for `event.update()`; a field set to `null` clears it natively. */
+export type IEventPatch = Partial<{
+    [K in keyof IEventInput]: IEventInput[K] | null;
+}>;
+/** Fields for `event.createAttendee()`. @platform android */
+export type IAttendeeInput = {
+    name: string;
+    role: AttendeeRole;
+    status: AttendeeStatus;
+    type: AttendeeType;
+    email: string;
+};
+/** Fields for `attendee.update()`. @platform android */
+export type IAttendeePatch = Partial<{
+    [K in keyof IAttendeeInput]: IAttendeeInput[K] | null;
+}>;
+/** Fields for `calendar.createReminder()`. @platform ios */
+export type IReminderInput = {
+    title?: string;
+    location?: string;
+    notes?: string;
+    startDate?: string | Date;
+    dueDate?: string | Date;
+    completionDate?: string | Date;
+    timeZone?: string;
+    alarms?: IAlarm[];
+    recurrenceRule?: IRecurrenceRule;
+    url?: string;
+    allDay?: boolean;
+    completed?: boolean;
+};
+/** Fields for `reminder.update()`; a field set to `null` clears it natively. @platform ios */
+export type IReminderPatch = Partial<{
+    [K in keyof IReminderInput]: IReminderInput[K] | null;
+}>;
+export type IRecurringEventOptions = {
+    /** Applies to `instanceStartDate` and every future occurrence when `true`. */
+    futureEvents?: boolean;
+    instanceStartDate?: string | Date;
+};
+export type IPresentationOptions = {
+    /** `true` resolves `'done'` right after opening. @default true @platform android */
+    startNewActivityTask?: boolean;
+};
+export type IOpenEventPresentationOptions = IPresentationOptions & {
+    /** @default false @platform ios */
+    allowsEditing?: boolean;
+    /** @default false @platform ios */
+    allowsCalendarPreview?: boolean;
+};
+/** Fields for `calendar.addEventWithForm()`. */
+export type IAddEventWithFormOptions = {
+    title?: string;
+    location?: string;
+    notes?: string;
+    url?: string;
+    /** @platform android */
+    timeZone?: string;
+    availability?: string;
+    allDay?: boolean;
+    startDate?: string | Date;
+    endDate?: string | Date;
+    recurrenceRule?: IRecurrenceRule;
+    alarms?: IAlarm[];
+} & IPresentationOptions;
+export type IDialogEventResult = {
+    action: CalendarDialogResultActions;
+    id?: string | null;
+};

package/build/core/types.js

@@ -0,0 +1 @@
+export {};

package/build/core/utils.d.ts

@@ -0,0 +1,7 @@
+export declare function stringifyIfDate(value: Date): string;
+export declare function stringifyIfDate(value: unknown): unknown;
+/** Recursively converts every `Date` field of `obj` to an ISO string for the native bridge. */
+export declare function stringifyDateValues(obj: Record<string, unknown>): Record<string, unknown>;
+/** `null` in a patch means "clear natively" - the native `update()` needs the field named
+ * separately, in addition to staying in the stringified record with its `null` value. */
+export declare function getNullableDetailsFields(details: Record<string, unknown>): string[];

package/build/core/utils.js

@@ -0,0 +1,29 @@
+export function stringifyIfDate(value) {
+    return value instanceof Date ? value.toISOString() : value;
+}
+function isPlainObject(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        !Array.isArray(value) &&
+        !(value instanceof Date));
+}
+function stringifyValue(value) {
+    if (Array.isArray(value))
+        return value.map(stringifyValue);
+    if (isPlainObject(value))
+        return stringifyDateValues(value);
+    return stringifyIfDate(value);
+}
+/** Recursively converts every `Date` field of `obj` to an ISO string for the native bridge. */
+export function stringifyDateValues(obj) {
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+        result[key] = stringifyValue(value);
+    }
+    return result;
+}
+/** `null` in a patch means "clear natively" - the native `update()` needs the field named
+ * separately, in addition to staying in the stringified record with its `null` value. */
+export function getNullableDetailsFields(details) {
+    return Object.keys(details).filter(key => details[key] === null);
+}

package/build/legacy/calendar.d.ts

@@ -0,0 +1,23 @@
+import type { IAttendee, ICalendar, ICalendarDialogParams, IDialogEventResult, IEvent, IOpenEventDialogResult, IOpenEventPresentationOptions, IPresentationOptions, IRecurringEventOptions, ISource } from './types';
+export declare function createEventInCalendarAsync(eventData?: Omit<Partial<IEvent>, 'id'>, presentationOptions?: IPresentationOptions): Promise<IDialogEventResult>;
+export declare function openEventInCalendarAsync(params: ICalendarDialogParams, presentationOptions?: IOpenEventPresentationOptions): Promise<IOpenEventDialogResult>;
+export declare function editEventInCalendarAsync(params: ICalendarDialogParams, presentationOptions?: IPresentationOptions): Promise<IDialogEventResult>;
+export declare function isAvailableAsync(): Promise<boolean>;
+export declare function getCalendarsAsync(entityType?: string): Promise<ICalendar[]>;
+export declare function createCalendarAsync(details?: Partial<ICalendar>): Promise<string>;
+export declare function updateCalendarAsync(id: string, details?: Partial<ICalendar>): Promise<string>;
+export declare function deleteCalendarAsync(id: string): Promise<void>;
+export declare function getEventsAsync(calendarIds: string[], startDate: Date, endDate: Date): Promise<IEvent[]>;
+export declare function getEventAsync(id: string, recurringEventOptions?: IRecurringEventOptions): Promise<IEvent>;
+export declare function createEventAsync(calendarId: string, eventData?: Omit<Partial<IEvent>, 'id' | 'organizer'>): Promise<string>;
+export declare function updateEventAsync(id: string, details?: Omit<Partial<IEvent>, 'id'>, recurringEventOptions?: IRecurringEventOptions): Promise<string>;
+export declare function deleteEventAsync(id: string, recurringEventOptions?: IRecurringEventOptions): Promise<void>;
+export declare function getAttendeesForEventAsync(id: string, recurringEventOptions?: IRecurringEventOptions): Promise<IAttendee[]>;
+export declare function createAttendeeAsync(eventId: string, details?: Partial<IAttendee>): Promise<string>;
+export declare function updateAttendeeAsync(id: string, details?: Partial<IAttendee>): Promise<string>;
+export declare function deleteAttendeeAsync(id: string): Promise<void>;
+export declare function getDefaultCalendarAsync(): Promise<ICalendar>;
+export declare function getSourcesAsync(): Promise<ISource[]>;
+export declare function getSourceAsync(id: string): Promise<ISource>;
+/** @platform android */
+export declare function openEventInCalendar(id: string): void;

package/build/legacy/calendar.js

@@ -0,0 +1,261 @@
+import { Platform, UnavailabilityError } from 'expo-modules-core';
+import { expoCalendar } from './native-module.js';
+import { stringifyDateValues, stringifyIfDate } from '../core/utils.js';
+export async function createEventInCalendarAsync(eventData = {}, presentationOptions) {
+    if (!expoCalendar.createEventInCalendarAsync) {
+        throw new UnavailabilityError('Calendar', 'createEventInCalendarAsync');
+    }
+    if ('id' in eventData && eventData.id) {
+        console.warn('You attempted to create an event with an id. Event ids are assigned by the system.');
+    }
+    const params = { ...stringifyDateValues(eventData), ...presentationOptions };
+    return expoCalendar.createEventInCalendarAsync(params);
+}
+export async function openEventInCalendarAsync(params, presentationOptions) {
+    if (!expoCalendar.openEventInCalendarAsync) {
+        throw new UnavailabilityError('Calendar', 'openEventInCalendarAsync');
+    }
+    if (!params.id) {
+        throw new Error('openEventInCalendarAsync must be called with an id (string) of the target event');
+    }
+    return expoCalendar.openEventInCalendarAsync({
+        ...params,
+        ...presentationOptions,
+    });
+}
+export async function editEventInCalendarAsync(params, presentationOptions) {
+    if (!expoCalendar.editEventInCalendarAsync) {
+        throw new UnavailabilityError('Calendar', 'editEventInCalendarAsync');
+    }
+    if (!params.id) {
+        throw new Error('editEventInCalendarAsync must be called with an id (string) of the target event');
+    }
+    return expoCalendar.editEventInCalendarAsync({
+        ...params,
+        ...presentationOptions,
+    });
+}
+export async function isAvailableAsync() {
+    return !!expoCalendar.getCalendarsAsync;
+}
+export async function getCalendarsAsync(entityType) {
+    if (!expoCalendar.getCalendarsAsync) {
+        throw new UnavailabilityError('Calendar', 'getCalendarsAsync');
+    }
+    return expoCalendar.getCalendarsAsync(entityType ?? null);
+}
+export async function createCalendarAsync(details = {}) {
+    if (!expoCalendar.saveCalendarAsync) {
+        throw new UnavailabilityError('Calendar', 'createCalendarAsync');
+    }
+    const newDetails = { ...details, id: undefined };
+    return expoCalendar.saveCalendarAsync(stringifyDateValues(newDetails));
+}
+const ANDROID_READ_ONLY_CALENDAR_FIELDS = [
+    'source',
+    'color',
+    'allowsModifications',
+    'allowedAvailabilities',
+    'isPrimary',
+    'ownerAccount',
+    'timeZone',
+    'allowedReminders',
+    'allowedAttendeeTypes',
+    'accessLevel',
+];
+const IOS_READ_ONLY_CALENDAR_FIELDS = [
+    'source',
+    'type',
+    'entityType',
+    'allowsModifications',
+    'allowedAvailabilities',
+];
+export async function updateCalendarAsync(id, details = {}) {
+    if (!expoCalendar.saveCalendarAsync) {
+        throw new UnavailabilityError('Calendar', 'updateCalendarAsync');
+    }
+    if (!id) {
+        throw new Error('updateCalendarAsync must be called with an id (string) of the target calendar');
+    }
+    const readOnlyFields = Platform.OS === 'android'
+        ? ANDROID_READ_ONLY_CALENDAR_FIELDS
+        : IOS_READ_ONLY_CALENDAR_FIELDS;
+    if (readOnlyFields.some(field => Object.hasOwn(details, field))) {
+        console.warn('updateCalendarAsync was called with one or more read-only properties, which will not be updated');
+    }
+    const newDetails = { ...details, id };
+    return expoCalendar.saveCalendarAsync(stringifyDateValues(newDetails));
+}
+export async function deleteCalendarAsync(id) {
+    if (!expoCalendar.deleteCalendarAsync) {
+        throw new UnavailabilityError('Calendar', 'deleteCalendarAsync');
+    }
+    if (!id) {
+        throw new Error('deleteCalendarAsync must be called with an id (string) of the target calendar');
+    }
+    return expoCalendar.deleteCalendarAsync(id);
+}
+export async function getEventsAsync(calendarIds, startDate, endDate) {
+    if (!expoCalendar.getEventsAsync) {
+        throw new UnavailabilityError('Calendar', 'getEventsAsync');
+    }
+    if (!startDate) {
+        throw new Error('getEventsAsync must be called with a startDate (date) to search for events');
+    }
+    if (!endDate) {
+        throw new Error('getEventsAsync must be called with an endDate (date) to search for events');
+    }
+    if (!calendarIds || !calendarIds.length) {
+        throw new Error('getEventsAsync must be called with a non-empty array of calendarIds to search');
+    }
+    return expoCalendar.getEventsAsync(stringifyIfDate(startDate), stringifyIfDate(endDate), calendarIds);
+}
+export async function getEventAsync(id, recurringEventOptions = {}) {
+    if (!expoCalendar.getEventByIdAsync) {
+        throw new UnavailabilityError('Calendar', 'getEventAsync');
+    }
+    if (!id) {
+        throw new Error('getEventAsync must be called with an id (string) of the target event');
+    }
+    if (Platform.OS === 'ios') {
+        return expoCalendar.getEventByIdAsync(id, recurringEventOptions.instanceStartDate);
+    }
+    return expoCalendar.getEventByIdAsync(id);
+}
+export async function createEventAsync(calendarId, eventData = {}) {
+    if (!expoCalendar.saveEventAsync) {
+        throw new UnavailabilityError('Calendar', 'createEventAsync');
+    }
+    if (!calendarId) {
+        throw new Error('createEventAsync must be called with an id (string) of the target calendar');
+    }
+    if ('id' in eventData && eventData.id) {
+        console.warn('You attempted to create an event with an id. Event ids are assigned by the system.');
+    }
+    if (Platform.OS === 'android') {
+        if (!eventData.startDate) {
+            throw new Error('createEventAsync requires a startDate (Date)');
+        }
+        if (!eventData.endDate) {
+            throw new Error('createEventAsync requires an endDate (Date)');
+        }
+    }
+    return expoCalendar.saveEventAsync(stringifyDateValues({ ...eventData, calendarId }), {});
+}
+const IOS_READ_ONLY_EVENT_FIELDS = [
+    'creationDate',
+    'lastModifiedDate',
+    'originalStartDate',
+    'isDetached',
+    'status',
+    'organizer',
+];
+export async function updateEventAsync(id, details = {}, recurringEventOptions = {}) {
+    if (!expoCalendar.saveEventAsync) {
+        throw new UnavailabilityError('Calendar', 'updateEventAsync');
+    }
+    if (!id) {
+        throw new Error('updateEventAsync must be called with an id (string) of the target event');
+    }
+    if (Platform.OS === 'ios' &&
+        IOS_READ_ONLY_EVENT_FIELDS.some(field => Object.hasOwn(details, field))) {
+        console.warn('updateEventAsync was called with one or more read-only properties, which will not be updated');
+    }
+    const { futureEvents = false, instanceStartDate } = recurringEventOptions;
+    const newDetails = { ...details, id, instanceStartDate };
+    return expoCalendar.saveEventAsync(stringifyDateValues(newDetails), {
+        futureEvents,
+    });
+}
+export async function deleteEventAsync(id, recurringEventOptions = {}) {
+    if (!expoCalendar.deleteEventAsync) {
+        throw new UnavailabilityError('Calendar', 'deleteEventAsync');
+    }
+    if (!id) {
+        throw new Error('deleteEventAsync must be called with an id (string) of the target event');
+    }
+    const { futureEvents = false, instanceStartDate } = recurringEventOptions;
+    return expoCalendar.deleteEventAsync({ id, instanceStartDate }, { futureEvents });
+}
+export async function getAttendeesForEventAsync(id, recurringEventOptions = {}) {
+    if (!expoCalendar.getAttendeesForEventAsync) {
+        throw new UnavailabilityError('Calendar', 'getAttendeesForEventAsync');
+    }
+    if (!id) {
+        throw new Error('getAttendeesForEventAsync must be called with an id (string) of the target event');
+    }
+    const { instanceStartDate } = recurringEventOptions;
+    const params = Platform.OS === 'ios' ? { id, instanceStartDate } : id;
+    return expoCalendar.getAttendeesForEventAsync(params);
+}
+export async function createAttendeeAsync(eventId, details = {}) {
+    if (!expoCalendar.saveAttendeeForEventAsync) {
+        throw new UnavailabilityError('Calendar', 'createAttendeeAsync');
+    }
+    if (!eventId) {
+        throw new Error('createAttendeeAsync must be called with an id (string) of the target event');
+    }
+    if (!details.email) {
+        throw new Error('createAttendeeAsync requires an email (string)');
+    }
+    if (!details.role) {
+        throw new Error('createAttendeeAsync requires a role (string)');
+    }
+    if (!details.type) {
+        throw new Error('createAttendeeAsync requires a type (string)');
+    }
+    if (!details.status) {
+        throw new Error('createAttendeeAsync requires a status (string)');
+    }
+    return expoCalendar.saveAttendeeForEventAsync({ ...details, id: undefined }, eventId);
+}
+export async function updateAttendeeAsync(id, details = {}) {
+    if (!expoCalendar.saveAttendeeForEventAsync) {
+        throw new UnavailabilityError('Calendar', 'updateAttendeeAsync');
+    }
+    if (!id) {
+        throw new Error('updateAttendeeAsync must be called with an id (string) of the target event');
+    }
+    return expoCalendar.saveAttendeeForEventAsync({ ...details, id }, null);
+}
+export async function deleteAttendeeAsync(id) {
+    if (!expoCalendar.deleteAttendeeAsync) {
+        throw new UnavailabilityError('Calendar', 'deleteAttendeeAsync');
+    }
+    if (!id) {
+        throw new Error('deleteAttendeeAsync must be called with an id (string) of the target event');
+    }
+    return expoCalendar.deleteAttendeeAsync(id);
+}
+export async function getDefaultCalendarAsync() {
+    if (!expoCalendar.getDefaultCalendarAsync) {
+        throw new UnavailabilityError('Calendar', 'getDefaultCalendarAsync');
+    }
+    return expoCalendar.getDefaultCalendarAsync();
+}
+export async function getSourcesAsync() {
+    if (!expoCalendar.getSourcesAsync) {
+        throw new UnavailabilityError('Calendar', 'getSourcesAsync');
+    }
+    return expoCalendar.getSourcesAsync();
+}
+export async function getSourceAsync(id) {
+    if (!expoCalendar.getSourceByIdAsync) {
+        throw new UnavailabilityError('Calendar', 'getSourceAsync');
+    }
+    if (!id) {
+        throw new Error('getSourceAsync must be called with an id (string) of the target source');
+    }
+    return expoCalendar.getSourceByIdAsync(id);
+}
+/** @platform android */
+export function openEventInCalendar(id) {
+    if (!expoCalendar.openEventInCalendar) {
+        console.warn(`openEventInCalendar is not available on platform: ${Platform.OS}`);
+        return;
+    }
+    if (!id) {
+        throw new Error('openEventInCalendar must be called with an id (string) of the target event');
+    }
+    return expoCalendar.openEventInCalendar(id);
+}

package/build/legacy/enums.d.ts

@@ -0,0 +1 @@
+export * from '../core/enums';

package/build/legacy/enums.js

@@ -0,0 +1,2 @@
+// Same enum value sets as upstream's legacy/Calendar.ts and next Calendar.ts share one source.
+export * from '../core/enums.js';

package/build/legacy/index.d.ts

@@ -0,0 +1,5 @@
+export * from './enums';
+export * from './types';
+export * from './calendar';
+export * from './permissions';
+export * from './reminders';

package/build/legacy/index.js

@@ -0,0 +1,5 @@
+export * from './enums.js';
+export * from './types.js';
+export * from './calendar.js';
+export * from './permissions.js';
+export * from './reminders.js';

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

@@ -0,0 +1,39 @@
+import type { IAttendee, ICalendar, ICalendarDialogParams, IDialogEventResult, IEvent, IOpenEventDialogResult, IOpenEventPresentationOptions, IPresentationOptions, IReminder, ISource, PermissionResponse } from './types';
+export type INativeCalendarModule = {
+    createEventInCalendarAsync?(params: Record<string, unknown>): Promise<IDialogEventResult>;
+    openEventInCalendarAsync?(params: ICalendarDialogParams & IOpenEventPresentationOptions): Promise<IOpenEventDialogResult>;
+    editEventInCalendarAsync?(params: ICalendarDialogParams & IPresentationOptions): Promise<IDialogEventResult>;
+    getCalendarsAsync?(entityType: string | null): Promise<ICalendar[]>;
+    saveCalendarAsync?(details: Record<string, unknown>): Promise<string>;
+    deleteCalendarAsync?(id: string): Promise<void>;
+    getEventsAsync?(startDate: string | Date, endDate: string | Date, calendarIds: string[]): Promise<IEvent[]>;
+    getEventByIdAsync?(id: string, instanceStartDate?: string | Date): Promise<IEvent>;
+    saveEventAsync?(details: Record<string, unknown>, options: {
+        futureEvents?: boolean;
+    }): Promise<string>;
+    deleteEventAsync?(params: {
+        id: string;
+        instanceStartDate?: string | Date;
+    }, options: {
+        futureEvents?: boolean;
+    }): Promise<void>;
+    getAttendeesForEventAsync?(params: {
+        id: string;
+        instanceStartDate?: string | Date;
+    } | string): Promise<IAttendee[]>;
+    saveAttendeeForEventAsync?(details: Record<string, unknown>, eventId: string | null): Promise<string>;
+    deleteAttendeeAsync?(id: string): Promise<void>;
+    getDefaultCalendarAsync?(): Promise<ICalendar>;
+    getRemindersAsync?(startDate: string | Date | null, endDate: string | Date | null, calendarIds: (string | null)[], status: string | null): Promise<IReminder[]>;
+    getReminderByIdAsync?(id: string): Promise<IReminder>;
+    saveReminderAsync?(details: Record<string, unknown>): Promise<string>;
+    deleteReminderAsync?(id: string): Promise<void>;
+    getSourcesAsync?(): Promise<ISource[]>;
+    getSourceByIdAsync?(id: string): Promise<ISource>;
+    openEventInCalendar?(id: string): void;
+    getCalendarPermissionsAsync?(): Promise<PermissionResponse>;
+    requestCalendarPermissionsAsync?(): Promise<PermissionResponse>;
+    getRemindersPermissionsAsync?(): Promise<PermissionResponse>;
+    requestRemindersPermissionsAsync?(): Promise<PermissionResponse>;
+};
+export declare const expoCalendar: INativeCalendarModule;

package/build/legacy/native-module.js

@@ -0,0 +1,3 @@
+import { requireNativeModule } from 'expo-modules-core';
+const EXPO_CALENDAR_MODULE_NAME = 'ExpoCalendar';
+export const expoCalendar = requireNativeModule(EXPO_CALENDAR_MODULE_NAME);

package/build/legacy/permissions.d.ts

@@ -0,0 +1,9 @@
+import type { PermissionResponse } from './types';
+export declare function getCalendarPermissionsAsync(): Promise<PermissionResponse>;
+/** @platform ios */
+export declare function getRemindersPermissionsAsync(): Promise<PermissionResponse>;
+export declare function requestCalendarPermissionsAsync(): Promise<PermissionResponse>;
+/** @deprecated Use `requestCalendarPermissionsAsync` instead */
+export declare function requestPermissionsAsync(): Promise<PermissionResponse>;
+/** @platform ios */
+export declare function requestRemindersPermissionsAsync(): Promise<PermissionResponse>;

package/build/legacy/permissions.js

@@ -0,0 +1,33 @@
+import { UnavailabilityError } from 'expo-modules-core';
+import { expoCalendar } from './native-module.js';
+export async function getCalendarPermissionsAsync() {
+    if (!expoCalendar.getCalendarPermissionsAsync) {
+        throw new UnavailabilityError('Calendar', 'getCalendarPermissionsAsync');
+    }
+    return expoCalendar.getCalendarPermissionsAsync();
+}
+/** @platform ios */
+export async function getRemindersPermissionsAsync() {
+    if (!expoCalendar.getRemindersPermissionsAsync) {
+        throw new UnavailabilityError('Calendar', 'getRemindersPermissionsAsync');
+    }
+    return expoCalendar.getRemindersPermissionsAsync();
+}
+export async function requestCalendarPermissionsAsync() {
+    if (!expoCalendar.requestCalendarPermissionsAsync) {
+        throw new UnavailabilityError('Calendar', 'requestCalendarPermissionsAsync');
+    }
+    return expoCalendar.requestCalendarPermissionsAsync();
+}
+/** @deprecated Use `requestCalendarPermissionsAsync` instead */
+export async function requestPermissionsAsync() {
+    console.warn('requestPermissionsAsync is deprecated. Use requestCalendarPermissionsAsync instead.');
+    return requestCalendarPermissionsAsync();
+}
+/** @platform ios */
+export async function requestRemindersPermissionsAsync() {
+    if (!expoCalendar.requestRemindersPermissionsAsync) {
+        throw new UnavailabilityError('Calendar', 'requestRemindersPermissionsAsync');
+    }
+    return expoCalendar.requestRemindersPermissionsAsync();
+}

package/build/legacy/reminders.d.ts

@@ -0,0 +1,6 @@
+import type { IReminder } from './types';
+export declare function getRemindersAsync(calendarIds: (string | null)[], status: string | null, startDate: Date | null, endDate: Date | null): Promise<IReminder[]>;
+export declare function getReminderAsync(id: string): Promise<IReminder>;
+export declare function createReminderAsync(calendarId: string | null, reminder?: IReminder): Promise<string>;
+export declare function updateReminderAsync(id: string, details?: IReminder): Promise<string>;
+export declare function deleteReminderAsync(id: string): Promise<void>;