@remit/api-openapi-types 0.0.40 → 0.0.42

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remit/api-openapi-types",
-  "version": "0.0.40",
+  "version": "0.0.42",
   "type": "module",
   "main": "types.d.ts",
   "types": "types.d.ts",

package/types.d.ts

@@ -137,6 +137,34 @@ current enum emitter anyway, so the wire contract uses the bare form.
      * Lifecycle state of a smart-organize back-apply job (RFC 034, #1278). Mirrors the account-export job's lifecycle: a Pending row the worker picks up, drives to Running, then to a terminal Complete or Failed.
      */
     export type OrganizeJobState = "Pending" | "Running" | "Complete" | "Failed";
+    /**
+     * Display color for a calendar collection. Positional rather than named: the palette is a client-side concern, so the store carries the slot and the client owns what it renders (issue #15).
+     */
+    export type CalendarColor = "Cal1" | "Cal2" | "Cal3" | "Cal4" | "Cal5" | "Cal6";
+    /**
+     * Which iCalendar components a collection accepts (RFC 4791 supported-calendar-component-set). Only VEVENT is stored today; VTODO and VJOURNAL collections would be separate members, so the value is a property of the collection rather than of each object.
+     */
+    export type CalendarComponentSet = "VeventOnly";
+    /**
+     * Where a calendar collection came from. `Default` is the one provisioned per account config on first use and is never deleted; `UserCreated` is one a person made; `MailDerived` is one populated from mail rather than by a person.
+     */
+    export type CalendarSource = "Default" | "UserCreated" | "MailDerived";
+    /**
+     * Projection of a VEVENT's STATUS property (RFC 5545 3.8.1.11). A VEVENT with no STATUS projects as `Confirmed`, which is the value RFC 5545 gives an event whose status is unstated.
+     */
+    export type CalendarEventStatus = "Confirmed" | "Tentative" | "Cancelled";
+    /**
+     * Projection of a VEVENT's TRANSP property (RFC 5545 3.8.2.7) — whether the event consumes free/busy time. A VEVENT with no TRANSP projects as `Opaque`, the RFC default.
+     */
+    export type CalendarTransparency = "Opaque" | "Transparent";
+    /**
+     * How confidently a stored time was placed on the clock. A calendar that cannot say this hides its worst failure: an event read in the wrong zone is off by hours and looks exactly like an event read correctly.
+     */
+    export type ZoneCertainty = "Local" | "Explicit" | "Ambiguous";
+    /**
+     * Which occurrences of a recurring event a write applies to (issue #15). A request parameter, never a stored column: the resource records what the series is, and this records what the caller meant by editing one drawing of it.
+     */
+    export type RecurrenceScope = "This" | "Following" | "All";
     /**
      * Sort order for list operations
      */
@@ -391,6 +419,24 @@ a compile-time error rather than a value that silently sorts incorrectly.
        */
       details?: Record;
     }
+    /**
+     * Not found error response
+     */
+    export interface NotFoundError {
+      statusCode: 404;
+      error: ApiError;
+    }
+    /**
+     * The condition the request stated is no longer true. Answered when an
+`If-Match` names an etag the stored resource no longer carries: somebody else
+wrote it in between, so applying this request would silently discard their
+change. The client re-reads the resource and decides what to do with the
+version it now has.
+     */
+    export interface PreconditionFailedError {
+      statusCode: 412;
+      error: ApiError;
+    }
     /**
      * The same flat 409 body, with the two codes this endpoint can answer with.
 
@@ -439,13 +485,6 @@ a compile-time error rather than a value that silently sorts incorrectly.
       passthroughBehavior: "when_no_match";
       uri: any;
     }
-    /**
-     * Not found error response
-     */
-    export interface NotFoundError {
-      statusCode: 404;
-      error: ApiError;
-    }
     /**
      * Internal server error response
      */
@@ -2225,6 +2264,503 @@ standing to persist.
        */
       updatedAt: number;
     }
