@wirecat/cli-core 0.488.0 → 0.490.0

package/CHANGELOG.md

@@ -7,6 +7,118 @@ shape of this file.
 
 ## Unreleased
 
+## 0.490.0 — 31.10.2026
+
+### Changed — may break callers
+
+- **Notes, documents, knowledge annotations and contacts `--notes` are found by any part of a word, in any letter
+  case (store version 40).** `notes` with a search, `knowledge.annotations` with a search and `contacts` with
+  `notes` used `instr(lower(...))`, which folds only Latin letters and reads every row: a mixed-case Cyrillic word
+  was missed, and a search took 1.5–4 s on a store five times today's size. They now match `note_trigrams` and
+  `document_trigrams`, trigram indexes over the normalized title and text (`ё` as `е`, accents dropped) that the
+  notes drain keeps, and answer in milliseconds. A query of one or two characters is refused with "search needs at
+  least three characters", as message search is; an empty one still filters nothing. The title is searched too,
+  not only the text. The notes and documents stored before version 40 get their trigrams in batches from the
+  notes drain (`search notes`, `store migrate`); until then they are matched as before.
+
+## 0.489.0 — 31.10.2026
+
+### Added
+
+- **`events list changed:<date>`: what changed since a date.** It keeps the events first stored, moved, or cancelled
+  or removed since then, from the local copy, each with `change` (`new`, `moved`, `cancelled`), `changed_at` and, for
+  a moved one, `was` (`starts_at`, `ends_at`). A move counts when a copy's time now differs from its time at the date,
+  so a meeting moved and moved back is no change. MCP `events_list` takes the same word. New `EventFilter.changedSince`,
+  `EventStore.historyOf` and `eventChange`, from `@wirecat/cli-core/meetings`.
+- **`events list overlapping`: meetings that clash.** It keeps timed events that overlap another one, each with
+  `overlaps` (`event:<id>` of the others). An event counts only when it takes the owner's time: not cancelled, not
+  all-day, with a copy the owner did not decline or mark free. New `EventFilter.overlapping`.
+- **Changing or deleting "this and all following" occurrences.** `events update <occurrence> --following` (MCP
+  `following: true`) ends the series with UNTIL just before the occurrence and starts a new series there with the
+  change. The new series keeps the attendees, and the EXDATE and RDATE dates from the split on. It is built from the
+  writer's `create` and `update`, so no adapter needs code for it. The new series is made first, under an id
+  journaled before the call; if ending the old series then fails, the error names that id, and a retry with `--id`
+  finds the series instead of making a second one. A COUNT series needs `--repeat` for the new part
+  (`event.repeat-count`). `events delete <occurrence> --following` only ends the series. `WriteScope` stays
+  `this | series` for writers; `FollowingScope` adds `following`.
+- **Moving an event to another calendar of the same account.** `CalendarWriter` gains an optional
+  `move(calendar, externalId, target, { etag, notify })`. With it, `events move <event> --to-calendar <id>` (MCP
+  `event_move`, `to_calendar`) moves the event with its id. Its key is `events.move`, plus `extraKeys("move")`;
+  `CalendarWrite` gains `move`. It refuses a calendar of another account, the same calendar, a read-only calendar
+  (`calendar.read-only`), an event type other than `default` (`event.unmovable`), and an occurrence without
+  `--series`. The store cancels the old copy and saves the new one under the same UID.
+- **The contract kits cover both.** `calendarWriterContract` runs the "following" split over `memoryEventStore`
+  (earlier slots kept, the new series from the occurrence, no second series on a retry after a lost answer). With
+  `CalendarWriterFixture.target` and a writer that has `move`, it also checks a move: id kept, old etag a conflict,
+  retry finds the event. `fakeCalendarWriter` moves.
+
+### Changed — may break callers
+
+- **Calendar writes that are easy to undo go ahead by default, as tg's and drive's writes do.** In
+  `CALENDAR_WRITE_DEFAULTS`, `events.create`, `events.update`, `events.respond` and the new `events.move` are
+  `allow` (were `ask`). `events.delete` stays `ask`, and it also covers `--following`. `events.delete.series` and
+  `events.notify` stay `deny`, so mailing attendees still needs the owner's yes. A profile that wants a question
+  first sets the key to `ask`.
+- **A calendar series update whose new rule ends it sooner also needs `events.delete.series`,** which is `deny` by
+  default. `events update --series --repeat` with a COUNT or UNTIL that drops slots the series had (a bound added, an
+  earlier UNTIL, a smaller COUNT, or a bound of the other kind) deleted the later slots under `events.update` alone; it
+  now takes the same key as deleting the series. A rule with no end, or a later one, still needs only
+  `events.update`.
+- **A calendar `sync` with a failed calendar prints nothing on stdout, and `sync.partial` carries the whole result.**
+  It printed the report and then failed, so stdout held an answer and the run was a failure (WC-OUT-14). Now the
+  error's message lists each failed calendar as `calendar <id> (<title>): <error>`, `details.calendars` holds every
+  synced calendar's `calendar_id`, `external_id`, `title`, `round`, `state`, `saved`, `removed`, `occurrences` and, on a
+  failed one, `error`, and the error says `retry.safe: true` (`retryable: true`, `sent: false`: a sync sends the
+  provider no write). A host that queues the report and prints it before the error must stop doing so.
+- **`EventStore` gains `slotsOf`, and `LinkReview` gains `calendarId`** (the calendar of a `calendar_entry` review's
+  copy). `resolveAnswer` takes the account id after the store.
+- **`EventStore` gains `saveSlots`**, which saves several series' slots and the sync cursor in one transaction.
+
+- **`EventStore` gains `participantsOf(eventIds, calendarIds)`**: the participants of those events' copies on those
+  calendars, in one read.
+
+- **`StoredEntry` gains `createdAt` and `transparency`, and `EventStore` gains `historyOf`.**
+
+### Fixed
+
+- **A calendar sync commits a few times per calendar, not twice per repeating event.** The slots of up to 50 series
+  (250 slots) and the cursor go in one transaction. On a 20,000-event store with 819 weekly series (engine and SQLite
+  store, fake provider): 123 write transactions instead of 1,663 for a full round.
+- **The daily full round asks only the series that changed for their slots.** A series with the stored etag and slots
+  stored in the window keeps them; every series is asked again once a week, and on `--rescan`. On the same store the
+  next day's full round made 0 `instances` requests instead of 819 and took 6.7 s instead of 15.1 s. A series that does
+  not change lacks at most 7 days of slots at the window's far end, three months ahead.
+
+- **The daily full calendar sync no longer marks events outside its window as deleted.** A full list returns only
+  what falls in the window (a year back, three months ahead), but `markUnseen` limited only plain occurrences to it,
+  so every older or later single event, moved occurrence and ended series was marked deleted, and its event cancelled
+  or marked gone at the source. It now marks only what `entryInWindow` (new, from `@wirecat/cli-core/meetings`) puts
+  in the window. Stores already damaged heal on their next sync: each calendar runs the new
+  `EventStore.restoreUnseen` once, which brings back the entries marked outside the window of the list that marked
+  them, with their events. A rescan cannot do this, since it never lists them again. Implementations of `EventStore`
+  outside cli-core need `restoreUnseen`.
+- **A repeating event moved to another time no longer keeps its slots at the old time.** An incremental sync saved the
+  slots the provider gave for the series and left the old ones scheduled. Now the series' stored plain slots in the
+  window that the provider no longer gives are cancelled.
+- **A `sync --rescan` its budget stopped no longer leaves calendars it did not reach on incremental rounds.** The rescan
+  is saved as each calendar's round before the first request, so the next plain `sync` lists those in full.
+- **A create the provider made but the store failed to save names the event's id.** The error carries
+  `operation_id` and `id` and says to sync, or to repeat with `--id`, which finds the event instead of making it again.
+  The same for the new series of `events update --following`.
+- **`links resolve` no longer changes a link choice of another account's calendar.** It refuses with
+  `permission_error`; `links review` still lists every account's choices.
+- **`events list` by time seeks the time index, and `people list` reads attendees in one query.** The list query put
+  both time bounds inside `CASE WHEN all_day`, so SQLite scanned the events from the start of the window; plain bounds
+  on `starts_at`, wider than the exact ones (back by the longest stored event plus a day, forward by a day), now let it
+  seek. `people list` read each of up to 1,000 events with five queries. On a 20,000-event store: `events list` today
+  12.5 → 2 ms, `people list` for a week 83 → 15 ms, same answers.
+
+- **The store's `node:sqlite` driver prepares each SQL text once per connection.** It prepared every statement again
+  on every call, which was a quarter of a gcal sync's time. Each connection now keeps up to 1,000 prepared
+  statements (least recently used out first) and finalizes them on `close()`. gcal 0.1.1's first sync of a synthetic
+  calendar ran 2.5–2.7 times faster (5,000 events: 6.7 → 2.5 s; 50,000: 68 → 28 s). `prepare()` with the same SQL
+  now returns the same statement. Bun's driver already cached through `db.query()`.
+
 ## 0.488.0 — 30.10.2026
 
 ### Added

