@mgcrea/mcp-apple-calendar 0.0.0-bootstrap

package/dist/index.d.ts

@@ -0,0 +1,625 @@
+import { AppBusyError as CalendarBusyError, AppNotRunningError as CalendarNotRunningError, AppleAutomationError, AppleAutomationError as AppleCalendarError, BuildInfo, Logger, OsascriptRunner, ReadOnlyMode, StoreFacts, SurfaceContext } from "@mgcrea/mcp-apple-core";
+import { z } from "zod";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { DatabaseSync } from "node:sqlite";
+//#region src/build-info.d.ts
+declare const BUILD_INFO: BuildInfo;
+//#endregion
+//#region src/client/store.d.ts
+type StoreCapabilities = {
+  fingerprint: string;
+  /** Present columns, so an Apple rename degrades one field instead of the lane. */
+  itemColumns: Set<string>;
+  calendarColumns: Set<string>;
+  occurrenceColumns: Set<string>;
+  recurrenceColumns: Set<string>;
+  storeColumns: Set<string>;
+  /**
+   * Whether recurrences can be expanded at all.
+   *
+   * False is a capability downgrade, never a throw: leg 1 of a range query
+   * (items carrying no recurrence rule) stays correct at any horizon, so the
+   * honest degradation is to answer with it and say that repeating events were
+   * not expanded — not to fail, and above all not to quietly return fewer rows.
+   */
+  hasOccurrenceCache: boolean;
+  hasOccurrenceDays: boolean;
+  hasRecurrence: boolean;
+  hasExceptionDates: boolean;
+  hasLocation: boolean;
+  hasAttachments: boolean;
+  hasParticipants: boolean;
+  hasAlarms: boolean;
+  epochOffset: number;
+};
+/** One row of the union, still in store units. Rendering happens above this. */
+type EventRow = {
+  itemPk: number;
+  uuid: string | null;
+  calendarPk: number | null;
+  calendarUuid: string | null;
+  calendarTitle: string | null;
+  summary: string | null;
+  description: string | null;
+  url: string | null;
+  conferenceUrl: string | null;
+  locationTitle: string | null;
+  startApple: number | null;
+  endApple: number | null;
+  allDay: boolean;
+  startTz: string | null;
+  endTz: string | null;
+  status: number | null;
+  invitationStatus: number | null;
+  availability: number | null;
+  hasRecurrences: boolean;
+  hasAttendees: boolean;
+  /** Set on a detached occurrence: which series it broke away from, and when. */
+  origItemPk: number | null;
+  origDateApple: number | null;
+  /** Which leg produced this row. Reported so a caller can see the expansion working. */
+  source: "item" | "occurrence";
+};
+type RangeQuery = {
+  /** Apple-seconds, inclusive lower bound. */
+  fromApple: number;
+  /** Apple-seconds, exclusive upper bound. */
+  toApple: number;
+  /** `Calendar.UUID` values. Empty means every calendar. */
+  calendarUuids?: readonly string[];
+  limit: number;
+};
+type SearchQuery = RangeQuery & {
+  text: string;
+  scope: "summary" | "full";
+};
+/** How far the cached expansion actually reaches, in Apple-seconds. */
+type Coverage = {
+  fromApple: number;
+  toApple: number;
+  rows: number;
+} | null;
+type IndexCalendar = {
+  uuid: string | null;
+  title: string | null;
+  color: string | null;
+  type: string | null;
+  accountName: string | null;
+  isSubscribed: boolean;
+  isPublished: boolean;
+  /**
+   * Whether this calendar is shared with other people.
+   *
+   * Derived from `sharing_status`, and INFERRED rather than measured: the only
+   * values observed are 0, 1 and NULL, with 1 on the two calendars known to be
+   * shared. The raw value stays on the result so a caller can disagree.
+   *
+   * It matters because writing to a shared calendar is visible to whoever else
+   * is on it, and nothing else in the output says so.
+   */
+  isShared: boolean;
+  sharingStatus: number | null;
+};
+type IndexAccount = {
+  name: string | null;
+  type: number | null;
+  calendars: number;
+};
+declare class CalendarStore {
+  #private;
+  readonly db: DatabaseSync;
+  readonly mode: string;
+  readonly caps: StoreCapabilities;
+  constructor(db: DatabaseSync, mode: string, caps: StoreCapabilities);
+  /**
+   * LEG 1 — items carried by the table itself.
+   *
+   * Overlap, not containment: `start < to AND COALESCE(end, start) > from`. A
+   * naive `BETWEEN` on the start silently drops the all-hands that began at
+   * 09:00 when the caller asked about 10:00 onward.
+   *
+   * Items whose occurrences are expanded in the cache are excluded here and
+   * picked up by leg 2, so a repeating event is not also returned once at its
+   * master start.
+   */
+  rangeItems(q: RangeQuery): EventRow[];
+  /**
+   * LEG 2 — expanded occurrences.
+   *
+   * `OccurrenceCache.event_id` -> `CalendarItem.ROWID` was measured at a 100%
+   * resolve rate. `occurrence_date` is the start; `occurrence_start_date` exists
+   * too and reaches only +256 days against `occurrence_date`'s +724, so using it
+   * would silently truncate the far half of the window.
+   */
+  rangeOccurrences(q: RangeQuery): EventRow[];
+  /**
+   * Text search, unbounded in time by default.
+   *
+   * Searching is the one place a caller legitimately wants all of history, so
+   * the window is the caller's to set rather than a default. Runs over items
+   * only: an occurrence carries no text of its own, and matching the series once
+   * is what a search result should be.
+   */
+  searchItems(q: SearchQuery): EventRow[];
+  /** One event by its Apple Events uid. The bridge measured 198/198 exact. */
+  byUuid(uuid: string): EventRow | null;
+  /**
+   * How far the expansion reaches.
+   *
+   * Published with every range result. Measured at -732 to +724 days on the
+   * probed store, which is a real expansion rather than a month-view cache —
+   * but it is still an edge, and nothing guarantees the next machine's is as
+   * deep. A range running past it must say so rather than return a short list.
+   */
+  coverage(): Coverage;
+  calendars(): IndexCalendar[];
+  accounts(): IndexAccount[];
+  close(): void;
+}
+declare const introspect: (db: DatabaseSync) => StoreCapabilities;
+declare const openStore: (path: string | null, mode: ReadOnlyMode, logger?: Logger) => CalendarStore | null;
+//#endregion
+//#region src/config.d.ts
+/**
+ * Configuration is environment-only — this server holds no secret at all, its
+ * access is the macOS permission the user granted.
+ *
+ * `allowWrites`, `debug`, `osascriptPath`, `osascriptTimeoutMs` and `maxResults`
+ * come from `BaseConfigSchema`.
+ *
+ * Note what is deliberately ABSENT relative to `packages/reminders`: there is no
+ * `searchCacheTtlMs` and no degraded-listing cap, because both exist there to
+ * manage an Apple Events READ lane. Calendar has none by design
+ * (`docs/distribution.md`), and config for a lane that does not exist would
+ * advertise a fallback this server cannot provide.
+ */
+declare const ConfigSchema: z.ZodObject<{
+  allowWrites: z.ZodDefault<z.ZodBoolean>;
+  debug: z.ZodDefault<z.ZodBoolean>;
+  osascriptPath: z.ZodDefault<z.ZodString>;
+  osascriptTimeoutMs: z.ZodDefault<z.ZodNumber>;
+  maxResults: z.ZodDefault<z.ZodNumber>;
+  accounts: z.ZodDefault<z.ZodArray<z.ZodString>>;
+  calendars: z.ZodDefault<z.ZodArray<z.ZodString>>;
+  storePath: z.ZodOptional<z.ZodString>;
+  indexMode: z.ZodDefault<z.ZodEnum<{
+    auto: "auto";
+    immutable: "immutable";
+    off: "off";
+    ro: "ro";
+  }>>;
+  defaultCalendar: z.ZodOptional<z.ZodString>;
+  defaultRangeDays: z.ZodDefault<z.ZodNumber>;
+  maxRangeDays: z.ZodDefault<z.ZodNumber>;
+  defaultEventDurationMinutes: z.ZodDefault<z.ZodNumber>;
+  includeDeclined: z.ZodDefault<z.ZodBoolean>;
+  includeCancelled: z.ZodDefault<z.ZodBoolean>;
+  timeZone: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+type Config = z.infer<typeof ConfigSchema>;
+/**
+ * `env` is a parameter with a default so tests are hermetic — they pass their
+ * own object rather than mutating (and having to restore) process.env.
+ */
+declare const loadConfig: (env?: NodeJS.ProcessEnv) => Config;
+//#endregion
+//#region src/client/dates.d.ts
+/**
+ * What a tool reports for an event's start or end.
+ *
+ * A union rather than one struct with an `allDay` flag: an all-day event names
+ * a DAY and has no instant, and giving it an `iso` field would invite callers to
+ * read one. The type makes that impossible instead of merely discouraged.
+ */
+type EventInstant = {
+  allDay: true;
+  day: string;
+  timeZone: null;
+} | {
+  allDay: false;
+  iso: string;
+  timeZone: string | null;
+};
+//#endregion
+//#region src/client/locate.d.ts
+/**
+ * Find Calendar's store.
+ *
+ * ## Why this is the easy case
+ *
+ * Reminders keeps its database under a generated directory name, so resolving
+ * it means *listing* a protected directory — which is itself the privileged
+ * operation, leaving no path to even stat without the grant. Calendar does not:
+ *
+ *     ~/Library/Group Containers/group.com.apple.calendar/Calendar.sqlitedb
+ *
+ * is a constant. `statSync` succeeds on a TCC-protected file (only `access(2)`
+ * is denied — see packages/core/src/fs.ts), so this locator can tell "exists but
+ * unreadable" from "not there at all" with no permission whatsoever. Those are
+ * different failures with different fixes, and saying so is most of what
+ * diagnostics is for.
+ *
+ * ## Why it still walks the container
+ *
+ * `docs/calendar.md` recorded per-account stores sitting beside the main one,
+ * and the probe picked between them by size. The known filename is *preferred*,
+ * so the common case costs one `describeStore` and no listing at all; the walk
+ * is a fallback for a machine whose layout differs, and for the day Apple moves
+ * the file the way it moved Reminders' out of `~/Library/Reminders`.
+ */
+/** `group.com.apple.calendar`, under `~/Library/Group Containers`. */
+declare const GROUP_CONTAINER = "group.com.apple.calendar";
+/** The observed filename. Preferred when present; not required. */
+declare const STORE_FILENAME = "Calendar.sqlitedb";
+/** Sits beside the store. 32 KB, and its contents are not used by this server. */
+declare const EXTRAS_FILENAME = "Extras.db";
+type StoreCandidate = StoreFacts & {
+  path: string;
+};
+type LocateResult = StoreFacts & {
+  containerPath: string;
+  /** Null when discovery found nothing at all — see `reason`. */
+  storePath: string | null;
+  /** Every store-shaped file found, largest first. */
+  candidates: StoreCandidate[];
+  /**
+   * Whether the container could be listed.
+   *
+   * Unlike Reminders this is NOT the permission signal — the store's path is
+   * known, so `readable` answers that directly. It is reported because a
+   * listable container with no store in it means Calendar was never set up,
+   * which is a different conversation from a denied grant.
+   */
+  containerListable: boolean;
+  /** `Extras.db` beside the store. Recorded so it stops being an unknown. */
+  extrasPresent: boolean;
+  reason: string | null;
+};
+declare const defaultContainerPath: (home?: string) => string;
+declare const defaultStorePath: (home?: string) => string;
+declare const locateStore: (opts?: {
+  storePath?: string | undefined;
+  home?: string;
+}) => LocateResult;
+//#endregion
+//#region src/client/recurrence.d.ts
+type ExpansionState = "expanded" | "unavailable";
+//#endregion
+//#region src/client/calendar.d.ts
+/**
+ * The lane orchestrator.
+ *
+ * Thinner than `packages/reminders`' by design. That surface arbitrates between
+ * two read lanes and caches an expensive Apple Events bulk fetch; Calendar has
+ * exactly one read lane, because `docs/distribution.md` sets the policy for new
+ * surfaces — file-lane reads, Apple Events for writes and live state — and
+ * `docs/calendar.md` measured why: a range query over Apple Events costs 3.4 s
+ * and does not improve with batching.
+ *
+ * So there is nothing to arbitrate. Either the store opens or the surface says
+ * plainly that it cannot answer, and never returns an empty list that reads like
+ * an empty calendar.
+ */
+type LaneStatus = {
+  /**
+   * Always reported, never probed here.
+   *
+   * Reminders probes its Apple Events lane on every `lanes()` call because that
+   * lane answers reads. Calendar's does not: it exists only for writes, which
+   * are not implemented yet. Probing it would fire the Automation prompt for a
+   * capability the server does not currently have, which is a worse trade than
+   * saying so.
+   */
+  applescript: "not-used" | "live" | "unavailable";
+  index: "live" | "unavailable" | "disabled";
+  indexMode: string | null;
+  storeFingerprint: string | null;
+  reason: string | null;
+};
+type EventSummary = {
+  /** Opaque; feed it back to get_event or a write tool. */
+  ref: string;
+  summary: string | null;
+  start: EventInstant | null;
+  end: EventInstant | null;
+  allDay: boolean;
+  calendar: string | null;
+  location: string | null;
+  /** True when this row is one instance of a repeating event. */
+  isOccurrence: boolean;
+  /** Present on an occurrence: the ref naming the whole series. */
+  seriesRef?: string;
+  /** Raw store value, reported because the mapping above is inferred. */
+  status: number | null;
+  invitationStatus: number | null;
+  /** Which lane produced the row. */
+  source: EventRow["source"];
+};
+type EventDetail = EventSummary & {
+  description: string | null;
+  url: string | null;
+  conferenceUrl: string | null;
+  hasAttendees: boolean;
+  hasRecurrences: boolean;
+  timeZone: string | null;
+};
+type EventPage = {
+  events: EventSummary[];
+  expansion: ExpansionState;
+  expansionReason?: string;
+  /** The window actually queried, echoed so a clamp is visible. */
+  window: {
+    from: string;
+    to: string;
+    clamped: boolean;
+  };
+  coverage: {
+    from: string;
+    to: string;
+    rows: number;
+  } | null;
+  truncated?: {
+    reason: string;
+    affects: string;
+    uncoveredFrom?: string;
+    uncoveredTo?: string;
+  };
+  dropped?: number;
+};
+type EventFilters = {
+  from?: string | undefined;
+  to?: string | undefined;
+  calendar?: string | undefined;
+  includeDeclined?: boolean | undefined;
+  includeCancelled?: boolean | undefined;
+  limit: number;
+};
+type CreateClientOptions = {
+  config: Config;
+  logger?: Logger;
+  /** Injected by tests so nothing spawns a process or touches a real Calendar. */
+  osascript?: OsascriptRunner;
+  /** Injected by tests so a relative range resolves against a frozen clock. */
+  now?: () => Date;
+};
+/** What a write returns: what Calendar STORED, never what was requested. */
+type WriteResult = {
+  ref: string;
+  uid: string | null;
+  summary: string | null;
+  start: string | null;
+  end: string | null;
+  allDay: boolean;
+  calendar: string | null;
+  /** Always "apple-events": writes never touch the store. */
+  source: "apple-events";
+};
+type CreateEventFields = {
+  summary: string;
+  calendar?: string | undefined;
+  start: string;
+  end?: string | undefined;
+  durationMinutes?: number | undefined;
+  allDay?: boolean | undefined;
+  location?: string | undefined;
+  description?: string | undefined;
+  url?: string | undefined;
+};
+type UpdateEventFields = {
+  ref: string;
+  summary?: string | undefined;
+  start?: string | undefined;
+  end?: string | undefined;
+  durationMinutes?: number | undefined;
+  allDay?: boolean | undefined;
+  location?: string | undefined;
+  description?: string | undefined;
+  url?: string | undefined;
+};
+declare class AppleCalendarClient {
+  #private;
+  readonly config: Config;
+  readonly runner: OsascriptRunner;
+  constructor(opts: CreateClientOptions);
+  /** Cached: the answer cannot change without the process being restarted anyway. */
+  locate(): LocateResult;
+  /**
+   * The store, opened lazily and at most once.
+   *
+   * Returns null rather than throwing, because "no index" is a state the caller
+   * has to render, not an exception. The reason lives on the locate result.
+   */
+  index(): CalendarStore | null;
+  /**
+   * Drop the open handle so the next read reopens.
+   *
+   * Called after a write: Calendar owns the store and reconciles it against a
+   * server, so an event created over Apple Events lands in the file on the
+   * app's schedule, not ours.
+   */
+  invalidate(): void;
+  listEvents(filters: EventFilters): EventPage;
+  /**
+   * Text search over events.
+   *
+   * Runs on items only. An occurrence carries no text of its own, so matching
+   * the series once is what a search result should be — expanding it here would
+   * bury one answer under fifty identical ones.
+   */
+  searchEvents(args: EventFilters & {
+    query: string;
+    scope?: "summary" | "full" | undefined;
+  }): EventPage;
+  getEvent(ref: string): EventDetail;
+  calendars(): IndexCalendar[];
+  accounts(): IndexAccount[];
+  createEvent(fields: CreateEventFields): Promise<WriteResult>;
+  updateEvent(fields: UpdateEventFields): Promise<WriteResult>;
+  /**
+   * Delete whole events.
+   *
+   * Only whole events: Calendar's scripting interface cannot remove a single
+   * occurrence of a repeating one. `excludedDates` — the property Calendar.app
+   * itself uses for "Delete This Event" — reads back a 1903 sentinel and throws
+   * on assignment, measured on macOS 26.6. So an occurrence ref is refused
+   * rather than silently deleting the whole series, which is the same shape of
+   * refusal `updateEvent` makes and for the same underlying reason.
+   */
+  deleteEvents(refs: readonly string[]): Promise<{
+    results: unknown[];
+    scope: string;
+  }>;
+  lanes(): LaneStatus;
+}
+//#endregion
+//#region src/client/errors.d.ts
+/**
+ * Named in every user-facing error and in the env vars they mention.
+ *
+ * `appName` is the display name, which is NOT the bundle id: Calendar.app is
+ * still `com.apple.iCal` underneath. Every other surface has the two agreeing,
+ * so the mismatch is written down in both places it matters.
+ */
+declare const CALENDAR_SURFACE: SurfaceContext;
+/** Calendar's Apple Events target. Not `com.apple.Calendar`, which does not exist. */
+declare const CALENDAR_BUNDLE_ID = "com.apple.iCal";
+/**
+ * A date argument could not be understood.
+ *
+ * Carries the accepted grammar rather than just rejecting, because the caller is
+ * usually a model that will retry once and needs to know what shape to retry in.
+ */
+declare class InvalidDateError extends AppleAutomationError {
+  readonly name = "InvalidDateError";
+  constructor(field: string, raw: string, reason: string);
+}
+/** A CalendarRef no longer resolves — deleted, or moved to another calendar. */
+declare class EventNotFoundError extends AppleAutomationError {
+  readonly name = "EventNotFoundError";
+  constructor(ref: string);
+}
+/** A calendar was named that Calendar does not have. */
+declare class CalendarNotFoundError extends AppleAutomationError {
+  readonly name = "CalendarNotFoundError";
+  constructor(name: string, available?: readonly string[]);
+}
+/**
+ * A write was aimed at a calendar that cannot accept one.
+ *
+ * Its own error rather than a generic failure because the cause is almost
+ * always structural rather than a mistake: holiday, birthday and subscribed
+ * calendars are read-only by nature, and a caller that hits one needs to pick a
+ * different target, not retry.
+ */
+declare class CalendarNotWritableError extends AppleAutomationError {
+  readonly name = "CalendarNotWritableError";
+  constructor(name: string);
+}
+//#endregion
+//#region src/client/ref.d.ts
+/**
+ * CalendarRef — the one identifier any tool accepts or returns.
+ *
+ * Wire format:  c1:<calendarUid>/<occurrence>/<eventUid>
+ *
+ *   calendarUid  `Calendar.UUID`. Always a UUID in this store.
+ *   occurrence   "-" for a single event or a whole series, otherwise the
+ *                occurrence start as ISO-8601 basic with offset,
+ *                e.g. 20260821T090000+0200.
+ *   eventUid     `CalendarItem.UUID`, verbatim, as the greedy tail.
+ *
+ * The `c1:` prefix follows the same reasoning as Notes' `n1:` and Reminders'
+ * `r1:`: if the scheme ever changes, a versioned prefix makes that an additive
+ * change instead of a silent reinterpretation of every ref already sitting in a
+ * conversation.
+ *
+ * ## Why the uid is the greedy tail, and why `@` is not a separator
+ *
+ * `docs/calendar.md` measured the id bridge on an iCloud account, where every
+ * uid is a bare UUID. That is a property of the ACCOUNT, not of Calendar: a
+ * Google event's uid looks like `abc123def@google.com`, and an Exchange one is
+ * a long hex blob. Requiring a UUID here would work perfectly on the machine it
+ * was written on and fail completely on anyone else's — so the uid is carried
+ * through verbatim and the UUID is only extracted opportunistically.
+ *
+ * That also rules out `@` as a field separator, which is otherwise the obvious
+ * choice for pinning an occurrence to a time.
+ *
+ * ## Why the calendar uid rides along
+ *
+ * Calendar's scripting dictionary has no `events.byId()`. Finding an event over
+ * Apple Events means either `whose({uid})` — measured at 4.5-7.3 s and, worse,
+ * UNSTABLE across runs — or one bulk `cal.events.uid()` fetch and an index in
+ * JS, at about 1.8 s. The bulk fetch is only affordable if it is scoped to ONE
+ * calendar, so every write narrows by calendar before it scans.
+ *
+ * That is a concrete thing the file lane hands the write lane: the store knows
+ * which calendar an event is in, so Apple Events never has to search for it.
+ */
+declare const REF_VERSION = "c1";
+type CalendarRef = {
+  /** `Calendar.UUID` — which calendar to narrow to before scanning. */
+  calendarUid: string;
+  /** `CalendarItem.UUID`, exactly as stored. This is what resolves. */
+  eventUid: string;
+  /** Null for a single event or a whole series. */
+  occurrenceStart: Date | null;
+  /** True when this ref names one occurrence rather than the series. */
+  isOccurrence: boolean;
+};
+declare const encodeRef: (calendarUid: string, eventUid: string, occurrenceStart?: Date | null) => string;
+declare const decodeRef: (raw: string) => CalendarRef;
+/** The series a ref belongs to. Identity for a ref that is already a series. */
+declare const seriesRefOf: (ref: CalendarRef) => string;
+/** The bare UUID inside an id, when there is one. Null is legitimate, not an error. */
+declare const uuidOf: (id: string) => string | null;
+//#endregion
+//#region src/server.d.ts
+declare const SERVER_NAME: string;
+declare const SERVER_VERSION: string;
+type CreateServerOptions = {
+  config: Config;
+  logger?: Logger;
+  /** Injected by tests so nothing spawns a process or touches a real Calendar. */
+  osascript?: OsascriptRunner;
+  /** Injected by tests so a relative range resolves against a frozen clock. */
+  now?: () => Date;
+};
+type CreatedServer = {
+  server: McpServer;
+  client: AppleCalendarClient;
+};
+/**
+ * Build the server. Side-effect free: it opens no connection, spawns no
+ * process and reads no file, so a test can construct it freely and every
+ * external dependency arrives through an option.
+ *
+ */
+declare const createServer: (opts: CreateServerOptions) => CreatedServer;
+//#endregion
+//#region src/tools/index.d.ts
+type ToolContext = {
+  /**
+   * Register the mutating tools too. Off by default — with the flag off they are
+   * not merely refused, they are invisible and cannot be called at all.
+   */
+  allowWrites: boolean;
+};
+/**
+ * Register the Apple Calendar tools.
+ *
+ * The registered set is a pure function of `allowWrites` and nothing else. In
+ * particular it does NOT vary with whether Full Disk Access is granted: that is
+ * a runtime condition which can change while the process lives, and MCP clients
+ * cache the tool list, so a tool that appears and disappears would leave clients
+ * calling names the server no longer has. Tools that need the store instead
+ * report their source, or explain what is missing.
+ *
+ * Writes go through Apple Events, always. Not a preference: `PRAGMA query_only`
+ * is set on the store because Calendar owns it, holds it open and reconciles it
+ * against a server, so writing to it would corrupt sync state.
+ */
+declare const registerTools: (server: McpServer, client: AppleCalendarClient, ctx: ToolContext) => void;
+//#endregion
+export { AppleCalendarClient, AppleCalendarError, BUILD_INFO, type BuildInfo, CALENDAR_BUNDLE_ID, CALENDAR_SURFACE, CalendarBusyError, CalendarNotFoundError, CalendarNotRunningError, CalendarNotWritableError, type CalendarRef, CalendarStore, type Config, type CreateClientOptions, type CreateServerOptions, EXTRAS_FILENAME, EventNotFoundError, GROUP_CONTAINER, InvalidDateError, type LaneStatus, type LocateResult, REF_VERSION, SERVER_NAME, SERVER_VERSION, STORE_FILENAME, type StoreCandidate, type StoreCapabilities, type ToolContext, createServer, decodeRef, defaultContainerPath, defaultStorePath, encodeRef, introspect, loadConfig, locateStore, openStore, registerTools, seriesRefOf, uuidOf };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/build-info.ts","../src/client/store.ts","../src/config.ts","../src/client/dates.ts","../src/client/locate.ts","../src/client/recurrence.ts","../src/client/calendar.ts","../src/client/errors.ts","../src/client/ref.ts","../src/server.ts","../src/tools/index.ts"],"mappings":"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"}

package/dist/index.js

@@ -0,0 +1,2 @@
+import { A as BUILD_INFO, C as CALENDAR_SURFACE, D as CalendarNotWritableError, E as CalendarNotRunningError, O as EventNotFoundError, S as CALENDAR_BUNDLE_ID, T as CalendarNotFoundError, _ as STORE_FILENAME, a as loadConfig, b as locateStore, c as introspect, d as decodeRef, f as encodeRef, g as GROUP_CONTAINER, h as EXTRAS_FILENAME, i as registerTools, k as InvalidDateError, l as openStore, m as uuidOf, n as SERVER_VERSION, o as AppleCalendarClient, p as seriesRefOf, r as createServer, s as CalendarStore, t as SERVER_NAME, u as REF_VERSION, v as defaultContainerPath, w as CalendarBusyError, x as AppleCalendarError, y as defaultStorePath } from "./server-B2HtiXLF.js";
+export { AppleCalendarClient, AppleCalendarError, BUILD_INFO, CALENDAR_BUNDLE_ID, CALENDAR_SURFACE, CalendarBusyError, CalendarNotFoundError, CalendarNotRunningError, CalendarNotWritableError, CalendarStore, EXTRAS_FILENAME, EventNotFoundError, GROUP_CONTAINER, InvalidDateError, REF_VERSION, SERVER_NAME, SERVER_VERSION, STORE_FILENAME, createServer, decodeRef, defaultContainerPath, defaultStorePath, encodeRef, introspect, loadConfig, locateStore, openStore, registerTools, seriesRefOf, uuidOf };