+    /**
+     * Every calendar collection of the caller's account config, url segment first. Unpaginated: an account holds a handful of calendars, and a page boundary in a sidebar is a bug waiting to happen.
+     */
+    export interface CalendarListResponse {
+      items: CalendarResponse[];
+    }
+    /**
+     * A calendar collection scoped to an account config (issue #15) — the CalDAV
+collection a client mounts, and the parent of every CalendarObject.
+
+`calendarId` is derived from `(accountConfigId, urlSegment)`, so the DAV path
+a client bookmarks resolves to a row without a lookup table, and provisioning
+the same collection twice writes the same row instead of a second one.
+`displayName` is the mutable human overlay and is never the key.
+
+`syncSequence` is the collection's monotonic change counter: every write
+through the calendar service's put path bumps it and stamps the new value on
+the object it wrote, which is what a later WebDAV-Sync `sync-token` reports
+and what `CalendarObject.bySyncSequence` pages by.
+     */
+    export interface CalendarCollection {
+      /**
+       * Primary identifier, derived from accountConfigId + urlSegment
+       */
+      calendarId: UUID;
+      /**
+       * Owning account configuration
+       */
+      accountConfigId: UUID;
+      /**
+       * Path segment this collection is addressed by, unique within the account config. Stored case-folded, the same folding `calendarId` is derived from — a DAV path is matched case-insensitively, and storing the writer's casing would let a lookup by segment and a lookup by derived id disagree about one path. The default collection provisioned on first use holds "default".
+       */
+      urlSegment: String64;
+      /**
+       * Human-readable collection name (display)
+       */
+      displayName: String140;
+      /**
+       * Display color slot for this collection
+       */
+      color: CalendarColor;
+      /**
+       * Which iCalendar components this collection accepts
+       */
+      componentSet: CalendarComponentSet;
+      /**
+       * Where this collection came from
+       */
+      source: CalendarSource;
+      /**
+       * IANA time zone this collection's floating times are read in, e.g. "Europe/Amsterdam". `""` when none is set, which reads as UTC.
+       */
+      timezone: String64;
+      /**
+       * Monotonic change counter for this collection. Bumped by every write to one of its objects; the value stamped on `CalendarObject.syncSequence` is the value this counter held after that write.
+       */
+      syncSequence: number;
+      createdAt: number;
+      updatedAt: number;
+    }
+    /**
+     * A calendar collection as the API returns it.
+     */
+    export interface CalendarResponse {
+      /**
+       * Primary identifier, derived from accountConfigId + urlSegment
+       */
+      calendarId: UUID;
+      /**
+       * Owning account configuration
+       */
+      accountConfigId: UUID;
+      /**
+       * Path segment this collection is addressed by, unique within the account config. Stored case-folded, the same folding `calendarId` is derived from — a DAV path is matched case-insensitively, and storing the writer's casing would let a lookup by segment and a lookup by derived id disagree about one path. The default collection provisioned on first use holds "default".
+       */
+      urlSegment: String64;
+      /**
+       * Human-readable collection name (display)
+       */
+      displayName: String140;
+      /**
+       * Display color slot for this collection
+       */
+      color: CalendarColor;
+      /**
+       * Which iCalendar components this collection accepts
+       */
+      componentSet: CalendarComponentSet;
+      /**
+       * Where this collection came from
+       */
+      source: CalendarSource;
+      /**
+       * IANA time zone this collection's floating times are read in, e.g. "Europe/Amsterdam". `""` when none is set, which reads as UTC.
+       */
+      timezone: String64;
+      /**
+       * Monotonic change counter for this collection. Bumped by every write to one of its objects; the value stamped on `CalendarObject.syncSequence` is the value this counter held after that write.
+       */
+      syncSequence: number;
+      createdAt: number;
+      updatedAt: number;
+    }
+    /**
+     * Input for creating a calendar collection (issue #15).
+
+`urlSegment` is supplied rather than derived from the display name: it is the
+collection's identity — `calendarId` is a hash of it — and the path a CalDAV
+client will later bookmark. Slugging a name would make two calendars called
+"Work" one row, and a rename would either move a bookmarked path or leave a
+segment that no longer matches anything a person recognises. The name is the
+mutable overlay; this is the address.
+     */
+    export interface CreateCalendarInput {
+      /**
+       * Human-readable collection name (display)
+       */
+      displayName: String140;
+      /**
+       * Path segment addressing this collection, unique within the account config. Case-folded on write, so "Work" and "work" name the same collection and the second create is refused rather than silently merged into the first.
+       */
+      urlSegment: String64;
+      /**
+       * Display colour slot. Absent takes the collection's own default.
+       */
+      color?: CalendarColor;
+      /**
+       * IANA time zone this collection's floating times are read in. Absent reads them as UTC.
+       */
+      timezone?: String64;
+    }
+    /**
+     * Input for updating a calendar collection. The name, colour and timezone are the mutable overlay; `urlSegment` is not among them, because it is the collection's identity and the path a client has bookmarked.
+     */
+    export interface UpdateCalendarInput {
+      /**
+       * Human-readable collection name (display)
+       */
+      displayName: String140;
+      /**
+       * Display color slot for this collection
+       */
+      color: CalendarColor;
+      /**
+       * IANA time zone this collection's floating times are read in, e.g. "Europe/Amsterdam". `""` when none is set, which reads as UTC.
+       */
+      timezone: String64;
+    }
+    /**
+     * Nothing to return. The resource, or the occurrence, is gone.
+     */
+    export interface CalendarNoContent {
+      statusCode: 204;
+    }
+    /**
+     * Expanded occurrences in the requested window, in start order.
+
+Includes an occurrence that began before `from` and runs into the window, up
+to a bounded lookback — a meeting that started last night is part of this
+morning. Unpaginated: the window is the bound.
+     */
+    export interface CalendarEventListResponse {
+      items: CalendarEventInstance[];
+    }
+    /**
+     * One occurrence of an event, in the window the caller asked for (issue #15).
+
+Instances are expanded by the server. A client never reads an RRULE and never
+reconstructs a series: it renders what this returns, and addresses one
+occurrence by `calendarObjectId` plus `recurrenceId`.
+     */
+    export interface CalendarEventInstance {
+      /**
+       * Collection this occurrence belongs to
+       */
+      calendarId: UUID;
+      /**
+       * Resource this occurrence was expanded from
+       */
+      calendarObjectId: UUID;
+      /**
+       * RECURRENCE-ID of this occurrence as an ISO 8601 UTC instant, or `""` for a resource that does not recur. This is the value a scoped write passes back to name the occurrence it means.
+       */
+      recurrenceId: String64;
+      /**
+       * The event's iCalendar UID, shared by every occurrence of the series
+       */
+      icalUid: String512;
+      /**
+       * Projection of the VEVENT's SUMMARY. `""` when the event carries none.
+       */
+      summary: String512;
+      /**
+       * When this occurrence starts, as an ISO 8601 date-time with zone offset, read in the collection's timezone. A business date, not an epoch instant: an all-day occurrence carries midnight of its civil date.
+       */
+      start: String64;
+      /**
+       * When this occurrence ends, as an ISO 8601 date-time with zone offset. Exclusive for an all-day occurrence, per RFC 5545 3.6.1.
+       */
+      end: String64;
+      /**
+       * Whether this occurrence is all-day
+       */
+      allDay: boolean;
+      /**
+       * Projection of the occurrence's STATUS
+       */
+      status: CalendarEventStatus;
+      /**
+       * Projection of the occurrence's TRANSP — whether it consumes free/busy time
+       */
+      transparency: CalendarTransparency;
+      /**
+       * How the resource's start was placed on the clock. `Ambiguous` means the resource named a zone nothing could resolve, so this occurrence may be hours out; a client says so rather than presenting the guess as a fact.
+       */
+      zoneCertainty: ZoneCertainty;
+      /**
+       * Entity tag of the resource this occurrence came from. Pass it as `If-Match` on a scoped write to refuse an edit built on a version somebody has since replaced.
+       */
+      etag: String64;
+      /**
+       * Whether the resource this occurrence came from expands to more than one instance. A client showing the recurrence-scope prompt gates on this.
+       */
+      hasRecurrence: boolean;
+    }
+    /**
+     * Input for creating an event (issue #15). The server builds the VEVENT and
+writes it through the single calendar write path, so an event created here,
+one accepted from an invitation, and one PUT over CalDAV are the same bytes
+written the same way.
+
+Times are ISO 8601 with zone offset — or a bare `YYYY-MM-DD` date when
+`allDay` is set. The offset pins the instant; `timeZone` names the zone the
+event is anchored in, which is what a recurring event needs to survive a DST
+transition. An offset alone cannot: a weekly 09:00 meeting written as
+`+02:00` becomes an 08:00 meeting in November.
+     */
+    export interface CreateCalendarEventInput {
+      /**
+       * Collection to write the event into
+       */
+      calendarId: UUID;
+      /**
+       * SUMMARY of the event
+       */
+      summary: String512;
+      /**
+       * DESCRIPTION of the event. Absent writes none.
+       */
+      description?: String2048;
+      /**
+       * LOCATION of the event. Absent writes none.
+       */
+      location?: String512;
+      /**
+       * When the event starts: an ISO 8601 date-time with zone offset, or a `YYYY-MM-DD` date when `allDay` is set.
+       */
+      start: String64;
+      /**
+       * When the event ends, in the same form as `start`. Exclusive for an all-day event, per RFC 5545 3.6.1.
+       */
+      end: String64;
+      /**
+       * Whether this is an all-day event, whose times are civil dates rather than instants
+       */
+      allDay?: boolean;
+      /**
+       * IANA time zone the event is anchored in, e.g. "Europe/Amsterdam", written as the DTSTART TZID. Absent anchors the event in UTC. Refused with 400 when the zone is one this server cannot resolve — a calendar that accepted an unknown zone would draw the event hours away from where it belongs.
+       */
+      timeZone?: String64;
+      /**
+       * STATUS of the event
+       */
+      status?: CalendarEventStatus;
+      /**
+       * TRANSP of the event — whether it consumes free/busy time
+       */
+      transparency?: CalendarTransparency;
+      /**
+       * RRULE value for a recurring event, e.g. "FREQ=WEEKLY;BYDAY=MO" (RFC 5545 3.8.5.3), without the property name. `""` creates a single event. Refused with 400 when it is not a rule this server can read.
+       */
+      recurrenceRule?: String512;
+    }
+    /**
+     * One calendar resource — the bytes behind one `.ics` URL (issue #15).
+
+`icalData` is the canonical value. Every other column on this row is a
+projection of it, computed on write and never written independently: a reader
+that needs a fact the projection does not carry re-parses `icalData` rather
+than adding a column that could disagree with it.
+
+The write path parses the bytes to validate and project them and then stores
+the bytes it was handed, never a reserialization of them. That is what keeps
+`etag` honest: the tag is a digest of exactly what the writer sent, so it
+moves only when a writer sends something different. It is not a digest that
+survives a round trip through the parser — ical.js refolds long lines and
+reorders properties, so a resource stored as its own reserialization would
+change tag without anyone editing it, and every client's cache would miss.
+
+`calendarObjectId` is derived from `(calendarId, resourceName)`: the resource
+name is the last path segment of the resource's URL, so the URL a client holds
+resolves to a row directly, and a repeated PUT of the same resource rewrites
+its own row.
+     */
+    export interface CalendarObject {
+      /**
+       * Primary identifier, derived from calendarId + resourceName
+       */
+      calendarObjectId: UUID;
+      /**
+       * Collection this resource belongs to
+       */
+      calendarId: UUID;
+      /**
+       * Last path segment of the resource's URL, e.g. "a1b2c3.ics". Unique within the collection and chosen by whoever wrote the resource, never derived from its contents — a client is free to rename a resource without changing the event it holds.
+       */
+      resourceName: String256;
+      /**
+       * The VEVENT's UID property (RFC 5545 3.8.4.7). Identifies the event across collections and servers, which `resourceName` does not.
+       */
+      icalUid: String512;
+      /**
+       * The complete VCALENDAR text, byte-for-byte as stored — CANONICAL. Line endings are CRLF and are never normalized; unknown properties and components are preserved verbatim.
+       */
+      icalData: string;
+      /**
+       * Strong entity tag over the stored `icalData` bytes, used for If-Match on a conditional write and for change detection on read.
+       */
+      etag: String64;
+      /**
+       * The VEVENT's SEQUENCE property (RFC 5545 3.8.7.4) — the organizer's own revision counter, carried for scheduling comparisons. `0` when the event declares none, which is the RFC default.
+       */
+      sequence: number;
+      /**
+       * Value the owning collection's `syncSequence` held after the write that produced this row. Pages the `bySyncSequence` read.
+       */
+      syncSequence: number;
+      /**
+       * Projection of the VEVENT's SUMMARY (RFC 5545 3.8.1.12). `""` when the event carries none.
+       */
+      summary: String512;
+      /**
+       * Projection of the master VEVENT's DTSTART as an ISO 8601 date-time with zone offset — a business date, not an epoch instant. An all-day event carries midnight in the event's own zone.
+       */
+      dtStart: String64;
+      /**
+       * Projection of the master VEVENT's effective end as an ISO 8601 date-time with zone offset, resolved from DTEND or from DTSTART + DURATION. An event with neither ends when it starts (RFC 5545 3.6.1).
+       */
+      dtEnd: String64;
+      /**
+       * Whether the master VEVENT's DTSTART is a DATE rather than a DATE-TIME (RFC 5545 3.3.4) — an all-day or multi-day event, whose end is exclusive.
+       */
+      allDay: boolean;
+      /**
+       * How the master VEVENT's DTSTART was placed on the clock. `Ambiguous` means the resource named a zone nothing could resolve, so `dtStart` and every occurrence expanded from it may be off by hours — a client shows the event and says so rather than presenting a guess as a fact.
+       */
+      zoneCertainty: ZoneCertainty;
+      /**
+       * Projection of the master VEVENT's STATUS
+       */
+      status: CalendarEventStatus;
+      /**
+       * Projection of the master VEVENT's TRANSP
+       */
+      transparency: CalendarTransparency;
+      /**
+       * Whether the resource expands to more than its master instance — an RRULE, an RDATE, or an override VEVENT. Overrides count on their own: a client that edits one instance and then drops the rule leaves a resource with a master and its exceptions, and each of those is still an occurrence.
+       */
+      hasRecurrence: boolean;
+      /**
+       * ISO 8601 UTC instant through which `CalendarEventIndex` rows exist for this resource, when the series runs past the expansion horizon and the index is therefore incomplete. `""` when the index is exhaustive — a single event, or a series that ends inside the horizon. A later live-expansion pass reads this to find the resources whose instances it must compute rather than query.
+       */
+      expandedThrough: String64;
+      createdAt: number;
+      updatedAt: number;
+    }
+    /**
+     * A stored calendar resource — the bytes behind one event, plus the columns projected from them. `icalData` is canonical; every other field is derived from it on write.
+     */
+    export interface CalendarEventResponse {
+      /**
+       * Primary identifier, derived from calendarId + resourceName
+       */
+      calendarObjectId: UUID;
+      /**
+       * Collection this resource belongs to
+       */
+      calendarId: UUID;
+      /**
+       * Last path segment of the resource's URL, e.g. "a1b2c3.ics". Unique within the collection and chosen by whoever wrote the resource, never derived from its contents — a client is free to rename a resource without changing the event it holds.
+       */
+      resourceName: String256;
+      /**
+       * The VEVENT's UID property (RFC 5545 3.8.4.7). Identifies the event across collections and servers, which `resourceName` does not.
+       */
+      icalUid: String512;
+      /**
+       * The complete VCALENDAR text, byte-for-byte as stored — CANONICAL. Line endings are CRLF and are never normalized; unknown properties and components are preserved verbatim.
+       */
+      icalData: string;
+      /**
+       * Strong entity tag over the stored `icalData` bytes, used for If-Match on a conditional write and for change detection on read.
+       */
+      etag: String64;
+      /**
+       * The VEVENT's SEQUENCE property (RFC 5545 3.8.7.4) — the organizer's own revision counter, carried for scheduling comparisons. `0` when the event declares none, which is the RFC default.
+       */
+      sequence: number;
+      /**
+       * Value the owning collection's `syncSequence` held after the write that produced this row. Pages the `bySyncSequence` read.
+       */
+      syncSequence: number;
+      /**
+       * Projection of the VEVENT's SUMMARY (RFC 5545 3.8.1.12). `""` when the event carries none.
+       */
+      summary: String512;
+      /**
+       * Projection of the master VEVENT's DTSTART as an ISO 8601 date-time with zone offset — a business date, not an epoch instant. An all-day event carries midnight in the event's own zone.
+       */
+      dtStart: String64;
+      /**
+       * Projection of the master VEVENT's effective end as an ISO 8601 date-time with zone offset, resolved from DTEND or from DTSTART + DURATION. An event with neither ends when it starts (RFC 5545 3.6.1).
+       */
+      dtEnd: String64;
+      /**
+       * Whether the master VEVENT's DTSTART is a DATE rather than a DATE-TIME (RFC 5545 3.3.4) — an all-day or multi-day event, whose end is exclusive.
+       */
+      allDay: boolean;
+      /**
+       * How the master VEVENT's DTSTART was placed on the clock. `Ambiguous` means the resource named a zone nothing could resolve, so `dtStart` and every occurrence expanded from it may be off by hours — a client shows the event and says so rather than presenting a guess as a fact.
+       */
+      zoneCertainty: ZoneCertainty;
+      /**
+       * Projection of the master VEVENT's STATUS
+       */
+      status: CalendarEventStatus;
+      /**
+       * Projection of the master VEVENT's TRANSP
+       */
+      transparency: CalendarTransparency;
+      /**
+       * Whether the resource expands to more than its master instance — an RRULE, an RDATE, or an override VEVENT. Overrides count on their own: a client that edits one instance and then drops the rule leaves a resource with a master and its exceptions, and each of those is still an occurrence.
+       */
+      hasRecurrence: boolean;
+      /**
+       * ISO 8601 UTC instant through which `CalendarEventIndex` rows exist for this resource, when the series runs past the expansion horizon and the index is therefore incomplete. `""` when the index is exhaustive — a single event, or a series that ends inside the horizon. A later live-expansion pass reads this to find the resources whose instances it must compute rather than query.
+       */
+      expandedThrough: String64;
+      createdAt: number;
+      updatedAt: number;
+    }
+    /**
+     * Input for updating an event. Every field is optional and absence means
+untouched — a patch that carries only `summary` renames the event and moves
+nothing.
+
+What the patch applies to is the `scope` parameter's business: `All` rewrites
+the master, `This` writes a RECURRENCE-ID override for one occurrence, and
+`Following` splits the series at one occurrence and applies the patch to the
+remainder.
+     */
+    export interface UpdateCalendarEventInput {
+      summary?: String512;
+      description?: String2048;
+      location?: String512;
+      start?: String64;
+      end?: String64;
+      allDay?: boolean;
+      timeZone?: String64;
+      status?: CalendarEventStatus;
+      transparency?: CalendarTransparency;
+      /**
+       * RRULE value, or `""` to drop the rule. Only meaningful with `scope=All` or `scope=Following`: an override is one occurrence and carries no rule of its own.
+       */
+      recurrenceRule?: String512;
+    }
+    /**
+     * Merged busy spans over the requested window, in start order. An event marked TRANSP:TRANSPARENT or STATUS:CANCELLED is not busy time and never appears here.
+     */
+    export interface CalendarFreeBusyResponse {
+      items: CalendarFreeBusySpan[];
+    }
+    /**
+     * One stretch of time the caller is busy in. Merged across every calendar they
+hold, so two overlapping meetings in two calendars are one span and a caller
+asking "is this slot free" never has to do the merging itself.
+     */
+    export interface CalendarFreeBusySpan {
+      /**
+       * When the busy stretch starts, as an ISO 8601 date-time with a `+00:00` offset. A busy span is an interval on the clock rather than a civil date, so it carries no calendar's local zone — the caller renders it in whichever zone it is drawing.
+       */
+      start: String64;
+      /**
+       * When the busy stretch ends, as an ISO 8601 date-time with a `+00:00` offset
+       */
+      end: String64;
+    }
     /**
      * Response from emptying trash
      */
