@remit/api-http-client 0.0.37 → 0.0.39

package/types.gen.ts

@@ -553,6 +553,254 @@ 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;
+};
+
+/**
+ * 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';
+
+/**
+ * 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.
  */
@@ -584,6 +832,10 @@ export type RemitImapConfigDescriptionResponse = {
      * Associated email accounts
      */
     accounts: Array<RemitImapAccountResponse>;
+    /**
+     * Absent unless a configuration import is still waiting on folders IMAP has not produced yet (#1021). Nothing polls a separate route for it.
+     */
+    pendingImport?: RemitImapPendingConfigImport;
 };
 
 /**
@@ -602,10 +854,80 @@ export type RemitImapConfigExportResponse = {
     };
 };
 
+/**
+ * What became of one item in the submitted document
+ */
+export type RemitImapConfigImportItemReport = {
+    /**
+     * Which section: accounts | labels | filters | addressFlags | settings
+     */
+    section: string;
+    /**
+     * Human key of the item - an email, a label name, a filter name
+     */
+    key: string;
+    /**
+     * created | updated | unchanged | skipped | rejected
+     */
+    verdict: string;
+    /**
+     * Why, when the verdict is skipped or rejected
+     */
+    reason?: string;
+};
+
+/**
+ * Whether an import writes. The default is the dry run, so the wizard can show what a file would do before anything lands.
+ */
+export type RemitImapConfigImportMode = 'validate' | 'apply';
+
+/**
+ * What an import does when the configuration it is importing into is not empty.
+ */
+export type RemitImapConfigImportOnExisting = 'abort' | 'merge';
+
+/**
+ * The outcome of a validate or an apply. A rejected document is an answer, not a failure: `valid` is false and `errors` says why.
+ */
+export type RemitImapConfigImportReport = {
+    /**
+     * Import identity; present on apply, so the folder bindings this import is still waiting on can be named later
+     */
+    importId?: Uuid;
+    /**
+     * Whether the document is importable at all
+     */
+    valid: boolean;
+    /**
+     * Schema version of the submitted document
+     */
+    schemaVersion: number;
+    /**
+     * Whether anything was written
+     */
+    applied: boolean;
+    /**
+     * Per-item verdicts
+     */
+    items: Array<RemitImapConfigImportItemReport>;
+    /**
+     * Blocking problems; non-empty means nothing was written
+     */
+    errors: Array<ApiError>;
+    /**
+     * Non-blocking notes - e.g. a folder path this account does not hold yet
+     */
+    warnings: Array<ApiError>;
+    /**
+     * Accounts that landed needing a credential before they can sync
+     */
+    accountsNeedingCredentials: Array<Uuid>;
+};
+
 /**
  * IMAP connection states per RFC 9051 Section 3
  */
-export type RemitImapConnectionState = 'not_authenticated' | 'authenticated' | 'selected' | 'logout' | 'reauth_required';
+export type RemitImapConnectionState = 'not_authenticated' | 'authenticated' | 'selected' | 'logout' | 'reauth_required' | 'credentials_missing';
 
 /**
  * Content disposition types per RFC 2183
@@ -696,6 +1018,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
  */
@@ -1137,6 +1547,26 @@ export type RemitImapFolderAppointment = {
  */
 export type RemitImapFolderAppointmentSource = 'Appointed' | 'Flagged' | 'Reserved' | 'Proposed' | 'Stale' | 'None';
 
+/**
+ * Request body for POST /config/import
+ */
+export type RemitImapImportConfigInput = {
+    /**
+     * `validate` writes nothing; `apply` writes.
+     */
+    mode?: RemitImapConfigImportMode;
+    /**
+     * What to do when this configuration is not empty.
+     */
+    onExisting?: RemitImapConfigImportOnExisting;
+    /**
+     * The config document, as exported.
+     */
+    document: {
+        [key: string]: unknown;
+    };
+};
+
 /**
  * Address was only ever seen on mail in a Junk folder: withheld from autocomplete suggestions until the account corresponds with it, flags it, or meets it on live mail. Written by sync and by the boot-time repair; clear it by patching this key to null.
  */
@@ -1818,6 +2248,24 @@ export type RemitImapOutboxMessageResponse = {
  */
 export type RemitImapOutboxMessageStatus = 'draft' | 'queued' | 'sending' | 'sent' | 'unfiled' | 'failed' | 'blocked';
 
+/**
+ * An import that is still waiting for IMAP discovery to produce the folders its
+ * file named. The folder appointed to a role, a folder's own display name or
+ * mute, and a filter's move destination are all bound by path; a path this
+ * account does not hold yet is kept, not guessed, and bound the moment discovery
+ * finds it.
+ */
+export type RemitImapPendingConfigImport = {
+    /**
+     * The import still waiting
+     */
+    importId: Uuid;
+    /**
+     * The IMAP paths no mailbox answers to yet, deduplicated
+     */
+    folderPaths: Array<string>;
+};
+
 /**
  * Actionable placement verdict — the direction Remit decided to move a message. `leave` is not represented: a left-in-place verdict means the placement sub-model is absent.
  */
@@ -1998,6 +2446,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
  */
@@ -2591,6 +3044,50 @@ export type RemitImapUpdateAddressInput = {
     flags?: RemitImapUpdateAddressFlagsInput;
 };
 
+/**
+ * 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 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
@@ -2808,6 +3305,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;
@@ -2869,6 +3371,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
  */
@@ -2881,6 +3408,10 @@ export type RemitImapConfigDescriptionResponseWritable = {
      * Associated email accounts
      */
     accounts: Array<RemitImapAccountResponseWritable>;
+    /**
+     * Absent unless a configuration import is still waiting on folders IMAP has not produced yet (#1021). Nothing polls a separate route for it.
+     */
+    pendingImport?: RemitImapPendingConfigImport;
 };
 
 /**
@@ -3715,6 +4246,387 @@ 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 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;
@@ -3747,6 +4659,40 @@ export type ConfigOperationsExportConfigResponses = {
 
 export type ConfigOperationsExportConfigResponse = ConfigOperationsExportConfigResponses[keyof ConfigOperationsExportConfigResponses];
 
+export type ConfigOperationsImportConfigData = {
+    body: RemitImapImportConfigInput;
+    path?: never;
+    query?: never;
+    url: '/config/import';
+};
+
+export type ConfigOperationsImportConfigErrors = {
+    /**
+     * Validation error response
+     */
+    400: ApiError;
+    /**
+     * The import was refused because this configuration is not empty. The body is
+     * flat: `code`, `message` and `details` sit at the top level.
+     *
+     * `code: "config_not_empty"` — the configuration already holds an account, a
+     * label, a filter or an address flag. `details` names how many of each. Re-send
+     * with `onExisting: merge` to upsert instead.
+     */
+    409: ApiError;
+};
+
+export type ConfigOperationsImportConfigError = ConfigOperationsImportConfigErrors[keyof ConfigOperationsImportConfigErrors];
+
+export type ConfigOperationsImportConfigResponses = {
+    /**
+     * The request has succeeded.
+     */
+    200: RemitImapConfigImportReport;
+};
+
+export type ConfigOperationsImportConfigResponse = ConfigOperationsImportConfigResponses[keyof ConfigOperationsImportConfigResponses];
+
 export type ThreadOperationsListThreadsData = {
     body?: never;
     path: {