@remit/api-http-client 0.0.38 → 0.0.40

package/types.gen.ts

@@ -38,6 +38,16 @@ export type MicrosoftOAuthStartResponse = {
     authorizationUrl: string;
 };
 
+/**
+ * Body of `POST /calendar-suggestions/{suggestionId}/accept`. Names the collection the event is written into; there is no default, because filing someone else's invitation into a calendar the user did not pick is a decision the server does not get to make.
+ */
+export type RemitImapAcceptCalendarSuggestionInput = {
+    /**
+     * Collection the accepted event is written into.
+     */
+    calendarId: Uuid;
+};
+
 /**
  * Authentication mechanism used by an email account
  */
@@ -553,6 +563,345 @@ export type RemitImapBulkUpdateFlagsInput = {
     starColor?: RemitImapStarColor;
 };
 
+/**
+ * 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 RemitImapCalendarColor = '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 RemitImapCalendarComponentSet = 'VeventOnly';
+
+/**
+ * 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 type RemitImapCalendarEventInstance = {
+    /**
+     * 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: RemitImapCalendarEventStatus;
+    /**
+     * Projection of the occurrence's TRANSP — whether it consumes free/busy time
+     */
+    transparency: RemitImapCalendarTransparency;
+    /**
+     * 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: RemitImapZoneCertainty;
+    /**
+     * 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;
+};
+
+/**
+ * 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 type RemitImapCalendarEventListResponse = {
+    items: Array<RemitImapCalendarEventInstance>;
+};
+
+/**
+ * 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 type RemitImapCalendarEventResponse = {
+    /**
+     * 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.
+     */
+    readonly 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.
+     */
+    readonly sequence: number;
+    /**
+     * Value the owning collection's `syncSequence` held after the write that produced this row. Pages the `bySyncSequence` read.
+     */
+    readonly 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.
+     */
+    readonly 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: RemitImapZoneCertainty;
+    /**
+     * Projection of the master VEVENT's STATUS
+     */
+    status: RemitImapCalendarEventStatus;
+    /**
+     * Projection of the master VEVENT's TRANSP
+     */
+    transparency: RemitImapCalendarTransparency;
+    /**
+     * 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.
+     */
+    readonly 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;
+    readonly createdAt: number;
+    readonly updatedAt: number;
+};
+
+/**
+ * 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 RemitImapCalendarEventStatus = 'Confirmed' | 'Tentative' | 'Cancelled';
+
+/**
+ * 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 type RemitImapCalendarFreeBusyResponse = {
+    items: Array<RemitImapCalendarFreeBusySpan>;
+};
+
+/**
+ * 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 type RemitImapCalendarFreeBusySpan = {
+    /**
+     * 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;
+};
+
+/**
+ * The iTIP method a scheduling message carries (RFC 5546 3.2), read from the VCALENDAR's METHOD property. It says what the sender is asking for, which is not derivable from the VEVENT: a cancellation and an invitation differ by this property alone.
+ */
+export type RemitImapCalendarInviteMethod = 'Request' | 'Reply' | 'Cancel' | 'Counter' | 'Publish' | 'None';
+
+/**
+ * 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 type RemitImapCalendarListResponse = {
+    items: Array<RemitImapCalendarResponse>;
+};
+
+/**
+ * A calendar collection as the API returns it.
+ */
+export type RemitImapCalendarResponse = {
+    /**
+     * 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: RemitImapCalendarColor;
+    /**
+     * Which iCalendar components this collection accepts
+     */
+    componentSet: RemitImapCalendarComponentSet;
+    /**
+     * Where this collection came from
+     */
+    source: RemitImapCalendarSource;
+    /**
+     * 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.
+     */
+    readonly syncSequence: number;
+    readonly createdAt: number;
+    readonly updatedAt: number;
+};
+
+/**
+ * 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 RemitImapCalendarSource = 'Default' | 'UserCreated' | 'MailDerived';
+
+/**
+ * A suggestion as the API returns it. The raw `icalData` is not surfaced: a client renders the projected fields, and the bytes exist so that accepting can write them into a calendar unchanged.
+ */
+export type RemitImapCalendarSuggestionResponse = {
+    /**
+     * Primary identifier, derived from messageId + bodyPartId + icalUid
+     */
+    suggestionId: Uuid;
+    /**
+     * Owning account configuration
+     */
+    accountConfigId: Uuid;
+    /**
+     * Message this suggestion was read out of. The card is offered beside this message and nowhere else.
+     */
+    messageId: Uuid;
+    /**
+     * MIME part the iCalendar bytes came from. Part of the identity, so two invitations in one message stay two suggestions rather than overwriting each other.
+     */
+    bodyPartId: Uuid;
+    /**
+     * The VEVENT's UID property (RFC 5545 3.8.4.7). What ties a revision, a cancellation and the original invitation together across three separate messages.
+     */
+    icalUid: String512;
+    /**
+     * The VEVENT's SEQUENCE property (RFC 5545 3.8.7.4) — the organizer's revision counter. A later message carrying the same `icalUid` with a higher value supersedes this one. `0` when the event declares none, which is the RFC default.
+     */
+    readonly sequence: number;
+    /**
+     * The iTIP method the VCALENDAR declared. `None` when it declared no METHOD.
+     */
+    method: RemitImapCalendarInviteMethod;
+    /**
+     * Where in the message this was read from
+     */
+    source: RemitImapCalendarSuggestionSource;
+    /**
+     * What has become of this suggestion. Only `Pending` asks the user for anything.
+     */
+    state: RemitImapCalendarSuggestionState;
+    /**
+     * Projection of the VEVENT's SUMMARY. `""` when the event carries none.
+     */
+    summary: String512;
+    /**
+     * Projection of the 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 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 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.
+     */
+    readonly allDay: boolean;
+    /**
+     * Projection of the VEVENT's LOCATION. `""` when the event carries none.
+     */
+    location: String512;
+    /**
+     * Mail address of the VEVENT's ORGANIZER, without the `mailto:` scheme. `""` when the event names none — which is what a `PUBLISH` typically looks like, and why dismissing with `muteSender` mutes the message's sender rather than this field.
+     */
+    organizer: String256;
+    /**
+     * How the DTSTART above was placed on the clock. `Ambiguous` means the invitation named a zone nothing could resolve, so the time shown may be hours out — a card says so rather than presenting a guess as a fact.
+     */
+    zoneCertainty: RemitImapZoneCertainty;
+    /**
+     * The `CalendarObject` that accepting this suggestion wrote. `""` until it is accepted — the named absent state, never a missing attribute — and the resource's id afterwards, so the card can link to the event it produced.
+     */
+    readonly acceptedCalendarObjectId: string;
+    readonly createdAt: number;
+    readonly updatedAt: number;
+};
+
+/**
+ * Where in a message a suggestion was read from. It is what a card says to explain itself, and it is what separates a suggestion carrying real iCalendar from one inferred out of prose.
+ */
+export type RemitImapCalendarSuggestionSource = 'IcalendarPart' | 'IcalendarAttachment' | 'TextHeuristic';
+
+/**
+ * What has become of a suggestion. `Pending` is the only state that asks a person for anything; every other value is a decision already taken, and nothing but an explicit act moves a suggestion out of `Pending`.
+ */
+export type RemitImapCalendarSuggestionState = 'Pending' | 'Accepted' | 'Declined' | 'Tentative' | 'Dismissed' | 'Superseded';
+
+/**
+ * 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 RemitImapCalendarTransparency = 'Opaque' | 'Transparent';
+
 /**
  * The fixed anchor set of canonical mailbox roles a user appoints to a folder (RFC 032 exclusive-folder-appointment, issue #976). Mirrors the IMAP SPECIAL-USE roles (RFC 6154). Each role resolves to at most one mailbox per account — see FolderAppointment.
  */