@@ -4927,6 +5463,67 @@ domain already uses"; it does not close it.
       createdAt: number;
       updatedAt: number;
     }
+    /**
+     * One occurrence of a CalendarObject, flattened so a date range can be queried
+instead of expanded (issue #15). Every row is derived from
+`CalendarObject.icalData` and is replaced wholesale whenever that resource is
+written — nothing here is authoritative, and nothing writes here alone.
+
+`recurrenceId` is `""` for a resource that does not recur — its one row. A
+resource that does recur has no `""` row at all: every occurrence carries its
+own RECURRENCE-ID slot, the first one included, so an occurrence is
+addressable without a caller having to know whether it happened to be the
+series' first. It is part of the sort key, so it can never be absent — an
+optional value there would make the index sparse and hide the single-event
+row from the range read that has to return it.
+
+Times here are UTC instants, unlike `CalendarObject.dtStart`, which carries
+the event's own offset. The two are different jobs: `dtStart` is the value a
+client displays, and a fixed-width UTC instant is the only form in which a
+sort key orders correctly — comparing offset-bearing strings would sort
+`09:00+02:00` after `09:00Z`, and a range read would silently drop
+occurrences from every zone but its own.
+     */
+    export interface CalendarEventIndex {
+      /**
+       * Collection this occurrence belongs to
+       */
+      calendarId: UUID;
+      /**
+       * Resource this occurrence was expanded from
+       */
+      calendarObjectId: UUID;
+      /**
+       * RECURRENCE-ID of this occurrence as an ISO 8601 UTC instant, or `""` for the one row of a resource that does not recur. Canonicalized to UTC by the same rule the expansion uses, so an override's RECURRENCE-ID and the occurrence it replaces resolve to the same value.
+       */
+      recurrenceId: String64;
+      /**
+       * When this occurrence starts, as an ISO 8601 UTC instant. An all-day occurrence starts at midnight of its civil date read in the collection's timezone.
+       */
+      startAt: String64;
+      /**
+       * When this occurrence ends, as an ISO 8601 UTC instant. Exclusive for an all-day occurrence, per RFC 5545 3.6.1.
+       */
+      endAt: String64;
+      /**
+       * Whether this occurrence is all-day, copied from the resource it came from so a range read never has to join back to it. A client renders an all-day occurrence as the civil date its start falls on in the collection's timezone, not as the instant stored here.
+       */
+      allDay: boolean;
+      /**
+       * Projection of this occurrence's own SUMMARY. An overridden occurrence carries the override's, not the master's — an edit to one instance of a series is exactly the thing a range read must show, and a reader that took the summary from the master would draw the old title over the new one.
+       */
+      summary: String512;
+      /**
+       * Projection of this occurrence's own STATUS. Per occurrence for the same reason as `summary`: one cancelled instance of a series is cancelled, and reading the master's status would keep it in a free/busy answer.
+       */
+      status: CalendarEventStatus;
+      /**
+       * Projection of this occurrence's own TRANSP — whether it consumes free/busy time.
+       */
+      transparency: CalendarTransparency;
+      createdAt: number;
+      updatedAt: number;
+    }
     /**
      * Junction whose existence *is* a label assignment (RFC 030). Holds only ids
 and is hydrated with `batchGet`. Keyed by a deterministic UUID v5 derived
@@ -5260,6 +5857,130 @@ declare namespace Paths {
       export type $200 = void;
     }
   }
+  namespace ListCalendars {
+    namespace Responses {
+      export type $200 = void;
+    }
+  }
+  namespace CreateCalendar {
+    export type RequestBody = Components.Schemas.CreateCalendarInput;
+    namespace Responses {
+      export type $200 = void;
+      export type $400 = void;
+    }
+  }
+  namespace GetCalendar {
+    export interface PathParameters {
+      calendarId: Components.Schemas.UUID;
+    }
+    namespace Responses {
+      export type $200 = void;
+      export type $404 = void;
+    }
+  }
+  namespace UpdateCalendar {
+    export interface PathParameters {
+      calendarId: Components.Schemas.UUID;
+    }
+    export type RequestBody = Components.Schemas.UpdateCalendarInput;
+    namespace Responses {
+      export type $200 = void;
+      export type $400 = void;
+      export type $404 = void;
+    }
+  }
+  namespace DeleteCalendar {
+    export interface PathParameters {
+      calendarId: Components.Schemas.UUID;
+    }
+    namespace Responses {
+      export type $204 = void;
+      export type $400 = void;
+      export type $404 = void;
+    }
+  }
+  namespace ListCalendarEvents {
+    export interface QueryParameters {
+      from: string;
+      to: string;
+      calendarId?: Components.Schemas.UUID[];
+    }
+    namespace Responses {
+      export type $200 = void;
+      export type $400 = void;
+      export type $404 = void;
+    }
+  }
+  namespace CreateCalendarEvent {
+    export type RequestBody = Components.Schemas.CreateCalendarEventInput;
+    namespace Responses {
+      export type $200 = void;
+      export type $400 = void;
+      export type $404 = void;
+    }
+  }
+  namespace GetCalendarEvent {
+    export interface PathParameters {
+      calendarObjectId: Components.Schemas.UUID;
+    }
+    export interface QueryParameters {
+      calendarId: Components.Schemas.UUID;
+    }
+    namespace Responses {
+      export type $200 = void;
+      export type $400 = void;
+      export type $404 = void;
+    }
+  }
+  namespace UpdateCalendarEvent {
+    export interface PathParameters {
+      calendarObjectId: Components.Schemas.UUID;
+    }
+    export interface QueryParameters {
+      calendarId: Components.Schemas.UUID;
+      scope?: Components.Schemas.RecurrenceScope;
+      recurrenceId?: string;
+    }
+    export interface HeaderParameters {
+      ifMatch?: string;
+    }
+    export type RequestBody = Components.Schemas.UpdateCalendarEventInput;
+    namespace Responses {
+      export type $200 = void;
+      export type $400 = void;
+      export type $404 = void;
+      export type $412 = void;
+    }
+  }
+  namespace DeleteCalendarEvent {
+    export interface PathParameters {
+      calendarObjectId: Components.Schemas.UUID;
+    }
+    export interface QueryParameters {
+      calendarId: Components.Schemas.UUID;
+      scope?: Components.Schemas.RecurrenceScope;
+      recurrenceId?: string;
+    }
+    export interface HeaderParameters {
+      ifMatch?: string;
+    }
+    namespace Responses {
+      export type $204 = void;
+      export type $400 = void;
+      export type $404 = void;
+      export type $412 = void;
+    }
+  }
+  namespace ListCalendarFreeBusy {
+    export interface QueryParameters {
+      from: string;
+      to: string;
+    }
+    namespace Responses {
+      export type $200 = void;
+      export type $400 = void;
+    }
+  }
   namespace EmptyTrash {
     export interface PathParameters {
       accountId: Components.Schemas.UUID;
@@ -5793,6 +6514,122 @@ export interface OperationMethods {
     data?: any,
     config?: AxiosRequestConfig
   ): OperationResponse<Paths.GetOrganizeJob.Responses.$200>;
+  /**
+   * listCalendars - List the caller's calendar collections. Provisions the account config's default collection when it has none, so a first read never comes back empty and no client has to know how a calendar gets made.
+   */
+  'listCalendars'(
+    parameters?: Parameters<UnknownParamsObject> | null,
+    data?: any,
+    config?: AxiosRequestConfig
+  ): OperationResponse<Paths.ListCalendars.Responses.$200>;
+  /**
+   * createCalendar - Create a calendar collection. Refused with 400 when `urlSegment` is empty or already taken in this account config — the segment is the collection's identity, so a second create under the same one would otherwise silently return the collection that already exists.
+   */
+  'createCalendar'(
+    parameters?: Parameters<UnknownParamsObject> | null,
+    data?: Paths.CreateCalendar.RequestBody,
+    config?: AxiosRequestConfig
+  ): OperationResponse<Paths.CreateCalendar.Responses.$200>;
+  /**
+   * getCalendar
+   */
+  'getCalendar'(
+    parameters?: Parameters<Paths.GetCalendar.PathParameters> | null,
+    data?: any,
+    config?: AxiosRequestConfig
+  ): OperationResponse<Paths.GetCalendar.Responses.$200>;
+  /**
+   * updateCalendar
+   */
+  'updateCalendar'(
+    parameters?: Parameters<Paths.UpdateCalendar.PathParameters> | null,
+    data?: Paths.UpdateCalendar.RequestBody,
+    config?: AxiosRequestConfig
+  ): OperationResponse<Paths.UpdateCalendar.Responses.$200>;
+  /**
+   * deleteCalendar - Delete a calendar collection and every event in it. Refused with 400 for the account's default collection: it is the one place an accepted invitation or a first event can land, and an account with no calendar has nowhere to put an event.
+   */
+  'deleteCalendar'(
+    parameters?: Parameters<Paths.DeleteCalendar.PathParameters> | null,
+    data?: any,
+    config?: AxiosRequestConfig
+  ): OperationResponse<Paths.DeleteCalendar.Responses.$204>;
+  /**
+   * listCalendarEvents - Expanded event occurrences in a window. The server does the recurrence
+expansion and the client renders instances — no RRULE is ever evaluated
+in a browser, so a week grid and a day strip agree with each other and
+with what a native client will later read over CalDAV.
+
+Occurrences are served from the stored occurrence index. A series whose
+index stops before `to` — an open-ended event older than the expansion
+horizon — is expanded live for this window instead, and nothing
+unbounded is written to serve a read.
+
+Refused with 400 when `from` and `to` are not ISO 8601 date-times, when
+`to` is not after `from`, or when the window is wider than a year.
+   */
+  'listCalendarEvents'(
+    parameters?: Parameters<Paths.ListCalendarEvents.QueryParameters> | null,
+    data?: any,
+    config?: AxiosRequestConfig
+  ): OperationResponse<Paths.ListCalendarEvents.Responses.$200>;
+  /**
+   * createCalendarEvent - Create an event. The server builds the VEVENT and writes it through the single calendar write path — the same one an accepted invitation and a later CalDAV PUT go through — so the object, its expanded occurrences and the collection's sync sequence land together or not at all.
+   */
+  'createCalendarEvent'(
+    parameters?: Parameters<UnknownParamsObject> | null,
+    data?: Paths.CreateCalendarEvent.RequestBody,
+    config?: AxiosRequestConfig
+  ): OperationResponse<Paths.CreateCalendarEvent.Responses.$200>;
+  /**
+   * getCalendarEvent - Get one stored event, including its canonical iCalendar text and its etag.
+   */
+  'getCalendarEvent'(
+    parameters?: Parameters<Paths.GetCalendarEvent.PathParameters & Paths.GetCalendarEvent.QueryParameters> | null,
+    data?: any,
+    config?: AxiosRequestConfig
+  ): OperationResponse<Paths.GetCalendarEvent.Responses.$200>;
+  /**
+   * updateCalendarEvent - Update an event. `scope` says what the caller meant by editing one
+drawing of a series: `All` rewrites the master, `This` writes a
+RECURRENCE-ID override for the named occurrence, and `Following` splits
+the series — the master's rule is truncated and a second resource carries
+the remainder under a UID of its own.
+
+`recurrenceId` is required for `This` and `Following` and is refused with
+400 otherwise, along with a scope other than `All` on an event that does
+not recur, and a `recurrenceId` naming no occurrence of the series.
+
+`If-Match` makes the write conditional on the etag the caller read. A
+mismatch is 412: somebody replaced the resource in between, and applying
+this patch would discard their change without either of them seeing it.
+   */
+  'updateCalendarEvent'(
+    parameters?: Parameters<Paths.UpdateCalendarEvent.PathParameters & Paths.UpdateCalendarEvent.QueryParameters & Paths.UpdateCalendarEvent.HeaderParameters> | null,
+    data?: Paths.UpdateCalendarEvent.RequestBody,
+    config?: AxiosRequestConfig
+  ): OperationResponse<Paths.UpdateCalendarEvent.Responses.$200>;
+  /**
+   * deleteCalendarEvent - Delete an event. `All` removes the resource and every occurrence it
+produced; `This` writes an EXDATE for the named occurrence and keeps the
+rest of the series; `Following` truncates the series to end just before
+it.
+
+Same refusals and the same `If-Match` precondition as the update.
+   */
+  'deleteCalendarEvent'(
+    parameters?: Parameters<Paths.DeleteCalendarEvent.PathParameters & Paths.DeleteCalendarEvent.QueryParameters & Paths.DeleteCalendarEvent.HeaderParameters> | null,
+    data?: any,
+    config?: AxiosRequestConfig
+  ): OperationResponse<Paths.DeleteCalendarEvent.Responses.$204>;
+  /**
+   * listCalendarFreeBusy - Busy spans over a window, merged across every calendar the caller holds. Backs the clash check beside a mail invitation and the free-stretch maths in the day strip, neither of which should have to fetch every event and merge them itself. Refused with 400 on the same window rules as the event listing.
+   */
+  'listCalendarFreeBusy'(
+    parameters?: Parameters<Paths.ListCalendarFreeBusy.QueryParameters> | null,
+    data?: any,
+    config?: AxiosRequestConfig
+  ): OperationResponse<Paths.ListCalendarFreeBusy.Responses.$200>;
   /**
    * emptyTrash - Permanently delete all messages in the Trash mailbox
    */