package/dist/calendar/cli/index.js

@@ -12,7 +12,7 @@ import { BUSY_QUERY_HELP, busyAnswer, busyQuery, workingHoursOf } from "../busy.
 import { CALENDAR_UNTRUSTED_FIELDS, calendarIn, calendarItem, EVENTS_QUERY_HELP, eventAnswer, eventIdOf, eventOf, eventsAnswer, eventsFilter, peopleAnswer, resolveAnswer, reviewsAnswer, } from "../reads.js";
 import { REPEAT_HELP } from "../recurrence.js";
 import { calendarStatus, syncCalendars } from "../sync.js";
-import { createEvent, deleteEvent, EVENT_RESPONSES, respondToEvent, updateEvent, } from "../writes.js";
+import { createEvent, deleteEvent, EVENT_RESPONSES, moveEvent, respondToEvent, updateEvent, } from "../writes.js";
 const LOCAL_READ = { remote: "none", local: "read" };
 const LOCAL_WRITE = { remote: "none", local: "write" };
 const FETCH = { remote: "read", local: "write" };
@@ -168,11 +168,28 @@ const addCalendarCommandsDefinition = (program, deps) => {
                 : report.hint;
         if (report.hint === undefined)
             delete report.hint;
-        print({ ...report, ...(embeddings === undefined ? {} : { embeddings }), ...(next ? { next } : {}) }, command);
-        if (report.synced.some((one) => one.error !== undefined))
-            throw new CliError("provider_error", "some calendars did not sync; run sync again to retry them", {
+        const failed = report.synced.filter((one) => one.error !== undefined);
+        if (failed.length)
+            // A failure prints nothing on stdout (WC-OUT-14), so the error carries every calendar's result.
+            throw new CliError("provider_error", `${failed.map((one) => `calendar ${one.calendarId} (${one.title ?? one.externalId}): ${one.error}`).join("; ")}` +
+                " — run sync again to retry", {
                 reason: "sync.partial",
+                calendars: report.synced.map((one) => ({
+                    calendar_id: String(one.calendarId),
+                    external_id: one.externalId,
+                    title: one.title,
+                    round: one.round,
+                    state: one.state,
+                    saved: one.saved,
+                    removed: one.removed,
+                    occurrences: one.occurrences,
+                    ...(one.error === undefined ? {} : { error: one.error }),
+                })),
+                retryable: true,
+                // A sync sends the provider no write, so running it again changes nothing there.
+                sent: false,
             });
+        print({ ...report, ...(embeddings === undefined ? {} : { embeddings }), ...(next ? { next } : {}) }, command);
     });
     output(example(annotate(program.command("status"), { effects: LOCAL_READ }).description("how far each synced calendar's sync is: entries done, partial or complete, and when it last moved"), "status --json")).action(async (_opts, command) => {
         print(await calendarStatus(deps.store, deps.accountId, {
@@ -261,7 +278,7 @@ const addCalendarCommandsDefinition = (program, deps) => {
         .description("join a copy to the event you choose, or keep it apart")
         .argument("<review>", "the review's id from links review")
         .argument("<choice>", "one of its candidates, as event:<id>, or apart"), "links resolve 7 event:42")).action(async (review, choice, _opts, command) => {
-        print(await resolveAnswer(deps.store, review, choice, now()), command);
+        print(await resolveAnswer(deps.store, deps.accountId, review, choice, now()), command);
     });
 };
 const collect = (value, previous = []) => [...previous, value];
@@ -278,6 +295,7 @@ const addEventWrites = (events, writes, { deps, now, zone, output, print, exampl
             id: "--id",
             calendar: "--calendar",
             series: "--series",
+            following: "--following",
             repeat: "--repeat",
         },
     });
@@ -302,9 +320,10 @@ const addEventWrites = (events, writes, { deps, now, zone, output, print, exampl
         ...Object.fromEntries(Object.entries(given).filter(([, value]) => value !== undefined)),
         ...(attendee === undefined || attendee.length === 0 ? {} : { attendees: attendee }),
     });
-    const choicesOf = ({ calendar, series, notify }) => ({
+    const choicesOf = ({ calendar, series, following, notify }) => ({
         ...(calendar === undefined ? {} : { calendar }),
         ...(series ? { series: true } : {}),
+        ...(following ? { following: true } : {}),
         ...(notify === undefined ? {} : { notify }),
     });
     const write = (name) => annotate(events.command(name), { effects: REMOTE_WRITE, offline: false });
@@ -323,17 +342,33 @@ const addEventWrites = (events, writes, { deps, now, zone, output, print, exampl
         }), command);
     });
     output(example(notify(target(fields(write("update"), true))
-        .description("change an event; with --series every occurrence of the repeating event; new times or dates switch it " +
-        "between timed and all-day")
-        .option("--series", "change the whole repeating event, not only this occurrence")), "events update event:42 --start-time 2026-11-02T14:00 --end-time 2026-11-02T15:00 --notify", "events update event:42 --series --repeat 'FREQ=WEEKLY;BYDAY=TU;UNTIL=20261231T230000Z' --no-notify")).action(async (reference, opts, command) => {
-        const { calendar: _calendar, series: _series, notify: _notify, ...rest } = opts;
-        printWritten(await updateEvent(context(command), reference, fieldsOf(rest), choicesOf(opts)), command);
+        .description("change an event; with --series every occurrence of the repeating event, with --following this " +
+        "occurrence and every later one; new times or dates switch it between timed and all-day")
+        .option("--series", "change the whole repeating event, not only this occurrence")
+        .option("--following", "change this occurrence and every later one: the repeating event ends before it and a new one starts " +
+        "with the change")
+        .option("--id <id>", "with --following, the id an outcome_unknown named: a retry finds that new series")), "events update event:42 --start-time 2026-11-02T14:00 --end-time 2026-11-02T15:00 --notify", "events update event:42 --series --repeat 'FREQ=WEEKLY;BYDAY=TU;UNTIL=20261231T230000Z' --no-notify", "events update event:42 --following --start-time 2026-11-09T10:00 --end-time 2026-11-09T10:30 --no-notify")).action(async (reference, opts, command) => {
+        const { calendar: _calendar, series: _series, following: _following, notify: _notify, id, ...rest } = opts;
+        printWritten(await updateEvent(context(command), reference, fieldsOf(rest), {
+            ...choicesOf(opts),
+            ...(id === undefined ? {} : { id }),
+        }), command);
     });
     output(example(notify(target(write("delete"))
-        .description("delete an event; a whole repeating event needs events.delete.series allowed first")
-        .option("--series", "delete the whole repeating event, not only this occurrence")), "events delete event:42 --no-notify")).action(async (reference, opts, command) => {
+        .description("delete an event; a whole repeating event, or every later occurrence, needs events.delete.series " +
+        "allowed first")
+        .option("--series", "delete the whole repeating event, not only this occurrence")
+        .option("--following", "delete this occurrence and every later one: the repeating event ends before it")), "events delete event:42 --no-notify", "events delete event:42 --following --no-notify")).action(async (reference, opts, command) => {
         printWritten(await deleteEvent(context(command), reference, choicesOf(opts)), command);
     });