@@ -770,6 +1119,94 @@ export type RemitImapCreateAccountInput = {
     smtpPassword?: string;
 };
 
+/**
+ * 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 type RemitImapCreateCalendarEventInput = {
+    /**
+     * 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?: RemitImapCalendarEventStatus;
+    /**
+     * TRANSP of the event — whether it consumes free/busy time
+     */
+    transparency?: RemitImapCalendarTransparency;
+    /**
+     * 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;
+};
+
+/**
+ * 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 type RemitImapCreateCalendarInput = {
+    /**
+     * 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?: RemitImapCalendarColor;
+    /**
+     * IANA time zone this collection's floating times are read in. Absent reads them as UTC.
+     */
+    timezone?: String64;
+};
+
 /**
  * Response body for POST /me/export
  */
@@ -991,6 +1428,16 @@ export type RemitImapDescribeMessageResponse = {
     references: Array<RemitImapMessageReferenceResponse>;
 };
 
+/**
+ * Body of `POST /calendar-suggestions/{suggestionId}/dismiss`.
+ */
+export type RemitImapDismissCalendarSuggestionInput = {
+    /**
+     * Also stop offering invitations from this message's sender, by writing a standing `Filter` rule. `false` dismisses this one card and nothing else.
+     */
+    muteSender: boolean;
+};
+
 /**
  * How the From display name relates to the From domain. `Corresponds` — the name is contained in the domain. `Lookalike` — the name is one or two characters away from a domain label. `ForeignAddress` — the name spells out an email address at a domain the sender does not send from. `Unrelated` — no relation. `NoClaim` — the name is empty, or is an address at the sending domain, so it claims no other identity.
  */