@@ -6362,6 +7199,132 @@ export interface PathsDictionary {
       config?: AxiosRequestConfig
     ): OperationResponse<Paths.GetOrganizeJob.Responses.$200>;
   };
+  ['/calendars']: {
+    /**
+     * listCalendars - List the caller's calendar collections. Provisions the account config's default collection when it has none, so a first read never comes back empty and no client has to know how a calendar gets made.
+     */
+    'get'(
+      parameters?: Parameters<UnknownParamsObject> | null,
+      data?: any,
+      config?: AxiosRequestConfig
+    ): OperationResponse<Paths.ListCalendars.Responses.$200>;
+    /**
+     * createCalendar - Create a calendar collection. Refused with 400 when `urlSegment` is empty or already taken in this account config — the segment is the collection's identity, so a second create under the same one would otherwise silently return the collection that already exists.
+     */
+    'post'(
+      parameters?: Parameters<UnknownParamsObject> | null,
+      data?: Paths.CreateCalendar.RequestBody,
+      config?: AxiosRequestConfig
+    ): OperationResponse<Paths.CreateCalendar.Responses.$200>;
+  };
+  ['/calendars/{calendarId}']: {
+    /**
+     * getCalendar
+     */
+    'get'(
+      parameters?: Parameters<Paths.GetCalendar.PathParameters> | null,
+      data?: any,
+      config?: AxiosRequestConfig
+    ): OperationResponse<Paths.GetCalendar.Responses.$200>;
+    /**
+     * updateCalendar
+     */
+    'patch'(
+      parameters?: Parameters<Paths.UpdateCalendar.PathParameters> | null,
+      data?: Paths.UpdateCalendar.RequestBody,
+      config?: AxiosRequestConfig
+    ): OperationResponse<Paths.UpdateCalendar.Responses.$200>;
+    /**
+     * deleteCalendar - Delete a calendar collection and every event in it. Refused with 400 for the account's default collection: it is the one place an accepted invitation or a first event can land, and an account with no calendar has nowhere to put an event.
+     */
+    'delete'(
+      parameters?: Parameters<Paths.DeleteCalendar.PathParameters> | null,
+      data?: any,
+      config?: AxiosRequestConfig
+    ): OperationResponse<Paths.DeleteCalendar.Responses.$204>;
+  };
+  ['/calendar-events']: {
+    /**
+     * listCalendarEvents - Expanded event occurrences in a window. The server does the recurrence
+expansion and the client renders instances — no RRULE is ever evaluated
+in a browser, so a week grid and a day strip agree with each other and
+with what a native client will later read over CalDAV.
+
+Occurrences are served from the stored occurrence index. A series whose
+index stops before `to` — an open-ended event older than the expansion
+horizon — is expanded live for this window instead, and nothing
+unbounded is written to serve a read.
+
+Refused with 400 when `from` and `to` are not ISO 8601 date-times, when
+`to` is not after `from`, or when the window is wider than a year.
+     */
+    'get'(
+      parameters?: Parameters<Paths.ListCalendarEvents.QueryParameters> | null,
+      data?: any,
+      config?: AxiosRequestConfig
+    ): OperationResponse<Paths.ListCalendarEvents.Responses.$200>;
+    /**
+     * createCalendarEvent - Create an event. The server builds the VEVENT and writes it through the single calendar write path — the same one an accepted invitation and a later CalDAV PUT go through — so the object, its expanded occurrences and the collection's sync sequence land together or not at all.
+     */
+    'post'(
+      parameters?: Parameters<UnknownParamsObject> | null,
+      data?: Paths.CreateCalendarEvent.RequestBody,
+      config?: AxiosRequestConfig
+    ): OperationResponse<Paths.CreateCalendarEvent.Responses.$200>;
+  };
+  ['/calendar-events/{calendarObjectId}']: {
+    /**
+     * getCalendarEvent - Get one stored event, including its canonical iCalendar text and its etag.
+     */
+    'get'(
+      parameters?: Parameters<Paths.GetCalendarEvent.PathParameters & Paths.GetCalendarEvent.QueryParameters> | null,
+      data?: any,
+      config?: AxiosRequestConfig
+    ): OperationResponse<Paths.GetCalendarEvent.Responses.$200>;
+    /**
+     * updateCalendarEvent - Update an event. `scope` says what the caller meant by editing one
+drawing of a series: `All` rewrites the master, `This` writes a
+RECURRENCE-ID override for the named occurrence, and `Following` splits
+the series — the master's rule is truncated and a second resource carries
+the remainder under a UID of its own.
+
+`recurrenceId` is required for `This` and `Following` and is refused with
+400 otherwise, along with a scope other than `All` on an event that does
+not recur, and a `recurrenceId` naming no occurrence of the series.
+
+`If-Match` makes the write conditional on the etag the caller read. A
+mismatch is 412: somebody replaced the resource in between, and applying
+this patch would discard their change without either of them seeing it.
+     */
+    'patch'(
+      parameters?: Parameters<Paths.UpdateCalendarEvent.PathParameters & Paths.UpdateCalendarEvent.QueryParameters> | null,
+      data?: Paths.UpdateCalendarEvent.RequestBody,
+      config?: AxiosRequestConfig
+    ): OperationResponse<Paths.UpdateCalendarEvent.Responses.$200>;
+    /**
+     * deleteCalendarEvent - Delete an event. `All` removes the resource and every occurrence it
+produced; `This` writes an EXDATE for the named occurrence and keeps the
+rest of the series; `Following` truncates the series to end just before
+it.
+
+Same refusals and the same `If-Match` precondition as the update.
+     */
+    'delete'(
+      parameters?: Parameters<Paths.DeleteCalendarEvent.PathParameters & Paths.DeleteCalendarEvent.QueryParameters> | null,
+      data?: any,
+      config?: AxiosRequestConfig
+    ): OperationResponse<Paths.DeleteCalendarEvent.Responses.$204>;
+  };
+  ['/calendar-free-busy']: {
+    /**
+     * listCalendarFreeBusy - Busy spans over a window, merged across every calendar the caller holds. Backs the clash check beside a mail invitation and the free-stretch maths in the day strip, neither of which should have to fetch every event and merge them itself. Refused with 400 on the same window rules as the event listing.
+     */
+    'get'(
+      parameters?: Parameters<Paths.ListCalendarFreeBusy.QueryParameters> | null,
+      data?: any,
+      config?: AxiosRequestConfig
+    ): OperationResponse<Paths.ListCalendarFreeBusy.Responses.$200>;
+  };
   ['/accounts/{accountId}/trash/empty']: {
     /**
      * emptyTrash - Permanently delete all messages in the Trash mailbox
@@ -6729,10 +7692,11 @@ export type AccessPattern = Components.Schemas.AccessPattern;
 export type ResultList = Components.Schemas.ResultList;
 export type FolderRoleConflict = Components.Schemas.FolderRoleConflict;
 export type AppointFolderRoleConflict = Components.Schemas.AppointFolderRoleConflict;
+export type NotFoundError = Components.Schemas.NotFoundError;
+export type PreconditionFailedError = Components.Schemas.PreconditionFailedError;
 export type DeleteMessagesConflict = Components.Schemas.DeleteMessagesConflict;
 export type MessagePlacementConflict = Components.Schemas.MessagePlacementConflict;
 export type AmazonApiGatewayIntegration = Components.Schemas.AmazonApiGatewayIntegration;
-export type NotFoundError = Components.Schemas.NotFoundError;
 export type InternalServerError = Components.Schemas.InternalServerError;
 export type UnauthorizedError = Components.Schemas.UnauthorizedError;
 export type ForbiddenError = Components.Schemas.ForbiddenError;
@@ -6784,6 +7748,20 @@ export type CreateOrganizeJobResponse = Components.Schemas.CreateOrganizeJobResp
 export type OrganizePreviewResponse = Components.Schemas.OrganizePreviewResponse;
 export type OrganizeJobRequest = Components.Schemas.OrganizeJobRequest;
 export type OrganizeJobResponse = Components.Schemas.OrganizeJobResponse;
+export type CalendarListResponse = Components.Schemas.CalendarListResponse;
+export type CalendarCollection = Components.Schemas.CalendarCollection;
+export type CalendarResponse = Components.Schemas.CalendarResponse;
+export type CreateCalendarInput = Components.Schemas.CreateCalendarInput;
+export type UpdateCalendarInput = Components.Schemas.UpdateCalendarInput;
+export type CalendarNoContent = Components.Schemas.CalendarNoContent;
+export type CalendarEventListResponse = Components.Schemas.CalendarEventListResponse;
+export type CalendarEventInstance = Components.Schemas.CalendarEventInstance;
+export type CreateCalendarEventInput = Components.Schemas.CreateCalendarEventInput;
+export type CalendarObject = Components.Schemas.CalendarObject;
+export type CalendarEventResponse = Components.Schemas.CalendarEventResponse;
+export type UpdateCalendarEventInput = Components.Schemas.UpdateCalendarEventInput;
+export type CalendarFreeBusyResponse = Components.Schemas.CalendarFreeBusyResponse;
+export type CalendarFreeBusySpan = Components.Schemas.CalendarFreeBusySpan;
 export type EmptyTrashResponse = Components.Schemas.EmptyTrashResponse;
 export type SyncTriggerResponse = Components.Schemas.SyncTriggerResponse;
 export type AccountSyncStatusResponse = Components.Schemas.AccountSyncStatusResponse;
@@ -6872,6 +7850,7 @@ export type BodyPartParameter = Components.Schemas.BodyPartParameter;
 export type RawMessageStorage = Components.Schemas.RawMessageStorage;
 export type BodyPartStorage = Components.Schemas.BodyPartStorage;
 export type BodyPartContent = Components.Schemas.BodyPartContent;
+export type CalendarEventIndex = Components.Schemas.CalendarEventIndex;
 export type MessageLabel = Components.Schemas.MessageLabel;
 export type FilterAnchor = Components.Schemas.FilterAnchor;
 export type MicrosoftOAuthStartRequest = Components.Schemas.MicrosoftOAuthStartRequest;
@@ -6901,6 +7880,13 @@ export type FilterMatchOperator = Components.Schemas.FilterMatchOperator;
 export type FilterClauseField = Components.Schemas.FilterClauseField;
 export type LabelColor = Components.Schemas.LabelColor;
 export type OrganizeJobState = Components.Schemas.OrganizeJobState;
+export type CalendarColor = Components.Schemas.CalendarColor;
+export type CalendarComponentSet = Components.Schemas.CalendarComponentSet;
+export type CalendarSource = Components.Schemas.CalendarSource;
+export type CalendarEventStatus = Components.Schemas.CalendarEventStatus;
+export type CalendarTransparency = Components.Schemas.CalendarTransparency;
+export type ZoneCertainty = Components.Schemas.ZoneCertainty;
+export type RecurrenceScope = Components.Schemas.RecurrenceScope;
 export type SortOrder = Components.Schemas.SortOrder;
 export type StarColor = Components.Schemas.StarColor;
 export type MessageCategory = Components.Schemas.MessageCategory;