+    if (writes.writer.move)
+        output(example(notify(target(write("move"))
+            .description("move an event, with its id, to another calendar of the account; a repeating one moves whole")
+            .requiredOption("--to-calendar <id>", "the calendar to move it to: its id, or the provider's id")
+            .option("--series", "move the whole repeating event an occurrence belongs to")), "events move event:42 --to-calendar 4 --no-notify")).action(async (reference, opts, command) => {
+            const { series, calendar, notify } = opts;
+            printWritten(await moveEvent(context(command), reference, opts.toCalendar, choicesOf({ series, calendar, notify })), command);
+        });
     output(example(notify(target(write("respond"))
         .description("answer an invitation; the organiser is told only with --notify")
         .addArgument(new Argument("<response>", "the answer").choices(EVENT_RESPONSES))), "events respond event:42 accepted --notify")).action(async (reference, response, opts, command) => {

package/dist/calendar/index.d.ts

@@ -2,5 +2,5 @@ export type { CalendarAccessRole, CalendarInput, EntryAttachment, EntryAttachmen
 export { repeatRule } from "./recurrence.js";
 export type { BusyTimes, CalendarExpander, CalendarSource, CalendarSourceTraits, ChangePage, ChangeResult, FreeBusyRequest, SyncWindow, } from "./source.js";
 export { type CalendarCursor, type CalendarSyncOptions, type CalendarSyncReport, type CalendarSyncResult, calendarStatus, calendarSyncWindow, type PendingRound, parseCalendarCursor, syncCalendars, } from "./sync.js";
-export { CALENDAR_WRITE_DEFAULTS, CALENDAR_WRITE_KEYS, type CalendarWrite, type CalendarWriter, calendarConflict, EVENTS_DELETE_SERIES_KEY, EVENTS_NOTIFY_KEY, type EventDraft, type EventPatch, type EventResponse, type WriteScope, } from "./writer.js";
+export { CALENDAR_WRITE_DEFAULTS, CALENDAR_WRITE_KEYS, type CalendarWrite, type CalendarWriter, calendarConflict, EVENTS_DELETE_SERIES_KEY, EVENTS_NOTIFY_KEY, type EventDraft, type EventPatch, type EventResponse, type FollowingScope, type WriteScope, } from "./writer.js";
 export type { CalendarWrites } from "./writes.js";

package/dist/calendar/mcp/index.d.ts

@@ -391,10 +391,19 @@ export declare const calendarWriteTools: ({
             series: {
                 type: string;
             };
+            following: {
+                type: string;
+                description: string;
+            };
             notify: {
                 type: string;
                 description: string;
             };
+            id: {
+                type: string;
+                minLength: number;
+                description: string;
+            };
         } | {
             account_id: {
                 type: string;
@@ -412,6 +421,36 @@ export declare const calendarWriteTools: ({
             series: {
                 type: string;
             };
+            following: {
+                type: string;
+                description: string;
+            };
+            notify: {
+                type: string;
+                description: string;
+            };
+        } | {
+            account_id: {
+                type: string;
+                minimum: number;
+            };
+            event: {
+                type: string;
+                minLength: number;
+            };
+            calendar: {
+                type: string;
+                minLength: number;
+                description: string;
+            };
+            to_calendar: {
+                type: string;
+                minLength: number;
+                description: string;
+            };
+            series: {
+                type: string;
+            };
             notify: {
                 type: string;
                 description: string;
@@ -586,6 +625,40 @@ export declare const calendarWriteTools: ({
             series: {
                 type: string;
             };
+            following: {
+                type: string;
+                description: string;
+            };
+            notify: {
+                type: string;
+                description: string;
+            };
+            id: {
+                type: string;
+                minLength: number;
+                description: string;
+            };
+        } | {
+            account_id: {
+                type: string;
+                minimum: number;
+            };
+            event: {
+                type: string;
+                minLength: number;
+            };
+            calendar: {
+                type: string;
+                minLength: number;
+                description: string;
+            };
+            series: {
+                type: string;
+            };
+            following: {
+                type: string;
+                description: string;
+            };
             notify: {
                 type: string;
                 description: string;
@@ -604,6 +677,11 @@ export declare const calendarWriteTools: ({
                 minLength: number;
                 description: string;
             };
+            to_calendar: {
+                type: string;
+                minLength: number;
+                description: string;
+            };
             series: {
                 type: string;
             };
@@ -781,6 +859,40 @@ export declare const calendarWriteTools: ({
             series: {
                 type: string;
             };
+            following: {
+                type: string;
+                description: string;
+            };
+            notify: {
+                type: string;
+                description: string;
+            };
+            id: {
+                type: string;
+                minLength: number;
+                description: string;
+            };
+        } | {
+            account_id: {
+                type: string;
+                minimum: number;
+            };
+            event: {
+                type: string;
+                minLength: number;
+            };
+            calendar: {
+                type: string;
+                minLength: number;
+                description: string;
+            };
+            series: {
+                type: string;
+            };
+            following: {
+                type: string;
+                description: string;
+            };
             notify: {
                 type: string;
                 description: string;
@@ -799,6 +911,11 @@ export declare const calendarWriteTools: ({
                 minLength: number;
                 description: string;
             };
+            to_calendar: {
+                type: string;
+                minLength: number;
+                description: string;
+            };
             series: {
                 type: string;
             };
@@ -976,6 +1093,66 @@ export declare const calendarWriteTools: ({
             series: {
                 type: string;
             };
+            following: {
+                type: string;
+                description: string;
+            };
+            notify: {
+                type: string;
+                description: string;
+            };
+            id: {
+                type: string;
+                minLength: number;
+                description: string;
+            };
+        } | {
+            account_id: {
+                type: string;
+                minimum: number;
+            };
+            event: {
+                type: string;
+                minLength: number;
+            };
+            calendar: {
+                type: string;
+                minLength: number;
+                description: string;
+            };
+            series: {
+                type: string;
+            };
+            following: {
+                type: string;
+                description: string;
+            };
+            notify: {
+                type: string;
+                description: string;
+            };
+        } | {
+            account_id: {
+                type: string;
+                minimum: number;
+            };
+            event: {
+                type: string;
+                minLength: number;
+            };
+            calendar: {
+                type: string;
+                minLength: number;
+                description: string;
+            };
+            to_calendar: {
+                type: string;
+                minLength: number;
+                description: string;
+            };
+            series: {
+                type: string;
+            };
             notify: {
                 type: string;
                 description: string;
@@ -994,6 +1171,219 @@ export declare const calendarWriteTools: ({
                 minLength: number;
                 description: string;
             };
+            response: {
+                type: string;
+                enum: readonly EventResponse[];
+            };
+            notify: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+        additionalProperties: boolean;
+    };
+    annotations: {
+        readOnlyHint: boolean;
+        destructiveHint: boolean;
+        idempotentHint: boolean;
+        openWorldHint: boolean;
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            title: {
+                type: string;
+                minLength: number;
+            };
+            start_time: {
+                type: string;
+                minLength: number;
+                description: string;
+            };
+            end_time: {
+                type: string;
+                minLength: number;
+                description: string;
+            };
+            start_date: {
+                type: string;
+                minLength: number;
+                description: string;
+            };
+            end_date: {
+                type: string;
+                minLength: number;
+                description: string;
+            };
+            timezone: {
+                type: string;
+                minLength: number;
+            };
+            location: {
+                type: string;
+                description: string;
+            };
+            description: {
+                type: string;
+                description: string;
+            };
+            attendees: {
+                type: string;
+                items: {
+                    type: string;
+                    minLength: number;
+                };
+                description: string;
+            };
+            repeat: {
+                type: string;
+                minLength: number;
+                description: string;
+            };
+            account_id: {
+                type: string;
+                minimum: number;
+            };
+            calendar: {
+                type: string;
+                minLength: number;
+            };
+            notify: {
+                type: string;
+                description: string;
+            };
+            id: {
+                type: string;
+                minLength: number;
+                description: string;
+            };
+        } | {
+            title: {
+                type: string;
+                minLength: number;
+            };
+            start_time: {
+                type: string;
+                minLength: number;
+                description: string;
+            };
+            end_time: {
+                type: string;
+                minLength: number;
+                description: string;
+            };
+            start_date: {
+                type: string;
+                minLength: number;
+                description: string;
+            };
+            end_date: {
+                type: string;
+                minLength: number;
+                description: string;
+            };
+            timezone: {
+                type: string;
+                minLength: number;
+            };
+            location: {
+                type: string;
+                description: string;
+            };
+            description: {
+                type: string;
+                description: string;
+            };
+            attendees: {
+                type: string;
+                items: {
+                    type: string;
+                    minLength: number;
+                };
+                description: string;
+            };
+            repeat: {
+                type: string;
+                minLength: number;
+                description: string;
+            };
+            account_id: {
+                type: string;
+                minimum: number;
+            };
+            event: {
+                type: string;
+                minLength: number;
+            };
+            calendar: {
+                type: string;
+                minLength: number;
+                description: string;
+            };
+            series: {
+                type: string;
+            };
+            following: {
+                type: string;
+                description: string;
+            };
+            notify: {
+                type: string;
+                description: string;
+            };
+            id: {
+                type: string;
+                minLength: number;
+                description: string;
+            };
+        } | {
+            account_id: {
+                type: string;
+                minimum: number;
+            };
+            event: {
+                type: string;
+                minLength: number;
+            };
+            calendar: {
+                type: string;
+                minLength: number;
+                description: string;
+            };
+            series: {
+                type: string;
+            };
+            following: {
+                type: string;
+                description: string;
+            };
+            notify: {
+                type: string;
+                description: string;
+            };
+        } | {
+            account_id: {
+                type: string;
+                minimum: number;
+            };
+            event: {
+                type: string;
+                minLength: number;
+            };
+            calendar: {
+                type: string;
+                minLength: number;
+                description: string;
+            };
+            to_calendar: {
+                type: string;
+                minLength: number;
+                description: string;
+            };
             series: {
                 type: string;
             };