@@ -2110,6 +2557,11 @@ export type RemitImapRawMessageResponse = {
     raw: string;
 };
 
+/**
+ * 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 RemitImapRecurrenceScope = 'This' | 'Following' | 'All';
+
 /**
  * Message reference types per RFC 2822 Section 3.6.4
  */
@@ -2704,22 +3156,66 @@ export type RemitImapUpdateAddressInput = {
 };
 
 /**
- * Input for updating a filter (RFC 034, reader #266). The name, predicate,
- * action, scope, and expiresAt are all updatable; `ttl` is always
- * server-derived from `scope`/`expiresAt`, never client-supplied, and
- * `state`/`hasAnchor`/`ruleChangedAt`/`actionChangedAt`/`filterId` are
- * server-derived too. A patch touching the predicate, the action, `scope`, or
- * `expiresAt` bumps `ruleChangedAt`; a name-only rename never does (RFC 034
- * Decision 3.2, reader #266). Only a patch touching the predicate or the
- * action bumps `actionChangedAt`, the narrower signal exclusive-move
- * precedence reads (reader #384) — a scope/expiresAt-only edit leaves it
- * untouched.
+ * 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.
  *
- * The semantic anchor has no field here at all — it is set once, from
- * `anchorMessageId`, only on `CreateFilterInput`. Repointing an anchor would
- * silently change what a saved filter matches with nothing visible changing;
- * that deserves a new filter, so the server rejects any attempt to smuggle an
- * anchor change through this body (reader #266).
+ * 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 type RemitImapUpdateCalendarEventInput = {
+    summary?: String512;
+    description?: String2048;
+    location?: String512;
+    start?: String64;
+    end?: String64;
+    allDay?: boolean;
+    timeZone?: String64;
+    status?: RemitImapCalendarEventStatus;
+    transparency?: RemitImapCalendarTransparency;
+    /**
+     * 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;
+};
+
+/**
+ * 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 type RemitImapUpdateCalendarInput = {
+    /**
+     * Human-readable collection name (display)
+     */
+    displayName?: String140;
+    /**
+     * Display color slot for this collection
+     */
+    color?: RemitImapCalendarColor;
+    /**
+     * 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;
+};
+
+/**
+ * Input for updating a filter (RFC 034, reader #266). The name, predicate,
+ * action, scope, and expiresAt are all updatable; `ttl` is always
+ * server-derived from `scope`/`expiresAt`, never client-supplied, and
+ * `state`/`hasAnchor`/`ruleChangedAt`/`actionChangedAt`/`filterId` are
+ * server-derived too. A patch touching the predicate, the action, `scope`, or
+ * `expiresAt` bumps `ruleChangedAt`; a name-only rename never does (RFC 034
+ * Decision 3.2, reader #266). Only a patch touching the predicate or the
+ * action bumps `actionChangedAt`, the narrower signal exclusive-move
+ * precedence reads (reader #384) — a scope/expiresAt-only edit leaves it
+ * untouched.
+ *
+ * The semantic anchor has no field here at all — it is set once, from
+ * `anchorMessageId`, only on `CreateFilterInput`. Repointing an anchor would
+ * silently change what a saved filter matches with nothing visible changing;
+ * that deserves a new filter, so the server rejects any attempt to smuggle an
+ * anchor change through this body (reader #266).
  */
 export type RemitImapUpdateFilterInput = {
     /**
@@ -2920,6 +3416,11 @@ export type RemitImapWellknownFlagUpdate = RemitImapAddressFlagBaseUpdate & {
     value?: boolean;
 };
 
+/**
+ * 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 RemitImapZoneCertainty = 'Local' | 'Explicit' | 'Ambiguous';
+
 export type String140 = string;
 
 export type String2048 = string;
@@ -2981,6 +3482,31 @@ export type RemitImapBodyPartResponseWritable = {
     contentUrl: string;
 };
 
+/**
+ * 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 type RemitImapCalendarListResponseWritable = {
+    items: Array<RemitImapCalendarResponseWritable>;
+};
+
+/**
+ * A calendar collection as the API returns it.
+ */
+export type RemitImapCalendarResponseWritable = {
+    /**
+     * Human-readable collection name (display)
+     */
+    displayName: String140;
+    /**
+     * Display color slot for this collection
+     */
+    color: RemitImapCalendarColor;
+    /**
+     * 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;
+};
+
 /**
  * Full configuration description including accounts
  */
@@ -3831,6 +4357,502 @@ export type AddressDetailOperationsUpdateAddressResponses = {
 
 export type AddressDetailOperationsUpdateAddressResponse = AddressDetailOperationsUpdateAddressResponses[keyof AddressDetailOperationsUpdateAddressResponses];
 
+export type CalendarEventOperationsListCalendarEventsData = {
+    body?: never;
+    path?: never;
+    query: {
+        /**
+         * Start of the window, an ISO 8601 date-time with zone offset. Inclusive.
+         */
+        from: string;
+        /**
+         * End of the window, an ISO 8601 date-time with zone offset. Exclusive.
+         */
+        to: string;
+        /**
+         * Restrict to these collections, repeated once per calendar. Omitted means every calendar the caller holds.
+         */
+        calendarId?: Array<Uuid>;
+    };
+    url: '/calendar-events';
+};
+
+export type CalendarEventOperationsListCalendarEventsErrors = {
+    /**
+     * Validation error response
+     */
+    400: ApiError;
+    /**
+     * Not found error response
+     */
+    404: ApiError;
+};
+
+export type CalendarEventOperationsListCalendarEventsError = CalendarEventOperationsListCalendarEventsErrors[keyof CalendarEventOperationsListCalendarEventsErrors];
+
+export type CalendarEventOperationsListCalendarEventsResponses = {
+    /**
+     * The request has succeeded.
+     */
+    200: RemitImapCalendarEventListResponse;
+};
+
+export type CalendarEventOperationsListCalendarEventsResponse = CalendarEventOperationsListCalendarEventsResponses[keyof CalendarEventOperationsListCalendarEventsResponses];
+
+export type CalendarEventOperationsCreateCalendarEventData = {
+    body: RemitImapCreateCalendarEventInput;
+    path?: never;
+    query?: never;
+    url: '/calendar-events';
+};
+
+export type CalendarEventOperationsCreateCalendarEventErrors = {
+    /**
+     * Validation error response
+     */
+    400: ApiError;
+    /**
+     * Not found error response
+     */
+    404: ApiError;
+};
+
+export type CalendarEventOperationsCreateCalendarEventError = CalendarEventOperationsCreateCalendarEventErrors[keyof CalendarEventOperationsCreateCalendarEventErrors];
+
+export type CalendarEventOperationsCreateCalendarEventResponses = {
+    /**
+     * The request has succeeded.
+     */
+    200: RemitImapCalendarEventResponse;
+};
+
+export type CalendarEventOperationsCreateCalendarEventResponse = CalendarEventOperationsCreateCalendarEventResponses[keyof CalendarEventOperationsCreateCalendarEventResponses];
+
+export type CalendarEventDetailOperationsDeleteCalendarEventData = {
+    body?: never;
+    headers?: {
+        'If-Match'?: string;
+    };
+    path: {
+        calendarObjectId: Uuid;
+    };
+    query: {
+        /**
+         * Collection the resource lives in
+         */
+        calendarId: Uuid;
+        /**
+         * Which occurrences this delete applies to. Defaults to `All`.
+         */
+        scope?: RemitImapRecurrenceScope;
+        /**
+         * RECURRENCE-ID of the occurrence the delete is anchored at. Required for `This` and `Following`.
+         */
+        recurrenceId?: string;
+    };
+    url: '/calendar-events/{calendarObjectId}';
+};
+
+export type CalendarEventDetailOperationsDeleteCalendarEventErrors = {
+    /**
+     * Validation error response
+     */
+    400: ApiError;
+    /**
+     * Not found error response
+     */
+    404: 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.
+     */
+    412: ApiError;
+};
+
+export type CalendarEventDetailOperationsDeleteCalendarEventError = CalendarEventDetailOperationsDeleteCalendarEventErrors[keyof CalendarEventDetailOperationsDeleteCalendarEventErrors];
+
+export type CalendarEventDetailOperationsDeleteCalendarEventResponses = {
+    /**
+     * Nothing to return. The resource, or the occurrence, is gone.
+     */
+    204: void;
+};
+
+export type CalendarEventDetailOperationsDeleteCalendarEventResponse = CalendarEventDetailOperationsDeleteCalendarEventResponses[keyof CalendarEventDetailOperationsDeleteCalendarEventResponses];
+
+export type CalendarEventDetailOperationsGetCalendarEventData = {
+    body?: never;
+    path: {
+        calendarObjectId: Uuid;
+    };
+    query: {
+        /**
+         * Collection the resource lives in. A resource is addressed by its collection and its own id, which is what a client holds: every occurrence a listing returns carries both.
+         */
+        calendarId: Uuid;
+    };
+    url: '/calendar-events/{calendarObjectId}';
+};
+
+export type CalendarEventDetailOperationsGetCalendarEventErrors = {
+    /**
+     * Validation error response
+     */
+    400: ApiError;
+    /**
+     * Not found error response
+     */
+    404: ApiError;
+};
+
+export type CalendarEventDetailOperationsGetCalendarEventError = CalendarEventDetailOperationsGetCalendarEventErrors[keyof CalendarEventDetailOperationsGetCalendarEventErrors];
+
+export type CalendarEventDetailOperationsGetCalendarEventResponses = {
+    /**
+     * The request has succeeded.
+     */
+    200: RemitImapCalendarEventResponse;
+};
+
+export type CalendarEventDetailOperationsGetCalendarEventResponse = CalendarEventDetailOperationsGetCalendarEventResponses[keyof CalendarEventDetailOperationsGetCalendarEventResponses];
+
+export type CalendarEventDetailOperationsUpdateCalendarEventData = {
+    body: RemitImapUpdateCalendarEventInput;
+    headers?: {
+        'If-Match'?: string;
+    };
+    path: {
+        calendarObjectId: Uuid;
+    };
+    query: {
+        /**
+         * Collection the resource lives in
+         */
+        calendarId: Uuid;
+        /**
+         * Which occurrences this update applies to. Defaults to `All`.
+         */
+        scope?: RemitImapRecurrenceScope;
+        /**
+         * RECURRENCE-ID of the occurrence the update is anchored at, as the ISO 8601 UTC instant a listing returned. Required for `This` and `Following`.
+         */
+        recurrenceId?: string;
+    };
+    url: '/calendar-events/{calendarObjectId}';
+};
+
+export type CalendarEventDetailOperationsUpdateCalendarEventErrors = {
+    /**
+     * Validation error response
+     */
+    400: ApiError;
+    /**
+     * Not found error response
+     */
+    404: 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.
+     */
+    412: ApiError;
+};
+
+export type CalendarEventDetailOperationsUpdateCalendarEventError = CalendarEventDetailOperationsUpdateCalendarEventErrors[keyof CalendarEventDetailOperationsUpdateCalendarEventErrors];
+
+export type CalendarEventDetailOperationsUpdateCalendarEventResponses = {
+    /**
+     * The request has succeeded.
+     */
+    200: RemitImapCalendarEventResponse;
+};
+
+export type CalendarEventDetailOperationsUpdateCalendarEventResponse = CalendarEventDetailOperationsUpdateCalendarEventResponses[keyof CalendarEventDetailOperationsUpdateCalendarEventResponses];
+
+export type CalendarFreeBusyOperationsListCalendarFreeBusyData = {
+    body?: never;
+    path?: never;
+    query: {
+        /**
+         * Start of the window, an ISO 8601 date-time with zone offset. Inclusive.
+         */
+        from: string;
+        /**
+         * End of the window, an ISO 8601 date-time with zone offset. Exclusive.
+         */
+        to: string;
+    };
+    url: '/calendar-free-busy';
+};
+
+export type CalendarFreeBusyOperationsListCalendarFreeBusyErrors = {
+    /**
+     * Validation error response
+     */
+    400: ApiError;
+};
+
+export type CalendarFreeBusyOperationsListCalendarFreeBusyError = CalendarFreeBusyOperationsListCalendarFreeBusyErrors[keyof CalendarFreeBusyOperationsListCalendarFreeBusyErrors];
+
+export type CalendarFreeBusyOperationsListCalendarFreeBusyResponses = {
+    /**
+     * The request has succeeded.
+     */
+    200: RemitImapCalendarFreeBusyResponse;
+};
+
+export type CalendarFreeBusyOperationsListCalendarFreeBusyResponse = CalendarFreeBusyOperationsListCalendarFreeBusyResponses[keyof CalendarFreeBusyOperationsListCalendarFreeBusyResponses];
+
+export type CalendarSuggestionOperationsListCalendarSuggestionsData = {
+    body?: never;
+    path?: never;
+    query: {
+        state: RemitImapCalendarSuggestionState;
+        continuationToken?: string;
+    };
+    url: '/calendar-suggestions';
+};
+
+export type CalendarSuggestionOperationsListCalendarSuggestionsErrors = {
+    /**
+     * Validation error response
+     */
+    400: ApiError;
+};
+
+export type CalendarSuggestionOperationsListCalendarSuggestionsError = CalendarSuggestionOperationsListCalendarSuggestionsErrors[keyof CalendarSuggestionOperationsListCalendarSuggestionsErrors];
+
+export type CalendarSuggestionOperationsListCalendarSuggestionsResponses = {
+    /**
+     * The request has succeeded.
+     */
+    200: {
+        /**
+         * Opaque, server-minted cursor: absent means the first (or last) page, present means resume from here. Echo it back unchanged to fetch the next page. Every listing endpoint that accepts it rejects a token it cannot decode with 400 ValidationError rather than silently restarting from the first page (#136, #172).
+         */
+        continuationToken?: String800;
+        items: Array<RemitImapCalendarSuggestionResponse>;
+    };
+};
+
+export type CalendarSuggestionOperationsListCalendarSuggestionsResponse = CalendarSuggestionOperationsListCalendarSuggestionsResponses[keyof CalendarSuggestionOperationsListCalendarSuggestionsResponses];
+
+export type CalendarSuggestionActionOperationsAcceptCalendarSuggestionData = {
+    body: RemitImapAcceptCalendarSuggestionInput;
+    path: {
+        suggestionId: Uuid;
+    };
+    query?: never;
+    url: '/calendar-suggestions/{suggestionId}/accept';
+};
+
+export type CalendarSuggestionActionOperationsAcceptCalendarSuggestionErrors = {
+    /**
+     * Validation error response
+     */
+    400: ApiError;
+};
+
+export type CalendarSuggestionActionOperationsAcceptCalendarSuggestionError = CalendarSuggestionActionOperationsAcceptCalendarSuggestionErrors[keyof CalendarSuggestionActionOperationsAcceptCalendarSuggestionErrors];
+
+export type CalendarSuggestionActionOperationsAcceptCalendarSuggestionResponses = {
+    /**
+     * The request has succeeded.
+     */
+    200: RemitImapCalendarSuggestionResponse;
+};
+
+export type CalendarSuggestionActionOperationsAcceptCalendarSuggestionResponse = CalendarSuggestionActionOperationsAcceptCalendarSuggestionResponses[keyof CalendarSuggestionActionOperationsAcceptCalendarSuggestionResponses];
+
+export type CalendarSuggestionActionOperationsDeclineCalendarSuggestionData = {
+    body?: never;
+    path: {
+        suggestionId: Uuid;
+    };
+    query?: never;
+    url: '/calendar-suggestions/{suggestionId}/decline';
+};
+
+export type CalendarSuggestionActionOperationsDeclineCalendarSuggestionErrors = {
+    /**
+     * Validation error response
+     */
+    400: ApiError;
+};
+
+export type CalendarSuggestionActionOperationsDeclineCalendarSuggestionError = CalendarSuggestionActionOperationsDeclineCalendarSuggestionErrors[keyof CalendarSuggestionActionOperationsDeclineCalendarSuggestionErrors];
+
+export type CalendarSuggestionActionOperationsDeclineCalendarSuggestionResponses = {
+    /**
+     * The request has succeeded.
+     */
+    200: RemitImapCalendarSuggestionResponse;
+};
+
+export type CalendarSuggestionActionOperationsDeclineCalendarSuggestionResponse = CalendarSuggestionActionOperationsDeclineCalendarSuggestionResponses[keyof CalendarSuggestionActionOperationsDeclineCalendarSuggestionResponses];
+
+export type CalendarSuggestionActionOperationsDismissCalendarSuggestionData = {
+    body: RemitImapDismissCalendarSuggestionInput;
+    path: {
+        suggestionId: Uuid;
+    };
+    query?: never;
+    url: '/calendar-suggestions/{suggestionId}/dismiss';
+};
+
+export type CalendarSuggestionActionOperationsDismissCalendarSuggestionErrors = {
+    /**
+     * Validation error response
+     */
+    400: ApiError;
+};
+
+export type CalendarSuggestionActionOperationsDismissCalendarSuggestionError = CalendarSuggestionActionOperationsDismissCalendarSuggestionErrors[keyof CalendarSuggestionActionOperationsDismissCalendarSuggestionErrors];
+
+export type CalendarSuggestionActionOperationsDismissCalendarSuggestionResponses = {
+    /**
+     * The request has succeeded.
+     */
+    200: RemitImapCalendarSuggestionResponse;
+};
+
+export type CalendarSuggestionActionOperationsDismissCalendarSuggestionResponse = CalendarSuggestionActionOperationsDismissCalendarSuggestionResponses[keyof CalendarSuggestionActionOperationsDismissCalendarSuggestionResponses];
+
+export type CalendarOperationsListCalendarsData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/calendars';
+};
+
+export type CalendarOperationsListCalendarsResponses = {
+    /**
+     * The request has succeeded.
+     */
+    200: RemitImapCalendarListResponse;
+};
+
+export type CalendarOperationsListCalendarsResponse = CalendarOperationsListCalendarsResponses[keyof CalendarOperationsListCalendarsResponses];
+
+export type CalendarOperationsCreateCalendarData = {
+    body: RemitImapCreateCalendarInput;
+    path?: never;
+    query?: never;
+    url: '/calendars';
+};
+
+export type CalendarOperationsCreateCalendarErrors = {
+    /**
+     * Validation error response
+     */
+    400: ApiError;
+};
+
+export type CalendarOperationsCreateCalendarError = CalendarOperationsCreateCalendarErrors[keyof CalendarOperationsCreateCalendarErrors];
+
+export type CalendarOperationsCreateCalendarResponses = {
+    /**
+     * The request has succeeded.
+     */
+    200: RemitImapCalendarResponse;
+};
+
+export type CalendarOperationsCreateCalendarResponse = CalendarOperationsCreateCalendarResponses[keyof CalendarOperationsCreateCalendarResponses];
+
+export type CalendarDetailOperationsDeleteCalendarData = {
+    body?: never;
+    path: {
+        calendarId: Uuid;
+    };
+    query?: never;
+    url: '/calendars/{calendarId}';
+};
+
+export type CalendarDetailOperationsDeleteCalendarErrors = {
+    /**
+     * Validation error response
+     */
+    400: ApiError;
+    /**
+     * Not found error response
+     */
+    404: ApiError;
+};
+
+export type CalendarDetailOperationsDeleteCalendarError = CalendarDetailOperationsDeleteCalendarErrors[keyof CalendarDetailOperationsDeleteCalendarErrors];
+
+export type CalendarDetailOperationsDeleteCalendarResponses = {
+    /**
+     * Nothing to return. The resource, or the occurrence, is gone.
+     */
+    204: void;
+};
+
+export type CalendarDetailOperationsDeleteCalendarResponse = CalendarDetailOperationsDeleteCalendarResponses[keyof CalendarDetailOperationsDeleteCalendarResponses];
+
+export type CalendarDetailOperationsGetCalendarData = {
+    body?: never;
+    path: {
+        calendarId: Uuid;
+    };
+    query?: never;
+    url: '/calendars/{calendarId}';
+};
+
+export type CalendarDetailOperationsGetCalendarErrors = {
+    /**
+     * Not found error response
+     */
+    404: ApiError;
+};
+
+export type CalendarDetailOperationsGetCalendarError = CalendarDetailOperationsGetCalendarErrors[keyof CalendarDetailOperationsGetCalendarErrors];
+
+export type CalendarDetailOperationsGetCalendarResponses = {
+    /**
+     * The request has succeeded.
+     */
+    200: RemitImapCalendarResponse;
+};
+
+export type CalendarDetailOperationsGetCalendarResponse = CalendarDetailOperationsGetCalendarResponses[keyof CalendarDetailOperationsGetCalendarResponses];
+
+export type CalendarDetailOperationsUpdateCalendarData = {
+    body: RemitImapUpdateCalendarInput;
+    path: {
+        calendarId: Uuid;
+    };
+    query?: never;
+    url: '/calendars/{calendarId}';
+};
+
+export type CalendarDetailOperationsUpdateCalendarErrors = {
+    /**
+     * Validation error response
+     */
+    400: ApiError;
+    /**
+     * Not found error response
+     */
+    404: ApiError;
+};
+
+export type CalendarDetailOperationsUpdateCalendarError = CalendarDetailOperationsUpdateCalendarErrors[keyof CalendarDetailOperationsUpdateCalendarErrors];
+
+export type CalendarDetailOperationsUpdateCalendarResponses = {
+    /**
+     * The request has succeeded.
+     */
+    200: RemitImapCalendarResponse;
+};
+
+export type CalendarDetailOperationsUpdateCalendarResponse = CalendarDetailOperationsUpdateCalendarResponses[keyof CalendarDetailOperationsUpdateCalendarResponses];
+
 export type ConfigOperationsGetConfigData = {
     body?: never;
     path?: never;
@@ -4220,6 +5242,39 @@ export type MessageOperationsDescribeMessageResponses = {
 
 export type MessageOperationsDescribeMessageResponse = MessageOperationsDescribeMessageResponses[keyof MessageOperationsDescribeMessageResponses];
 
+export type MessageCalendarSuggestionOperationsListMessageCalendarSuggestionsData = {
+    body?: never;
+    path: {
+        messageId: Uuid;
+    };
+    query?: never;
+    url: '/messages/{messageId}/calendar-suggestions';
+};
+
+export type MessageCalendarSuggestionOperationsListMessageCalendarSuggestionsErrors = {
+    /**
+     * Validation error response
+     */
+    400: ApiError;
+};
+
+export type MessageCalendarSuggestionOperationsListMessageCalendarSuggestionsError = MessageCalendarSuggestionOperationsListMessageCalendarSuggestionsErrors[keyof MessageCalendarSuggestionOperationsListMessageCalendarSuggestionsErrors];
+
+export type MessageCalendarSuggestionOperationsListMessageCalendarSuggestionsResponses = {
+    /**
+     * The request has succeeded.
+     */
+    200: {
+        /**
+         * Opaque, server-minted cursor: absent means the first (or last) page, present means resume from here. Echo it back unchanged to fetch the next page. Every listing endpoint that accepts it rejects a token it cannot decode with 400 ValidationError rather than silently restarting from the first page (#136, #172).
+         */
+        continuationToken?: String800;
+        items: Array<RemitImapCalendarSuggestionResponse>;
+    };
+};
+
+export type MessageCalendarSuggestionOperationsListMessageCalendarSuggestionsResponse = MessageCalendarSuggestionOperationsListMessageCalendarSuggestionsResponses[keyof MessageCalendarSuggestionOperationsListMessageCalendarSuggestionsResponses];
+
 export type MessageOperationsUpdateMessageFlagsData = {
     body: RemitImapUpdateFlagsInput;
     path: {