@remit/api-http-client 0.0.1

package/types.gen.ts

@@ -0,0 +1,3245 @@
+// This file is auto-generated by @hey-api/openapi-ts
+
+export type ClientOptions = {
+    baseUrl: 'https://api.remit.example.com' | (string & {});
+};
+
+/**
+ * API error response
+ */
+export type ApiError = {
+    /**
+     * Error code
+     */
+    code: string;
+    /**
+     * Human-readable error message
+     */
+    message: string;
+    /**
+     * Additional error details
+     */
+    details?: {
+        [key: string]: string;
+    };
+};
+
+export type MicrosoftOAuthStartRequest = {
+    /**
+     * Optional email hint for the Microsoft login page
+     */
+    email?: string;
+};
+
+export type MicrosoftOAuthStartResponse = {
+    /**
+     * The Microsoft authorization URL to redirect the user to
+     */
+    authorizationUrl: string;
+};
+
+/**
+ * Authentication mechanism used by an email account
+ */
+export type RemitImapAccountAuthType = 'password' | 'oauthMicrosoft';
+
+/**
+ * Account configuration response
+ */
+export type RemitImapAccountConfigResponse = {
+    /**
+     * Primary identifier
+     */
+    accountConfigId: Uuid;
+    /**
+     * Reference to owning user (typically stored externally)
+     */
+    userId: Uuid;
+    /**
+     * Display name for this configuration
+     */
+    readonly name?: string;
+    /**
+     * Lifecycle state of this account configuration
+     */
+    state: RemitImapAccountConfigState;
+    /**
+     * Timestamp when deletion was requested (tombstone)
+     */
+    readonly deletedAt?: number;
+    /**
+     * Timestamp when cascading cleanup started (idempotency fence)
+     */
+    readonly cascadeStartedAt?: number;
+    readonly createdAt: number;
+    readonly updatedAt: number;
+};
+
+/**
+ * Lifecycle state of an account configuration
+ */
+export type RemitImapAccountConfigState = 'active' | 'deleting';
+
+/**
+ * Response body for GET /me/export/{exportId}
+ */
+export type RemitImapAccountExportRequestResponse = {
+    /**
+     * Primary identifier
+     */
+    accountExportRequestId: Uuid;
+    /**
+     * Owning account config
+     */
+    accountConfigId: Uuid;
+    /**
+     * Cognito user id of the requesting user
+     */
+    readonly userId: string;
+    /**
+     * Current lifecycle state of the export
+     */
+    state: RemitImapAccountExportState;
+    /**
+     * Epoch millis when the request was created
+     */
+    readonly createdAt: number;
+    /**
+     * Epoch millis when the request was last updated
+     */
+    readonly updatedAt: number;
+    /**
+     * Epoch millis after which the stored archive is reclaimed by its lifecycle policy
+     */
+    readonly expiresAt?: number;
+    /**
+     * S3 object key of the ZIP archive; present only when state is Ready. The download URL is signed on demand at read time and never stored.
+     */
+    readonly objectKey?: string;
+    /**
+     * Short-lived presigned S3 URL to download the ZIP archive, signed on demand at read time; present only when state is Ready
+     */
+    readonly downloadUrl?: string;
+    /**
+     * Human-readable error message; present only when state is Failed
+     */
+    readonly errorMessage?: string;
+};
+
+/**
+ * Lifecycle state of an account export request
+ */
+export type RemitImapAccountExportState = 'Pending' | 'Processing' | 'Ready' | 'Failed';
+
+/**
+ * Account response (excluding sensitive fields). Display name, mute flag, and signatures are sourced from per-account AccountSetting rows (RFC 032), not the Account entity, but are surfaced here so the response shape is unchanged.
+ */
+export type RemitImapAccountResponse = {
+    /**
+     * Primary identifier
+     */
+    accountId: Uuid;
+    /**
+     * Reference to parent account configuration
+     */
+    accountConfigId: Uuid;
+    /**
+     * Login username
+     */
+    readonly username: string;
+    /**
+     * Primary email address
+     */
+    readonly email: string;
+    /**
+     * Authentication mechanism used by this account
+     */
+    authType: RemitImapAccountAuthType;
+    /**
+     * IMAP server hostname or IP address
+     */
+    readonly imapHost: string;
+    /**
+     * IMAP server port (typically 993 for TLS, 143 for STARTTLS)
+     */
+    readonly imapPort: number;
+    /**
+     * Whether to use TLS/SSL encryption (true for port 993)
+     */
+    readonly imapTls: boolean;
+    /**
+     * Whether to use STARTTLS upgrade (typically for port 143)
+     */
+    readonly imapStartTls: boolean;
+    /**
+     * Whether this account is configured to send mail over SMTP. The explicit marker for sending capability — never inferred from config-field presence.
+     */
+    readonly smtpEnabled: boolean;
+    /**
+     * SMTP server hostname or IP address for sending mail
+     */
+    readonly smtpHost: string;
+    /**
+     * SMTP server port (typically 587 for STARTTLS, 465 for TLS)
+     */
+    readonly smtpPort: number;
+    /**
+     * Whether to use TLS/SSL encryption for SMTP
+     */
+    readonly smtpTls: boolean;
+    /**
+     * Whether to use STARTTLS upgrade for SMTP
+     */
+    readonly smtpStartTls: boolean;
+    /**
+     * SMTP login username (may differ from IMAP username); empty when sending uses the IMAP username
+     */
+    readonly smtpUsername: string;
+    /**
+     * Whether the account is active and can login
+     */
+    readonly isActive: boolean;
+    /**
+     * Current connection state
+     */
+    connectionState: RemitImapConnectionState;
+    /**
+     * Timestamp of last successful connection
+     */
+    readonly lastConnectedAt?: number;
+    /**
+     * Timestamp of last synchronization attempt
+     */
+    readonly lastSyncAt?: number;
+    /**
+     * Error message from last failed connection attempt
+     */
+    readonly lastError?: string;
+    /**
+     * Current phase of the initial account sync lifecycle
+     */
+    syncPhase?: RemitImapSyncPhase;
+    /**
+     * Total number of mailboxes discovered during sync
+     */
+    readonly mailboxCountTotal?: number;
+    /**
+     * Number of mailboxes whose initial message sync has completed
+     */
+    readonly mailboxCountSynced?: number;
+    readonly createdAt: number;
+    readonly updatedAt: number;
+    /**
+     * User-chosen display name for this account. Optional; when absent the UI derives a label from the email address. Sourced from a per-account AccountSetting row (RFC 032).
+     */
+    displayName?: string;
+    /**
+     * Account-level mute flag. When set, all mailboxes of this account are hidden from unified/brief views (sync is unaffected). Sourced from a per-account AccountSetting row (RFC 032).
+     */
+    muted?: RemitImapMutedFlag;
+    /**
+     * Plain text email signature for this account
+     */
+    signaturePlainText?: string;
+    /**
+     * HTML email signature for this account
+     */
+    signatureHtml?: string;
+    /**
+     * Per-account appointment of each canonical role (Inbox, Drafts, Sent, Archive, Junk, Trash, All, Flagged) to at most one mailbox (RFC 032 exclusive-folder-appointment, issue #976). Always carries one entry per CanonicalMailboxRole member; an entry's `mailboxId` is a persisted user choice when set, or a server-proposed detection result when the user hasn't appointed that role yet. Write with PUT /accounts/{accountId}/folder-roles/{role}.
+     */
+    folderAppointments: Array<RemitImapFolderAppointment>;
+};
+
+/**
+ * Aggregate sync-status response for an account
+ */
+export type RemitImapAccountSyncStatusResponse = {
+    /**
+     * Account identifier
+     */
+    accountId: Uuid;
+    /**
+     * Current sync phase for the account
+     */
+    syncPhase?: RemitImapSyncPhase;
+    /**
+     * Total number of mailboxes discovered
+     */
+    mailboxCountTotal?: number;
+    /**
+     * Number of mailboxes whose initial message sync has completed
+     */
+    mailboxCountSynced?: number;
+    /**
+     * Per-mailbox sync progress
+     */
+    mailboxes: Array<RemitImapMailboxSyncProgress>;
+};
+
+/**
+ * Common metadata for sender-level flags
+ */
+export type RemitImapAddressFlagBase = {
+    /**
+     * Timestamp when the flag was set
+     */
+    setAt: number;
+    /**
+     * Device/session/user identifier that set the flag (audit trail)
+     */
+    setBy?: string;
+    /**
+     * Optional auto-revoke timestamp
+     */
+    expiresAt?: number;
+    /**
+     * Free-text user note
+     */
+    reason?: string;
+};
+
+/**
+ * Common metadata for sender-level flags
+ */
+export type RemitImapAddressFlagBaseUpdate = {
+    /**
+     * Timestamp when the flag was set
+     */
+    setAt?: number;
+    /**
+     * Device/session/user identifier that set the flag (audit trail)
+     */
+    setBy?: string;
+    /**
+     * Optional auto-revoke timestamp
+     */
+    expiresAt?: number;
+    /**
+     * Free-text user note
+     */
+    reason?: string;
+};
+
+/**
+ * Sender-level flags map. Absent keys mean absent flags (sparse).
+ */
+export type RemitImapAddressFlags = {
+    trusted?: RemitImapTrustedFlag;
+    blocked?: RemitImapBlockedFlag;
+    muted?: RemitImapMutedFlag;
+    vip?: RemitImapVipFlag;
+    wellknown?: RemitImapWellknownFlag;
+    category?: RemitImapCategoryFlag;
+    autoArchive?: RemitImapAutoArchiveFlag;
+    unsubscribed?: RemitImapUnsubscribedFlag;
+};
+
+/**
+ * Address response for address book entries
+ */
+export type RemitImapAddressResponse = {
+    /**
+     * Primary identifier
+     */
+    addressId: Uuid;
+    /**
+     * Reference to parent account configuration
+     */
+    accountConfigId: Uuid;
+    /**
+     * Personal name phrase (display-name in RFC 2822)
+     */
+    readonly displayName?: string;
+    /**
+     * Local-part before @ (addr-mailbox)
+     */
+    readonly localPart: string;
+    /**
+     * Domain after @ (addr-host)
+     */
+    readonly domain: string;
+    /**
+     * Lowercase full email address for matching/deduplication
+     */
+    readonly normalizedEmail: string;
+    /**
+     * Sender-level flags (trust/block/mute/etc). Always present; an empty map means no flags are set. Individual flag keys remain sparse — a key's presence means that flag is set.
+     */
+    flags: RemitImapAddressFlags;
+    /**
+     * Number of inbound messages received from this address. Defaults to zero.
+     */
+    readonly inboundCount: number;
+    /**
+     * Number of outbound messages sent to this address. Defaults to zero.
+     */
+    readonly outboundCount: number;
+    /**
+     * Number of user replies to messages from this address. Defaults to zero.
+     */
+    readonly replyCount: number;
+    /**
+     * Timestamp (ms epoch) of the last inbound message from this address. Zero means never.
+     */
+    readonly lastInboundAt: number;
+    /**
+     * Timestamp (ms epoch) of the last user reply to a message from this address. Zero means never.
+     */
+    readonly lastReplyAt: number;
+    readonly createdAt: number;
+    readonly updatedAt: number;
+};
+
+/**
+ * Address roles in message headers per RFC 2822 Sections 3.6.2 and 3.6.3
+ */
+export type RemitImapAddressRole = 'from' | 'sender' | 'reply_to' | 'to' | 'cc' | 'bcc';
+
+/**
+ * Input for PUT /accounts/{accountId}/folder-roles/{role}. Appoints the mailbox to the role, replacing whichever mailbox previously held it (exclusive by construction — the map has one slot per role). Pass `mailboxId: null` to clear the role back to unfilled.
+ */
+export type RemitImapAppointFolderRoleInput = {
+    /**
+     * Mailbox to appoint to the role, or `null` to clear the appointment. Typed as an inline nullable string rather than `UUID | null`: a named scalar union renders as allOf + nullable with no sibling type, which openapi-backend's AJV rejects for a `null` value — the same gotcha documented on RenameMailboxInput.displayNameOverride. An inline string keeps `null` valid at the wire; the handler validates the value as a UUID.
+     */
+    mailboxId: string | null;
+};
+
+/**
+ * Auto-archive: skip inbox, file directly
+ */
+export type RemitImapAutoArchiveFlag = RemitImapAddressFlagBase & {
+    value: boolean;
+};
+
+/**
+ * Auto-archive: skip inbox, file directly
+ */
+export type RemitImapAutoArchiveFlagUpdate = RemitImapAddressFlagBaseUpdate & {
+    value?: boolean;
+};
+
+/**
+ * Present only when Remit auto-moved this message on body-sync (a confident, non-dry-run move). Absent means the message was not auto-moved by Remit — clients treat absence as no indicator.
+ */
+export type RemitImapAutoMovedInfo = {
+    /**
+     * Direction Remit moved the message: MoveToInbox | MoveToJunk. The implied destination lets the client tell whether the move is still in effect.
+     */
+    action: RemitImapPlacementAction;
+    /**
+     * Folder role the message was moved from: inbox | junk | other. Used to render "moved from Junk" and to resolve the undo target client-side via MailboxRole.
+     */
+    fromPlacement: string;
+};
+
+/**
+ * Sender is blocked: never load images, even on explicit click
+ */
+export type RemitImapBlockedFlag = RemitImapAddressFlagBase & {
+    value: boolean;
+};
+
+/**
+ * Sender is blocked: never load images, even on explicit click
+ */
+export type RemitImapBlockedFlagUpdate = RemitImapAddressFlagBaseUpdate & {
+    value?: boolean;
+};
+
+/**
+ * Body part information
+ */
+export type RemitImapBodyPartResponse = {
+    /**
+     * Primary identifier
+     */
+    bodyPartId: Uuid;
+    /**
+     * MIME type (TEXT, IMAGE, APPLICATION, etc.)
+     */
+    mediaType: RemitImapMediaType;
+    /**
+     * MIME subtype (PLAIN, HTML, PNG, PDF, etc.)
+     */
+    readonly mediaSubtype: string;
+    /**
+     * Content-ID header value
+     */
+    readonly contentId?: string;
+    /**
+     * Encoded size in octets
+     */
+    readonly sizeOctets: number;
+    /**
+     * Content disposition (inline or attachment)
+     */
+    disposition?: RemitImapContentDisposition;
+    /**
+     * Filename from Content-Disposition
+     */
+    readonly dispositionFilename?: string;
+    /**
+     * True if this is a multipart container
+     */
+    readonly isMultipart: boolean;
+    /**
+     * CloudFront-fronted URL for fetching this body part. Cookie-authenticated via Cognito id_token. Path: /content/accounts/{accountConfigId}/{accountId}/messages/{messageId}/parts/{partPath}. Required: handlers must throw rather than emit a placeholder when CONTENT_DELIVERY_DOMAIN is unset.
+     */
+    contentUrl: string;
+};
+
+/**
+ * Input for bulk flag update operations
+ */
+export type RemitImapBulkUpdateFlagsInput = {
+    /**
+     * List of message IDs to update
+     */
+    messageIds: Array<Uuid>;
+    /**
+     * Set messages as read (maps to \Seen flag)
+     */
+    isRead?: boolean;
+    /**
+     * Set messages as starred (maps to \Flagged flag)
+     */
+    isStarred?: boolean;
+    /**
+     * Star color for visual categorization
+     */
+    starColor?: RemitImapStarColor;
+};
+
+/**
+ * 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.
+ */
+export type RemitImapCanonicalMailboxRole = 'Inbox' | 'Drafts' | 'Sent' | 'Archive' | 'Junk' | 'Trash' | 'All' | 'Flagged';
+
+/**
+ * Category override for auto-classification
+ */
+export type RemitImapCategoryFlag = RemitImapAddressFlagBase & {
+    value: RemitImapMessageCategory;
+};
+
+/**
+ * Category override for auto-classification
+ */
+export type RemitImapCategoryFlagUpdate = RemitImapAddressFlagBaseUpdate & {
+    value?: RemitImapMessageCategory;
+};
+
+/**
+ * Full configuration description including accounts
+ */
+export type RemitImapConfigDescriptionResponse = {
+    /**
+     * The account configuration
+     */
+    accountConfig: RemitImapAccountConfigResponse;
+    /**
+     * Associated email accounts
+     */
+    accounts: Array<RemitImapAccountResponse>;
+};
+
+/**
+ * IMAP connection states per RFC 9051 Section 3
+ */
+export type RemitImapConnectionState = 'not_authenticated' | 'authenticated' | 'selected' | 'logout' | 'reauth_required';
+
+/**
+ * Content disposition types per RFC 2183
+ */
+export type RemitImapContentDisposition = 'inline' | 'attachment';
+
+/**
+ * Input for copying messages to another mailbox
+ */
+export type RemitImapCopyMessagesInput = {
+    /**
+     * List of message IDs to copy
+     */
+    messageIds: Array<Uuid>;
+    /**
+     * Destination mailbox ID
+     */
+    destinationMailboxId: Uuid;
+};
+
+/**
+ * Input for creating a new email account
+ */
+export type RemitImapCreateAccountInput = {
+    /**
+     * Primary email address for this account
+     */
+    email: string;
+    /**
+     * Display name (optional)
+     */
+    displayName?: string;
+    /**
+     * IMAP login username (defaults to email if not provided)
+     */
+    username?: string;
+    /**
+     * Authentication mechanism for this account. Defaults to `password`. Pass `oauthMicrosoft` only via the OAuth connect flow (POST /accounts/oauth/microsoft/start).
+     */
+    authType?: RemitImapAccountAuthType;
+    /**
+     * Account password (will be encrypted). Required for password accounts; omit for OAuth accounts.
+     */
+    password?: string;
+    /**
+     * IMAP server hostname
+     */
+    imapHost: string;
+    /**
+     * IMAP server port
+     */
+    imapPort: number;
+    /**
+     * Use TLS encryption
+     */
+    imapTls: boolean;
+    /**
+     * Use STARTTLS upgrade
+     */
+    imapStartTls: boolean;
+    /**
+     * Whether to enable SMTP sending for this account. When omitted, the server enables sending if an SMTP host is supplied.
+     */
+    smtpEnabled?: boolean;
+    /**
+     * SMTP server hostname (optional)
+     */
+    smtpHost?: string;
+    /**
+     * SMTP server port
+     */
+    smtpPort?: number;
+    /**
+     * Use TLS encryption for SMTP
+     */
+    smtpTls?: boolean;
+    /**
+     * Use STARTTLS upgrade for SMTP
+     */
+    smtpStartTls?: boolean;
+    /**
+     * SMTP username if different from IMAP
+     */
+    smtpUsername?: string;
+    /**
+     * SMTP password if different from IMAP
+     */
+    smtpPassword?: string;
+};
+
+/**
+ * Response body for POST /me/export
+ */
+export type RemitImapCreateExportResponse = {
+    /**
+     * ID of the newly created export request
+     */
+    exportId: string;
+};
+
+/**
+ * Input for creating a filter (RFC 034). `ttl` is omitted — it is derived
+ * server-side from `expiresAt` when `scope` is `Temporary` (RFC 034 Decision
+ * 1.3), never client-supplied. `state`, `hasAnchor`, `ruleChangedAt`, and
+ * `filterId` are all server-derived and excluded by their Read-only visibility.
+ *
+ * When `anchorMessageId` is set, the server builds and persists the filter's
+ * semantic anchor from that message's indexed vectors (RFC 034 Decision 2) and
+ * sets `hasAnchor`. Absent for a purely-literal filter.
+ */
+export type RemitImapCreateFilterInput = {
+    /**
+     * Plain-language name or editable label for this filter
+     */
+    name: String256;
+    /**
+     * Standing (permanent) or Temporary (expires). Governs whether expiresAt/ttl are present (RFC 034 Decision 1).
+     */
+    scope: RemitImapFilterScope;
+    /**
+     * ISO 8601 date-time with zone offset, present only when scope is Temporary (RFC 034 Decision 1.1) — a business date, not an epoch instant. Every evaluation compares `now` against this value directly; it is the source of truth for whether a Temporary filter is still active, independent of `state` or row existence.
+     */
+    expiresAt?: string;
+    /**
+     * How literalClauses combine. Meaningless when literalClauses is empty.
+     */
+    matchOperator: RemitImapFilterMatchOperator;
+    /**
+     * Literal from/subject/has-words predicate clauses (RFC 031). Empty when the filter relies solely on its semantic anchor (see hasAnchor).
+     */
+    literalClauses: Array<RemitImapFilterClause>;
+    /**
+     * Label applied when this filter matches — additive action, any number of filters can independently apply their own label (RFC 034 Decision 3.1). The named sentinel `"None"` means no label action; never an empty/optional field.
+     */
+    actionLabelId: string;
+    /**
+     * Mailbox matched messages are moved into — exclusive action, since a message lives in exactly one mailbox (RFC 034 Decision 3.1). On conflict between filters, the one with the latest ruleChangedAt wins. `"None"` means no move action.
+     */
+    actionMailboxId: string;
+    /**
+     * Anchor message for a semantic filter — provenance for the persisted anchor the server builds at save time (RFC 034 Decision 2.1). Absent for a purely-literal filter.
+     */
+    anchorMessageId?: Uuid;
+};
+
+/**
+ * Input for creating a new mailbox
+ */
+export type RemitImapCreateMailboxInput = {
+    /**
+     * Namespace type: personal, other_users, or shared
+     */
+    namespaceType: RemitImapNamespaceType;
+    /**
+     * Complete mailbox path including hierarchy
+     */
+    fullPath: String512;
+};
+
+/**
+ * Response body for POST /accounts/{accountId}/organize
+ */
+export type RemitImapCreateOrganizeJobResponse = {
+    /**
+     * ID of the newly created organize job
+     */
+    organizeJobId: string;
+    /**
+     * Initial state of the job (Pending)
+     */
+    state: RemitImapOrganizeJobState;
+};
+
+/**
+ * Input for creating an outbox message
+ */
+export type RemitImapCreateOutboxMessageInput = {
+    /**
+     * Account to send from
+     */
+    accountId: Uuid;
+    /**
+     * Recipient addresses (To)
+     */
+    toAddresses: Array<string>;
+    /**
+     * CC recipient addresses
+     */
+    ccAddresses?: Array<string>;
+    /**
+     * BCC recipient addresses
+     */
+    bccAddresses?: Array<string>;
+    /**
+     * Subject line
+     */
+    subject?: string;
+    /**
+     * Plain text body
+     */
+    textBody?: string;
+    /**
+     * HTML body
+     */
+    htmlBody?: string;
+    /**
+     * For replies: parent message's Message-ID
+     */
+    inReplyTo?: string;
+    /**
+     * For replies: full References chain from parent
+     */
+    references?: Array<string>;
+    /**
+     * Whether to send immediately or save as draft
+     */
+    sendImmediately?: boolean;
+};
+
+/**
+ * Response for DELETE /me (account erasure request)
+ */
+export type RemitImapDeleteAccountConfigResponse = {
+    /**
+     * Human-readable confirmation message
+     */
+    message: string;
+};
+
+/**
+ * Delete account response (tombstone)
+ */
+export type RemitImapDeleteAccountResponse = {
+    /**
+     * Account ID that was marked for deletion
+     */
+    accountId: Uuid;
+    /**
+     * Timestamp when deletion was requested
+     */
+    deletedAt: number;
+    /**
+     * Message indicating async cleanup will follow
+     */
+    message: string;
+};
+
+/**
+ * Input for DELETE /me — requires the caller to confirm their email address
+ */
+export type RemitImapDeleteMeInput = {
+    /**
+     * Must match the caller's Cognito email claim (case-insensitive)
+     */
+    confirmEmail: string;
+};
+
+/**
+ * Input for deleting messages
+ */
+export type RemitImapDeleteMessagesInput = {
+    /**
+     * List of message IDs to delete
+     */
+    messageIds: Array<Uuid>;
+    /**
+     * Permanently delete instead of moving to Trash. Default: false
+     */
+    permanent?: boolean;
+};
+
+/**
+ * Complete message description including all related data. Body content is delivered via the per-part `BodyPartResponse.contentUrl` (CloudFront, JWT-authorized at the edge); the legacy `bodyText`/`bodyHtml` fields were removed once content delivery cut over end-to-end (#224).
+ */
+export type RemitImapDescribeMessageResponse = {
+    /**
+     * Core message metadata
+     */
+    message: RemitImapMessageSummaryResponse;
+    /**
+     * Envelope data
+     */
+    envelope: RemitImapEnvelopeResponse;
+    /**
+     * Message flags
+     */
+    flags: Array<string>;
+    /**
+     * Body structure. Each part exposes `contentUrl` for fetching its bytes.
+     */
+    bodyParts: Array<RemitImapBodyPartResponse>;
+    /**
+     * Message references (In-Reply-To and References headers)
+     */
+    references: Array<RemitImapMessageReferenceResponse>;
+};
+
+/**
+ * Response from emptying trash
+ */
+export type RemitImapEmptyTrashResponse = {
+    /**
+     * Number of messages permanently deleted
+     */
+    deletedCount: number;
+};
+
+/**
+ * Envelope address information. Includes the resolved Address `addressId` and per-sender `flags` so the UI can render trust state without a second fetch.
+ */
+export type RemitImapEnvelopeAddressResponse = {
+    /**
+     * Resolved Address identifier (stable per accountConfig + normalized email)
+     */
+    addressId: Uuid;
+    /**
+     * Display name as it appeared in this specific message's envelope
+     */
+    displayName?: string;
+    /**
+     * Lowercase full email address
+     */
+    normalizedEmail: string;
+    /**
+     * Role of this address in the envelope
+     */
+    addressRole: RemitImapAddressRole;
+    /**
+     * Order for multiple addresses in same role (0-indexed)
+     */
+    addressOrder: number;
+    /**
+     * Sender-level flags resolved from the linked Address
+     */
+    flags?: RemitImapAddressFlags;
+};
+
+/**
+ * Message envelope (header metadata)
+ */
+export type RemitImapEnvelopeResponse = {
+    /**
+     * Reference to parent message
+     */
+    messageId: Uuid;
+    /**
+     * Message date
+     */
+    date: number;
+    /**
+     * Message subject
+     */
+    subject?: string;
+    /**
+     * RFC 2822 Message-ID header value
+     */
+    messageIdValue?: string;
+    /**
+     * From addresses
+     */
+    from: Array<RemitImapEnvelopeAddressResponse>;
+    /**
+     * To addresses
+     */
+    to: Array<RemitImapEnvelopeAddressResponse>;
+    /**
+     * CC addresses
+     */
+    cc: Array<RemitImapEnvelopeAddressResponse>;
+    /**
+     * BCC addresses
+     */
+    bcc: Array<RemitImapEnvelopeAddressResponse>;
+    /**
+     * Reply-To addresses
+     */
+    replyTo: Array<RemitImapEnvelopeAddressResponse>;
+    /**
+     * Header-derived category for the message. Absent for messages synced before classification rolled out.
+     */
+    category?: RemitImapMessageCategory;
+    /**
+     * Trust level for the From address, derived from AddressFlags at read time.
+     */
+    senderTrust: RemitImapSenderTrust;
+};
+
+/**
+ * A single literal predicate clause (from / subject / has-words), combined with its siblings via Filter.matchOperator (RFC 031).
+ */
+export type RemitImapFilterClause = {
+    /**
+     * Message attribute this clause matches against
+     */
+    field: RemitImapFilterClauseField;
+    /**
+     * Literal text to match
+     */
+    value: String256;
+};
+
+/**
+ * Message attribute a FilterClause matches against — RFC 031's Tier 0 literal predicates (from / subject / has-words).
+ */
+export type RemitImapFilterClauseField = 'From' | 'Subject' | 'HasWords';
+
+/**
+ * How a Filter's literalClauses combine (RFC 031 "literal predicates, AND/OR"). Ignored when literalClauses is empty.
+ */
+export type RemitImapFilterMatchOperator = 'And' | 'Or';
+
+/**
+ * Filter item returned by list/get/create/update operations. `ttl` is internal bookkeeping (RFC 034 Decision 1.3) and not surfaced.
+ */
+export type RemitImapFilterResponse = {
+    /**
+     * Primary identifier. Stable id — the human name is a separate mutable overlay, never the key.
+     */
+    filterId: Uuid;
+    /**
+     * Owning account configuration
+     */
+    accountConfigId: Uuid;
+    /**
+     * Plain-language name or editable label for this filter
+     */
+    name: String256;
+    /**
+     * Standing (permanent) or Temporary (expires). Governs whether expiresAt/ttl are present (RFC 034 Decision 1).
+     */
+    scope: RemitImapFilterScope;
+    /**
+     * ISO 8601 date-time with zone offset, present only when scope is Temporary (RFC 034 Decision 1.1) — a business date, not an epoch instant. Every evaluation compares `now` against this value directly; it is the source of truth for whether a Temporary filter is still active, independent of `state` or row existence.
+     */
+    expiresAt?: string;
+    /**
+     * Cache of whether this filter is still active, backing byAccountAndState (RFC 034 Decision 1.2). Starts Active; lazily patched to Expired the first time something reads a Temporary filter past its expiresAt — whichever of index-time evaluation, retroactive replay, or a settings-page list touches it next. Never the correctness source; expiresAt is.
+     */
+    state: RemitImapFilterState;
+    /**
+     * Whether a sibling FilterAnchor row exists for this filter (RFC 034 Decision 2.3). Lets the index-time worker skip the FilterAnchor `get` entirely for purely-literal filters instead of probing for a row that may not exist.
+     */
+    readonly hasAnchor: boolean;
+    /**
+     * Epoch seconds, written only when the predicate (literalClauses, hasAnchor) or the action (actionLabelId, actionMailboxId) changes — never on a cosmetic rename. Backs most-recently-changed-filter-wins precedence for the exclusive move action (RFC 034 Decision 3.2). Distinct from ElectroDB's own updatedAt, which bumps on any write.
+     */
+    readonly ruleChangedAt: number;
+    /**
+     * How literalClauses combine. Meaningless when literalClauses is empty.
+     */
+    matchOperator: RemitImapFilterMatchOperator;
+    /**
+     * Literal from/subject/has-words predicate clauses (RFC 031). Empty when the filter relies solely on its semantic anchor (see hasAnchor).
+     */
+    literalClauses: Array<RemitImapFilterClause>;
+    /**
+     * Label applied when this filter matches — additive action, any number of filters can independently apply their own label (RFC 034 Decision 3.1). The named sentinel `"None"` means no label action; never an empty/optional field.
+     */
+    actionLabelId: string;
+    /**
+     * Mailbox matched messages are moved into — exclusive action, since a message lives in exactly one mailbox (RFC 034 Decision 3.1). On conflict between filters, the one with the latest ruleChangedAt wins. `"None"` means no move action.
+     */
+    actionMailboxId: string;
+    readonly createdAt: number;
+    readonly updatedAt: number;
+};
+
+/**
+ * Whether a Filter is permanent or expires (RFC 034 Decision 1). A Filter row exists only for these two standing scopes — the one-time "just these" / "all like these" batch actions never create one.
+ */
+export type RemitImapFilterScope = 'Standing' | 'Temporary';
+
+/**
+ * Cache of whether a Filter is still active to evaluate, backing the byAccountAndState index (RFC 034 Decision 1.2). Not the source of truth for expiry — Filter.expiresAt is, compared directly at every evaluation. Starts Active; lazily patched to Expired the first time something reads a Temporary filter past its expiresAt. No Disabled value: this RFC has no flow that pauses a filter without deleting it.
+ */
+export type RemitImapFilterState = 'Active' | 'Expired';
+
+/**
+ * Per-account appointment of a canonical role to at most one mailbox (RFC 032 exclusive-folder-appointment, issue #976). A role with no `mailboxId` is unfilled — either genuinely unappointed, or the account has no matching folder yet. Persisted as per-(account, role) AccountSetting rows (RFC 032 settings tiers), surfaced on AccountResponse.folderAppointments — never on the Mailbox entity, so two folders can never both claim the same role.
+ */
+export type RemitImapFolderAppointment = {
+    /**
+     * Which canonical role this entry fills.
+     */
+    role: RemitImapCanonicalMailboxRole;
+    /**
+     * The mailbox appointed to the role. Absent when the role is unfilled — either nothing was detected yet, or the account genuinely has no such folder. When absent on a GET, this is a server-proposed best guess (SPECIAL-USE flag, then the reserved INBOX name, then a weak name hint) rather than a user's persisted choice; it becomes persisted only once the user calls appointFolderRole.
+     */
+    mailboxId?: Uuid;
+};
+
+/**
+ * Mailbox item returned by list/get operations. The mute flag and the display-name override are sourced from per-mailbox AccountSetting rows (RFC 032), not the Mailbox entity, but are surfaced here so the response shape is unchanged. The canonical role a folder fills is not per-mailbox state — see AccountResponse.folderAppointments (RFC 032 exclusive-folder-appointment).
+ */
+export type RemitImapMailboxResponse = {
+    /**
+     * Primary identifier
+     */
+    mailboxId: Uuid;
+    /**
+     * Reference to the owning account
+     */
+    accountId: Uuid;
+    /**
+     * Namespace type: personal, other_users, or shared
+     */
+    namespaceType: RemitImapNamespaceType;
+    /**
+     * Namespace prefix (e.g., '', '~', '#shared/')
+     */
+    readonly namespacePrefix: string;
+    /**
+     * Character used to separate hierarchy levels (typically '/' or '.')
+     */
+    readonly hierarchyDelimiter: string;
+    /**
+     * Complete mailbox path including hierarchy
+     */
+    fullPath: String512;
+    /**
+     * Total message count in mailbox
+     */
+    readonly messageCount: number;
+    /**
+     * Count of unseen messages
+     */
+    readonly unseenCount: number;
+    /**
+     * Count of messages marked for deletion
+     */
+    readonly deletedCount: number;
+    /**
+     * The lowest UID that has been successfully synced (tracks downward progress)
+     */
+    readonly lastSyncUid: number;
+    /**
+     * The highest UID ever seen/synced (used to detect new messages)
+     */
+    readonly highWaterMarkUid: number;
+    /**
+     * Timestamp of the last successful message sync
+     */
+    readonly lastMessageSyncAt: number;
+    /**
+     * Denormalized list of IMAP SPECIAL-USE designations (RFC 6154). Populated from the same `\Sent`, `\Drafts`, etc. attributes the server reports during LIST. Stored on the row to avoid an N+1 join when listing mailboxes.
+     */
+    readonly specialUse?: Array<RemitImapMailboxSpecialUse>;
+    readonly createdAt: number;
+    readonly updatedAt: number;
+    /**
+     * Mailbox-level mute flag. When set, this mailbox is hidden from unified/brief views (sync is unaffected). Sourced from a per-mailbox AccountSetting row (RFC 032).
+     */
+    muted?: RemitImapMutedFlag;
+    /**
+     * User-chosen sidebar label for this mailbox. Optional; when absent the UI uses the canonical/derived folder label. Sourced from a per-mailbox AccountSetting row (RFC 032).
+     */
+    displayNameOverride?: String256;
+};
+
+/**
+ * Mailbox special-use designations, named after RFC 6154 / RFC 9051 Section 7.3.1.
+ * Values are the BARE forms (no leading backslash): Remit stores and serves
+ * `"Junk"`, not the RFC's `"\Junk"`. The runtime is bare across the generated
+ * enums and ElectroDB entities, and a backslash-prefixed value can't survive the
+ * current enum emitter anyway, so the wire contract uses the bare form.
+ */
+export type RemitImapMailboxSpecialUse = 'All' | 'Archive' | 'Drafts' | 'Flagged' | 'Junk' | 'Sent' | 'Trash' | 'Important';
+
+/**
+ * Per-mailbox progress entry in the sync-status response
+ */
+export type RemitImapMailboxSyncProgress = {
+    /**
+     * Mailbox identifier
+     */
+    mailboxId: Uuid;
+    /**
+     * Full IMAP path (e.g. INBOX, Sent)
+     */
+    fullPath: string;
+    /**
+     * Sync phase for this mailbox: pending (never synced), syncing (in-progress), or complete
+     */
+    phase: string;
+    /**
+     * Total messages in mailbox (refreshed each batch)
+     */
+    messagesTotal: number;
+    /**
+     * Approximate number of messages synced. Computed as highWaterMarkUid − lastSyncUid (UID-range approximation; UIDs are sparse so this may undercount). Clamped to messagesTotal.
+     */
+    messagesSynced: number;
+    /**
+     * Timestamp of the last successful message sync for this mailbox
+     */
+    lastSyncedAt?: number;
+};
+
+/**
+ * Top-level MIME media types per RFC 2046
+ */
+export type RemitImapMediaType = 'TEXT' | 'IMAGE' | 'AUDIO' | 'VIDEO' | 'APPLICATION' | 'MULTIPART' | 'MESSAGE';
+
+/**
+ * Structured sender-authenticity signal, derived from headers at classification time. Absent for messages classified before this field was introduced — clients should treat absence as no-signal.
+ */
+export type RemitImapMessageAuthenticity = {
+    /**
+     * Domain of the From header address
+     */
+    fromDomain: string;
+    /**
+     * DKIM signing domain (d=) that was compared, when a signature is present
+     */
+    dkimDomain?: string;
+    /**
+     * True when DKIM signing domain(s) are present and none aligns with the From domain
+     */
+    dkimMismatch: boolean;
+};
+
+/**
+ * Bulk operation result for message operations
+ */
+export type RemitImapMessageBulkOperationResult = {
+    /**
+     * Number of items successfully processed
+     */
+    successCount: number;
+    /**
+     * Number of items that failed
+     */
+    failureCount: number;
+    /**
+     * IDs of failed items
+     */
+    failedIds?: Array<Uuid>;
+};
+
+/**
+ * Header-derived message category. Set by classifyByHeaders during body-sync. Defaults to `uncategorized` until the message is body-classified.
+ */
+export type RemitImapMessageCategory = 'uncategorized' | 'personal' | 'newsletter' | 'marketing' | 'automated' | 'transactional' | 'social';
+
+/**
+ * Message reference response for In-Reply-To and References headers
+ */
+export type RemitImapMessageReferenceResponse = {
+    /**
+     * The msg-id value (without angle brackets)
+     */
+    readonly messageIdValue: string;
+    /**
+     * Type of reference: in_reply_to or references
+     */
+    referenceType: RemitImapReferenceType;
+    /**
+     * Order within References header (0-indexed). Always 0 for In-Reply-To.
+     */
+    readonly referenceOrder: number;
+};
+
+/**
+ * Core message metadata for API responses
+ */
+export type RemitImapMessageSummaryResponse = {
+    /**
+     * Primary identifier (internal UUID)
+     */
+    messageId: Uuid;
+    /**
+     * Reference to parent mailbox
+     */
+    mailboxId: Uuid;
+    /**
+     * IMAP UID - unique within mailbox, strictly ascending, never reused under same UIDVALIDITY
+     */
+    readonly uid: number;
+    /**
+     * Message size in octets in RFC 5322 format
+     */
+    readonly rfc822Size: number;
+    /**
+     * Server receipt timestamp (INTERNALDATE)
+     */
+    readonly internalDate: number;
+    /**
+     * Message-ID header value for quick reference
+     */
+    readonly messageIdHeader?: string;
+    /**
+     * Structured sender-authenticity signal derived from DKIM headers at classification time. Absent for messages classified before this field was introduced — absence means no signal.
+     */
+    authenticity?: RemitImapMessageAuthenticity;
+    /**
+     * Present only when Remit auto-moved this message on body-sync. Absent means the message was not auto-moved by Remit.
+     */
+    autoMoved?: RemitImapAutoMovedInfo;
+};
+
+/**
+ * Input for moving messages
+ */
+export type RemitImapMoveMessagesInput = {
+    /**
+     * List of message IDs to operate on
+     */
+    messageIds: Array<Uuid>;
+    /**
+     * Destination mailbox ID
+     */
+    destinationMailboxId: Uuid;
+};
+
+/**
+ * Sender is muted: do not notify on new mail
+ */
+export type RemitImapMutedFlag = RemitImapAddressFlagBase & {
+    value: boolean;
+};
+
+/**
+ * Sender is muted: do not notify on new mail
+ */
+export type RemitImapMutedFlagUpdate = RemitImapAddressFlagBaseUpdate & {
+    value?: boolean;
+};
+
+/**
+ * IMAP namespace types per RFC 9051 Section 6.3.10
+ */
+export type RemitImapNamespaceType = 'personal' | 'other_users' | 'shared';
+
+/**
+ * The predicate + action for a one-time "all like these" back-apply (RFC 034
+ * recap, #1278). A distinct model, deliberately NOT a Filter: it carries no
+ * `scope`, `expiresAt`, or `name`, so it structurally cannot create a standing
+ * rule. The anchor is derived transiently from `anchorMessageId`'s existing chunk
+ * vectors at match time and never persisted as a FilterAnchor row.
+ */
+export type RemitImapOrganizeInput = {
+    /**
+     * Anchor message for the semantic half — "all like this one". Absent for a purely-literal back-apply. The anchor vector is pooled transiently from this message's indexed chunk vectors and never written to a FilterAnchor row.
+     */
+    anchorMessageId?: Uuid;
+    /**
+     * How literalClauses combine. Meaningless when literalClauses is empty.
+     */
+    matchOperator: RemitImapFilterMatchOperator;
+    /**
+     * Literal from/subject/has-words clauses (RFC 031), reusing the Filter predicate shape. Empty when the back-apply relies solely on the semantic anchor.
+     */
+    literalClauses: Array<RemitImapFilterClause>;
+    /**
+     * Cosine cut-off for the semantic match. Absent uses the server default (the same threshold the index-time filter pipeline applies).
+     */
+    similarityThreshold?: number;
+    /**
+     * Label applied to every matching message — additive action (RFC 034 Decision 3.1). The `"None"` sentinel means no label action.
+     */
+    actionLabelId: string;
+    /**
+     * Mailbox every matching message is moved into — exclusive action (RFC 034 Decision 3.1). The `"None"` sentinel means no move action.
+     */
+    actionMailboxId: string;
+};
+
+/**
+ * Job item returned by GET /accounts/{accountId}/organize/{organizeJobId}. `ttl` is internal bookkeeping and not surfaced.
+ */
+export type RemitImapOrganizeJobResponse = {
+    /**
+     * Primary identifier
+     */
+    organizeJobId: Uuid;
+    /**
+     * Owning account config
+     */
+    accountConfigId: Uuid;
+    /**
+     * Cognito user id of the requesting user
+     */
+    readonly userId: string;
+    /**
+     * Current lifecycle state of the job
+     */
+    state: RemitImapOrganizeJobState;
+    /**
+     * Snapshot of the anchor message id, or the `"None"` sentinel for a purely-literal back-apply. A sentinel, not an optional field, so the persisted entity has no optional attributes (RFC 032).
+     */
+    readonly anchorMessageId: string;
+    /**
+     * Snapshot of how literalClauses combine
+     */
+    matchOperator: RemitImapFilterMatchOperator;
+    /**
+     * Snapshot of the literal predicate clauses
+     */
+    readonly literalClauses: Array<RemitImapFilterClause>;
+    /**
+     * Snapshot of the semantic cut-off applied for this run
+     */
+    readonly similarityThreshold: number;
+    /**
+     * Snapshot of the additive label action, or `"None"`
+     */
+    readonly actionLabelId: string;
+    /**
+     * Snapshot of the exclusive move action, or `"None"`
+     */
+    readonly actionMailboxId: string;
+    /**
+     * Number of messages matched by the predicate, set when the pass completes
+     */
+    readonly matchedCount: number;
+    /**
+     * Number of matches the action was successfully applied to
+     */
+    readonly appliedCount: number;
+    /**
+     * Number of matches whose action apply failed
+     */
+    readonly failedCount: number;
+    /**
+     * Human-readable error message; empty unless state is Failed
+     */
+    readonly errorMessage: string;
+    /**
+     * Epoch millis when the job was created
+     */
+    readonly createdAt: number;
+    /**
+     * Epoch millis when the job was last updated
+     */
+    readonly updatedAt: number;
+};
+
+/**
+ * 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 RemitImapOrganizeJobState = 'Pending' | 'Running' | 'Complete' | 'Failed';
+
+/**
+ * Response body for POST /accounts/{accountId}/organize/preview — the messages the same matcher would apply the action to, without applying it. Bounded server-side.
+ */
+export type RemitImapOrganizePreviewResponse = {
+    /**
+     * Number of messages the predicate matched within the bounded pass
+     */
+    matchedCount: number;
+    /**
+     * Ids of the matching messages, bounded to the same cap the apply pass uses
+     */
+    messageIds: Array<string>;
+};
+
+/**
+ * Outbox message response
+ */
+export type RemitImapOutboxMessageResponse = {
+    /**
+     * Primary identifier
+     */
+    outboxMessageId: Uuid;
+    /**
+     * Reference to sending account
+     */
+    accountId: Uuid;
+    /**
+     * Sender address for MAIL FROM (bounce address)
+     */
+    readonly fromAddress: string;
+    /**
+     * Display name for From header
+     */
+    readonly fromName?: string;
+    /**
+     * Recipient addresses (To)
+     */
+    readonly toAddresses: Array<string>;
+    /**
+     * CC recipient addresses. Empty when none.
+     */
+    readonly ccAddresses: Array<string>;
+    /**
+     * BCC recipient addresses. Empty when none.
+     */
+    readonly bccAddresses: Array<string>;
+    /**
+     * Subject line
+     */
+    readonly subject?: string;
+    /**
+     * In-Reply-To header value (parent message-id, without brackets)
+     */
+    readonly inReplyTo?: string;
+    /**
+     * References header values (array of message-ids, without brackets). Empty when none.
+     */
+    readonly references: Array<string>;
+    /**
+     * Plain text body
+     */
+    readonly textBody?: string;
+    /**
+     * HTML body
+     */
+    readonly htmlBody?: string;
+    /**
+     * Current send status
+     */
+    status: RemitImapOutboxMessageStatus;
+    /**
+     * Last error message if status is failed
+     */
+    readonly lastError?: string;
+    /**
+     * Timestamp when message was successfully sent
+     */
+    readonly sentAt?: number;
+    readonly createdAt: number;
+    readonly updatedAt: number;
+};
+
+/**
+ * Status of an outbox message in the send queue
+ */
+export type RemitImapOutboxMessageStatus = 'draft' | 'queued' | 'sending' | 'sent' | 'failed' | 'blocked';
+
+/**
+ * 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.
+ */
+export type RemitImapPlacementAction = 'MoveToInbox' | 'MoveToJunk';
+
+/**
+ * Raw RFC822/MIME source of a message (headers and body), decoded as a string for inspection.
+ */
+export type RemitImapRawMessageResponse = {
+    /**
+     * The complete RFC822/MIME source of the message, headers included.
+     */
+    raw: string;
+};
+
+/**
+ * Message reference types per RFC 2822 Section 3.6.4
+ */
+export type RemitImapReferenceType = 'in_reply_to' | 'references';
+
+/**
+ * Input for updating a mailbox. Rename (IMAP sync) is triggered only when `fullPath` is provided. The `muted` flag and the `displayNameOverride` override can be updated independently without triggering IMAP machinery; pass `null` to clear either. The canonical role a folder fills is appointed separately — see FolderRoleOperations.appointFolderRole (RFC 032 exclusive-folder-appointment).
+ */
+export type RemitImapRenameMailboxInput = {
+    /**
+     * New full path (triggers IMAP rename when present)
+     */
+    fullPath?: String512;
+    /**
+     * Mute flag. Pass a MutedFlag object to mute; pass `null` to clear the mute.
+     */
+    muted?: RemitImapMutedFlagUpdate | null;
+    /**
+     * Sidebar display-name override. Pass a string to set; pass `null` to clear (UI falls back to the canonical/derived label). Typed as an inline nullable string with `@maxLength(256)` rather than `String256 | null`: a named scalar union renders as allOf + nullable with no sibling type, which openapi-backend's AJV rejects for a `null` value (the `$ref` re-imposes the string type), 400ing the clear path. An inline string attaches `type:string`, AJV compiles, and `null` stays valid at the wire while the 256-length cap is preserved.
+     */
+    displayNameOverride?: string | null;
+};
+
+/**
+ * Allowed chunk types that may be the best match for a semantic-search hit
+ */
+export type RemitImapSemanticSearchChunkType = 'sender' | 'recipient' | 'subject' | 'attachment' | 'body' | 'entities';
+
+/**
+ * A single semantic-search hit. Display fields (fromName, subject, sentDate) are denormalized at index time and present for messages indexed after this feature was deployed. Older entries may omit them; clients should render a fallback when absent.
+ */
+export type RemitImapSemanticSearchResult = {
+    /**
+     * Matched message id
+     */
+    messageId: Uuid;
+    /**
+     * Thread id the matched message belongs to
+     */
+    threadId: Uuid;
+    /**
+     * Cosine similarity (or backend-equivalent) of the best matching chunk for this message; higher is more relevant
+     */
+    score: number;
+    /**
+     * Chunk type that produced the best match for this message
+     */
+    matchedChunkType: RemitImapSemanticSearchChunkType;
+    /**
+     * All mailbox ids the matched message currently lives in
+     */
+    mailboxIds: Array<Uuid>;
+    /**
+     * Display name of the sender (From header). Present for messages indexed after display-field enrichment was deployed.
+     */
+    fromName?: string;
+    /**
+     * Message subject. Present for messages indexed after display-field enrichment was deployed.
+     */
+    subject?: string;
+    /**
+     * Sent date as Unix epoch seconds. Present for messages indexed after display-field enrichment was deployed.
+     */
+    sentDate?: number;
+    /**
+     * Header-derived category of the matched message. Present for messages indexed after category enrichment was deployed; older entries omit it.
+     */
+    category?: RemitImapMessageCategory;
+};
+
+/**
+ * Trust level for the From address, derived at read time from AddressFlags + counters.
+ */
+export type RemitImapSenderTrust = 'unknown' | 'wellknown' | 'vip';
+
+/**
+ * Sort order for list operations
+ */
+export type RemitImapSortOrder = 'asc' | 'desc';
+
+/**
+ * Gmail-style star colors for message/thread marking
+ */
+export type RemitImapStarColor = 'none' | 'yellow' | 'orange' | 'red' | 'purple' | 'blue' | 'teal' | 'green' | 'yellow_bang' | 'red_bang' | 'purple_question' | 'blue_info' | 'orange_guillemet' | 'green_check' | 'yellow_check' | 'blue_star';
+
+/**
+ * Phase of the initial account sync lifecycle
+ */
+export type RemitImapSyncPhase = 'idle' | 'discovering_mailboxes' | 'syncing_inbox' | 'syncing_others' | 'complete' | 'error';
+
+/**
+ * Sync trigger response
+ */
+export type RemitImapSyncTriggerResponse = {
+    /**
+     * Whether sync was triggered successfully
+     */
+    triggered: boolean;
+    /**
+     * Message about sync status
+     */
+    message: string;
+};
+
+/**
+ * Input for testing connection without saving
+ */
+export type RemitImapTestConnectionInput = {
+    /**
+     * Account ID (optional, used to retrieve stored password if password is empty)
+     */
+    accountId?: Uuid;
+    /**
+     * IMAP login username
+     */
+    username: string;
+    /**
+     * Account password (optional if accountId provided - uses stored password)
+     */
+    password?: string;
+    /**
+     * IMAP server hostname
+     */
+    imapHost: string;
+    /**
+     * IMAP server port
+     */
+    imapPort: number;
+    /**
+     * Use TLS encryption
+     */
+    imapTls: boolean;
+    /**
+     * Use STARTTLS upgrade
+     */
+    imapStartTls: boolean;
+    /**
+     * SMTP server hostname (optional)
+     */
+    smtpHost?: string;
+    /**
+     * SMTP server port
+     */
+    smtpPort?: number;
+    /**
+     * Use TLS encryption for SMTP
+     */
+    smtpTls?: boolean;
+    /**
+     * Use STARTTLS upgrade for SMTP
+     */
+    smtpStartTls?: boolean;
+    /**
+     * SMTP username (defaults to IMAP username)
+     */
+    smtpUsername?: string;
+    /**
+     * SMTP password (defaults to IMAP password)
+     */
+    smtpPassword?: string;
+};
+
+/**
+ * Connection test result
+ */
+export type RemitImapTestConnectionResponse = {
+    /**
+     * Whether IMAP connection succeeded
+     */
+    imapSuccess: boolean;
+    /**
+     * IMAP error message if failed
+     */
+    imapError?: string;
+    /**
+     * Whether SMTP connection succeeded (null if not tested)
+     */
+    smtpSuccess?: boolean;
+    /**
+     * SMTP error message if failed
+     */
+    smtpError?: string;
+};
+
+/**
+ * Thread message item returned by list/search operations. `category` and `senderTrust` are attached at read time via batch-fetch so the inbox row can render badges without a per-row round trip.
+ */
+export type RemitImapThreadMessageResponse = {
+    /**
+     * Primary identifier
+     */
+    threadMessageId: Uuid;
+    /**
+     * Reference to parent thread
+     */
+    threadId: Uuid;
+    /**
+     * Reference to Message entity
+     */
+    messageId: Uuid;
+    /**
+     * Reference to parent account configuration
+     */
+    accountConfigId: Uuid;
+    /**
+     * Mailbox containing this message
+     */
+    mailboxId: Uuid;
+    /**
+     * Sender email address (denormalized for display)
+     */
+    readonly fromEmail?: string;
+    /**
+     * Sender display name (denormalized for display)
+     */
+    readonly fromName?: string;
+    /**
+     * Message subject
+     */
+    readonly subject?: string;
+    /**
+     * Envelope date from message headers (when message was sent)
+     */
+    readonly sentDate: number;
+    /**
+     * Message has \Seen flag
+     */
+    readonly isRead: boolean;
+    /**
+     * Message has attachments
+     */
+    readonly hasAttachment: boolean;
+    /**
+     * Message-level star color. Defaults to `None` (no star) — the absent state is a named sentinel value, never an empty field. `hasStars` carries the boolean the byStarred index filters on.
+     */
+    star: RemitImapStarColor;
+    /**
+     * True if message is starred (for index filtering)
+     */
+    readonly hasStars: boolean;
+    /**
+     * True if message is in Trash or deleted (for UI filtering)
+     */
+    readonly isDeleted: boolean;
+    /**
+     * Preview text (~256 chars)
+     */
+    snippet?: String256;
+    readonly createdAt: number;
+    readonly updatedAt: number;
+    /**
+     * Header-derived category for the message (from the underlying Message). Absent for messages synced before classification rolled out — clients should treat this as `personal`.
+     */
+    category?: RemitImapMessageCategory;
+    /**
+     * Trust level for the From address, derived from AddressFlags at read time. Defaults to `unknown` when no Address row resolves.
+     */
+    senderTrust: RemitImapSenderTrust;
+    /**
+     * Structured sender-authenticity signal derived from DKIM headers at classification time (from the underlying Message). Absent for messages classified before this field was introduced — absence means no signal.
+     */
+    authenticity?: RemitImapMessageAuthenticity;
+    /**
+     * Account identifier attached at read time via a mailboxId→accountId map. Present on rows returned by `GET /threads`; absent on rows from per-mailbox endpoints (clients can resolve from the mailbox cache).
+     */
+    accountId?: Uuid;
+    /**
+     * Present only when Remit auto-moved this message on body-sync. Absent means the message was not auto-moved by Remit.
+     */
+    autoMoved?: RemitImapAutoMovedInfo;
+};
+
+/**
+ * Aggregate response for `searchThreads`. Carries the matching rows (`items`), a
+ * pagination `continuationToken`, and an optional `count` of matches within the
+ * server-capped window. `items` is omitted when `results=false` (count-only);
+ * `count` is present only when `count=true`. Thread-specific so the shared
+ * `ResultList<T>` (7 endpoints) stays untouched.
+ */
+export type RemitImapThreadSearchResponse = {
+    /**
+     * Matching thread rows for this page. Omitted when `results=false` (count-only mode).
+     */
+    items?: Array<RemitImapThreadMessageResponse>;
+    /**
+     * Pass to the next call to fetch the next page; absent when the window is exhausted.
+     */
+    continuationToken?: String800;
+    /**
+     * Number of matches within the server-capped window. Present only when `count=true`.
+     */
+    count?: number;
+};
+
+/**
+ * Sender is trusted: auto-load images, allow author backgrounds
+ */
+export type RemitImapTrustedFlag = RemitImapAddressFlagBase & {
+    value: boolean;
+};
+
+/**
+ * Sender is trusted: auto-load images, allow author backgrounds
+ */
+export type RemitImapTrustedFlagUpdate = RemitImapAddressFlagBaseUpdate & {
+    value?: boolean;
+};
+
+/**
+ * User has unsubscribed; auto-mark-read until sender stops
+ */
+export type RemitImapUnsubscribedFlag = RemitImapAddressFlagBase & {
+    value: boolean;
+};
+
+/**
+ * User has unsubscribed; auto-mark-read until sender stops
+ */
+export type RemitImapUnsubscribedFlagUpdate = RemitImapAddressFlagBaseUpdate & {
+    value?: boolean;
+};
+
+/**
+ * Input for updating an existing account
+ */
+export type RemitImapUpdateAccountInput = {
+    /**
+     * Display name
+     */
+    displayName?: string;
+    /**
+     * Account password (only if changing)
+     */
+    password?: string;
+    /**
+     * IMAP server hostname
+     */
+    imapHost?: string;
+    /**
+     * IMAP server port
+     */
+    imapPort?: number;
+    /**
+     * Use TLS encryption
+     */
+    imapTls?: boolean;
+    /**
+     * Use STARTTLS upgrade
+     */
+    imapStartTls?: boolean;
+    /**
+     * Whether SMTP sending is enabled for this account. When omitted, the server enables sending if an SMTP host is supplied here or already stored.
+     */
+    smtpEnabled?: boolean;
+    /**
+     * SMTP server hostname
+     */
+    smtpHost?: string;
+    /**
+     * SMTP server port
+     */
+    smtpPort?: number;
+    /**
+     * Use TLS encryption for SMTP
+     */
+    smtpTls?: boolean;
+    /**
+     * Use STARTTLS upgrade for SMTP
+     */
+    smtpStartTls?: boolean;
+    /**
+     * SMTP username
+     */
+    smtpUsername?: string;
+    /**
+     * SMTP password (only if changing)
+     */
+    smtpPassword?: string;
+    /**
+     * Enable/disable account
+     */
+    isActive?: boolean;
+    /**
+     * Plain text email signature
+     */
+    signaturePlainText?: string;
+    /**
+     * HTML email signature
+     */
+    signatureHtml?: string;
+    /**
+     * Account-level mute flag. Pass a MutedFlag object to mute; pass `null` to clear the mute.
+     */
+    muted?: RemitImapMutedFlagUpdate | null;
+};
+
+/**
+ * Patch payload for a single AddressFlags entry. Pass `null` for a flag key to remove that flag while leaving the others untouched.
+ */
+export type RemitImapUpdateAddressFlagsInput = {
+    trusted?: RemitImapTrustedFlagUpdate | null;
+    blocked?: RemitImapBlockedFlagUpdate | null;
+    muted?: RemitImapMutedFlagUpdate | null;
+    vip?: RemitImapVipFlagUpdate | null;
+    wellknown?: RemitImapWellknownFlagUpdate | null;
+    category?: RemitImapCategoryFlagUpdate | null;
+    autoArchive?: RemitImapAutoArchiveFlagUpdate | null;
+    unsubscribed?: RemitImapUnsubscribedFlagUpdate | null;
+};
+
+/**
+ * Input for updating an Address (currently flag updates only)
+ */
+export type RemitImapUpdateAddressInput = {
+    /**
+     * Per-flag merge update; omitted flags are untouched, `null` removes the flag
+     */
+    flags?: RemitImapUpdateAddressFlagsInput;
+};
+
+/**
+ * Input for updating a filter (RFC 034). Only the mutable name/predicate/action fields are updatable — `scope`, `expiresAt`, and `ttl` are fixed at creation, and `state`/`hasAnchor`/`ruleChangedAt`/`filterId` are server-derived. A patch touching a predicate or action field bumps `ruleChangedAt`; a name-only rename never does (RFC 034 Decision 3.2).
+ */
+export type RemitImapUpdateFilterInput = {
+    /**
+     * Plain-language name or editable label for this filter
+     */
+    name?: String256;
+    /**
+     * How literalClauses combine. Meaningless when literalClauses is empty.
+     */
+    matchOperator?: RemitImapFilterMatchOperator;
+    /**
+     * Literal from/subject/has-words predicate clauses (RFC 031). Empty when the filter relies solely on its semantic anchor (see hasAnchor).
+     */
+    literalClauses?: Array<RemitImapFilterClause>;
+    /**
+     * Label applied when this filter matches — additive action, any number of filters can independently apply their own label (RFC 034 Decision 3.1). The named sentinel `"None"` means no label action; never an empty/optional field.
+     */
+    actionLabelId?: string;
+    /**
+     * Mailbox matched messages are moved into — exclusive action, since a message lives in exactly one mailbox (RFC 034 Decision 3.1). On conflict between filters, the one with the latest ruleChangedAt wins. `"None"` means no move action.
+     */
+    actionMailboxId?: string;
+};
+
+/**
+ * Input for updating message flags (translated to IMAP flags server-side)
+ */
+export type RemitImapUpdateFlagsInput = {
+    /**
+     * Set message as read (maps to \Seen flag)
+     */
+    isRead?: boolean;
+    /**
+     * Set message as starred (maps to \Flagged flag)
+     */
+    isStarred?: boolean;
+    /**
+     * Star color for visual categorization
+     */
+    starColor?: RemitImapStarColor;
+};
+
+/**
+ * Input for updating a draft outbox message
+ */
+export type RemitImapUpdateOutboxMessageInput = {
+    /**
+     * Recipient addresses (To)
+     */
+    toAddresses?: Array<string>;
+    /**
+     * CC recipient addresses
+     */
+    ccAddresses?: Array<string>;
+    /**
+     * BCC recipient addresses
+     */
+    bccAddresses?: Array<string>;
+    /**
+     * Subject line
+     */
+    subject?: string;
+    /**
+     * Plain text body
+     */
+    textBody?: string;
+    /**
+     * HTML body
+     */
+    htmlBody?: string;
+    /**
+     * For replies: parent message's Message-ID
+     */
+    inReplyTo?: string;
+    /**
+     * For replies: full References chain from parent
+     */
+    references?: Array<string>;
+};
+
+/**
+ * Sender is VIP: priority surface and push escalation
+ */
+export type RemitImapVipFlag = RemitImapAddressFlagBase & {
+    value: boolean;
+};
+
+/**
+ * Sender is VIP: priority surface and push escalation
+ */
+export type RemitImapVipFlagUpdate = RemitImapAddressFlagBaseUpdate & {
+    value?: boolean;
+};
+
+/**
+ * A reciprocal-engagement candidate for VIP promotion. The user opts in via `PATCH /addresses/{addressId}` with `flags.vip = { value: true, ... }`.
+ */
+export type RemitImapVipSuggestionEntry = {
+    /**
+     * Resolved Address identifier
+     */
+    addressId: Uuid;
+    /**
+     * Personal name phrase, when known
+     */
+    displayName?: string;
+    /**
+     * Lowercase full email address
+     */
+    normalizedEmail: string;
+    /**
+     * Number of inbound messages received from this address
+     */
+    inboundCount: number;
+    /**
+     * Number of outbound messages sent to this address
+     */
+    outboundCount: number;
+    /**
+     * Number of user replies to messages from this address
+     */
+    replyCount: number;
+    /**
+     * Timestamp (ms epoch) of the last user reply to a message from this address
+     */
+    lastReplyAt?: number;
+    /**
+     * Timestamp (ms epoch) of the last inbound message from this address
+     */
+    lastInboundAt?: number;
+};
+
+/**
+ * Response for `GET /me/vip-suggestions` — wellknown senders the user has not yet promoted to VIP, ranked by reciprocal engagement.
+ */
+export type RemitImapVipSuggestionsResponse = {
+    /**
+     * Up to 10 ranked suggestions; empty when there are no eligible senders yet.
+     */
+    suggestions: Array<RemitImapVipSuggestionEntry>;
+};
+
+/**
+ * Sender is wellknown: engagement counters crossed the promotion threshold
+ */
+export type RemitImapWellknownFlag = RemitImapAddressFlagBase & {
+    value: boolean;
+};
+
+/**
+ * Sender is wellknown: engagement counters crossed the promotion threshold
+ */
+export type RemitImapWellknownFlagUpdate = RemitImapAddressFlagBaseUpdate & {
+    value?: boolean;
+};
+
+export type String256 = string;
+
+export type String512 = string;
+
+export type String800 = string;
+
+export type Uuid = string;
+
+/**
+ * Account response (excluding sensitive fields). Display name, mute flag, and signatures are sourced from per-account AccountSetting rows (RFC 032), not the Account entity, but are surfaced here so the response shape is unchanged.
+ */
+export type RemitImapAccountResponseWritable = {
+    /**
+     * User-chosen display name for this account. Optional; when absent the UI derives a label from the email address. Sourced from a per-account AccountSetting row (RFC 032).
+     */
+    displayName?: string;
+    /**
+     * Account-level mute flag. When set, all mailboxes of this account are hidden from unified/brief views (sync is unaffected). Sourced from a per-account AccountSetting row (RFC 032).
+     */
+    muted?: RemitImapMutedFlag;
+    /**
+     * Plain text email signature for this account
+     */
+    signaturePlainText?: string;
+    /**
+     * HTML email signature for this account
+     */
+    signatureHtml?: string;
+    /**
+     * Per-account appointment of each canonical role (Inbox, Drafts, Sent, Archive, Junk, Trash, All, Flagged) to at most one mailbox (RFC 032 exclusive-folder-appointment, issue #976). Always carries one entry per CanonicalMailboxRole member; an entry's `mailboxId` is a persisted user choice when set, or a server-proposed detection result when the user hasn't appointed that role yet. Write with PUT /accounts/{accountId}/folder-roles/{role}.
+     */
+    folderAppointments: Array<RemitImapFolderAppointment>;
+};
+
+/**
+ * Address response for address book entries
+ */
+export type RemitImapAddressResponseWritable = {
+    [key: string]: unknown;
+};
+
+/**
+ * Body part information
+ */
+export type RemitImapBodyPartResponseWritable = {
+    /**
+     * CloudFront-fronted URL for fetching this body part. Cookie-authenticated via Cognito id_token. Path: /content/accounts/{accountConfigId}/{accountId}/messages/{messageId}/parts/{partPath}. Required: handlers must throw rather than emit a placeholder when CONTENT_DELIVERY_DOMAIN is unset.
+     */
+    contentUrl: string;
+};
+
+/**
+ * Full configuration description including accounts
+ */
+export type RemitImapConfigDescriptionResponseWritable = {
+    /**
+     * The account configuration
+     */
+    accountConfig: unknown;
+    /**
+     * Associated email accounts
+     */
+    accounts: Array<RemitImapAccountResponseWritable>;
+};
+
+/**
+ * Complete message description including all related data. Body content is delivered via the per-part `BodyPartResponse.contentUrl` (CloudFront, JWT-authorized at the edge); the legacy `bodyText`/`bodyHtml` fields were removed once content delivery cut over end-to-end (#224).
+ */
+export type RemitImapDescribeMessageResponseWritable = {
+    /**
+     * Core message metadata
+     */
+    message: RemitImapMessageSummaryResponseWritable;
+    /**
+     * Envelope data
+     */
+    envelope: RemitImapEnvelopeResponse;
+    /**
+     * Message flags
+     */
+    flags: Array<string>;
+    /**
+     * Body structure. Each part exposes `contentUrl` for fetching its bytes.
+     */
+    bodyParts: Array<RemitImapBodyPartResponseWritable>;
+    /**
+     * Message references (In-Reply-To and References headers)
+     */
+    references: Array<unknown>;
+};
+
+/**
+ * Filter item returned by list/get/create/update operations. `ttl` is internal bookkeeping (RFC 034 Decision 1.3) and not surfaced.
+ */
+export type RemitImapFilterResponseWritable = {
+    /**
+     * Plain-language name or editable label for this filter
+     */
+    name: String256;
+    /**
+     * Standing (permanent) or Temporary (expires). Governs whether expiresAt/ttl are present (RFC 034 Decision 1).
+     */
+    scope: RemitImapFilterScope;
+    /**
+     * ISO 8601 date-time with zone offset, present only when scope is Temporary (RFC 034 Decision 1.1) — a business date, not an epoch instant. Every evaluation compares `now` against this value directly; it is the source of truth for whether a Temporary filter is still active, independent of `state` or row existence.
+     */
+    expiresAt?: string;
+    /**
+     * How literalClauses combine. Meaningless when literalClauses is empty.
+     */
+    matchOperator: RemitImapFilterMatchOperator;
+    /**
+     * Literal from/subject/has-words predicate clauses (RFC 031). Empty when the filter relies solely on its semantic anchor (see hasAnchor).
+     */
+    literalClauses: Array<RemitImapFilterClause>;
+    /**
+     * Label applied when this filter matches — additive action, any number of filters can independently apply their own label (RFC 034 Decision 3.1). The named sentinel `"None"` means no label action; never an empty/optional field.
+     */
+    actionLabelId: string;
+    /**
+     * Mailbox matched messages are moved into — exclusive action, since a message lives in exactly one mailbox (RFC 034 Decision 3.1). On conflict between filters, the one with the latest ruleChangedAt wins. `"None"` means no move action.
+     */
+    actionMailboxId: string;
+};
+
+/**
+ * Mailbox item returned by list/get operations. The mute flag and the display-name override are sourced from per-mailbox AccountSetting rows (RFC 032), not the Mailbox entity, but are surfaced here so the response shape is unchanged. The canonical role a folder fills is not per-mailbox state — see AccountResponse.folderAppointments (RFC 032 exclusive-folder-appointment).
+ */
+export type RemitImapMailboxResponseWritable = {
+    /**
+     * Namespace type: personal, other_users, or shared
+     */
+    namespaceType: RemitImapNamespaceType;
+    /**
+     * Complete mailbox path including hierarchy
+     */
+    fullPath: String512;
+    /**
+     * Mailbox-level mute flag. When set, this mailbox is hidden from unified/brief views (sync is unaffected). Sourced from a per-mailbox AccountSetting row (RFC 032).
+     */
+    muted?: RemitImapMutedFlag;
+    /**
+     * User-chosen sidebar label for this mailbox. Optional; when absent the UI uses the canonical/derived folder label. Sourced from a per-mailbox AccountSetting row (RFC 032).
+     */
+    displayNameOverride?: String256;
+};
+
+/**
+ * Core message metadata for API responses
+ */
+export type RemitImapMessageSummaryResponseWritable = {
+    /**
+     * Present only when Remit auto-moved this message on body-sync. Absent means the message was not auto-moved by Remit.
+     */
+    autoMoved?: RemitImapAutoMovedInfo;
+};
+
+/**
+ * Job item returned by GET /accounts/{accountId}/organize/{organizeJobId}. `ttl` is internal bookkeeping and not surfaced.
+ */
+export type RemitImapOrganizeJobResponseWritable = {
+    [key: string]: unknown;
+};
+
+/**
+ * Thread message item returned by list/search operations. `category` and `senderTrust` are attached at read time via batch-fetch so the inbox row can render badges without a per-row round trip.
+ */
+export type RemitImapThreadMessageResponseWritable = {
+    /**
+     * Header-derived category for the message (from the underlying Message). Absent for messages synced before classification rolled out — clients should treat this as `personal`.
+     */
+    category?: RemitImapMessageCategory;
+    /**
+     * Trust level for the From address, derived from AddressFlags at read time. Defaults to `unknown` when no Address row resolves.
+     */
+    senderTrust: RemitImapSenderTrust;
+    /**
+     * Structured sender-authenticity signal derived from DKIM headers at classification time (from the underlying Message). Absent for messages classified before this field was introduced — absence means no signal.
+     */
+    authenticity?: RemitImapMessageAuthenticity;
+    /**
+     * Account identifier attached at read time via a mailboxId→accountId map. Present on rows returned by `GET /threads`; absent on rows from per-mailbox endpoints (clients can resolve from the mailbox cache).
+     */
+    accountId?: Uuid;
+    /**
+     * Present only when Remit auto-moved this message on body-sync. Absent means the message was not auto-moved by Remit.
+     */
+    autoMoved?: RemitImapAutoMovedInfo;
+};
+
+/**
+ * Aggregate response for `searchThreads`. Carries the matching rows (`items`), a
+ * pagination `continuationToken`, and an optional `count` of matches within the
+ * server-capped window. `items` is omitted when `results=false` (count-only);
+ * `count` is present only when `count=true`. Thread-specific so the shared
+ * `ResultList<T>` (7 endpoints) stays untouched.
+ */
+export type RemitImapThreadSearchResponseWritable = {
+    /**
+     * Matching thread rows for this page. Omitted when `results=false` (count-only mode).
+     */
+    items?: Array<RemitImapThreadMessageResponseWritable>;
+    /**
+     * Pass to the next call to fetch the next page; absent when the window is exhausted.
+     */
+    continuationToken?: String800;
+    /**
+     * Number of matches within the server-capped window. Present only when `count=true`.
+     */
+    count?: number;
+};
+
+export type AccountOperationsCreateAccountData = {
+    body: RemitImapCreateAccountInput;
+    path?: never;
+    query?: never;
+    url: '/accounts';
+};
+
+export type AccountOperationsCreateAccountResponses = {
+    /**
+     * The request has succeeded.
+     */
+    200: RemitImapAccountResponse;
+};
+
+export type AccountOperationsCreateAccountResponse = AccountOperationsCreateAccountResponses[keyof AccountOperationsCreateAccountResponses];
+
+export type MicrosoftOAuthOperationsMicrosoftOAuthCallbackData = {
+    body?: never;
+    path?: never;
+    query?: {
+        code?: string;
+        state?: string;
+        error?: string;
+    };
+    url: '/accounts/oauth/microsoft/callback';
+};
+
+export type MicrosoftOAuthOperationsMicrosoftOAuthStartData = {
+    body: MicrosoftOAuthStartRequest;
+    path?: never;
+    query?: never;
+    url: '/accounts/oauth/microsoft/start';
+};
+
+export type MicrosoftOAuthOperationsMicrosoftOAuthStartResponses = {
+    /**
+     * The request has succeeded.
+     */
+    200: MicrosoftOAuthStartResponse;
+};
+
+export type MicrosoftOAuthOperationsMicrosoftOAuthStartResponse = MicrosoftOAuthOperationsMicrosoftOAuthStartResponses[keyof MicrosoftOAuthOperationsMicrosoftOAuthStartResponses];
+
+export type AccountOperationsTestConnectionData = {
+    body: RemitImapTestConnectionInput;
+    path?: never;
+    query?: never;
+    url: '/accounts/test-connection';
+};
+
+export type AccountOperationsTestConnectionResponses = {
+    /**
+     * The request has succeeded.
+     */
+    200: RemitImapTestConnectionResponse;
+};
+
+export type AccountOperationsTestConnectionResponse = AccountOperationsTestConnectionResponses[keyof AccountOperationsTestConnectionResponses];
+
+export type AccountDetailOperationsDeleteAccountData = {
+    body?: never;
+    path: {
+        accountId: Uuid;
+    };
+    query?: never;
+    url: '/accounts/{accountId}';
+};
+
+export type AccountDetailOperationsDeleteAccountResponses = {
+    /**
+     * The request has succeeded.
+     */
+    200: RemitImapDeleteAccountResponse;
+};
+
+export type AccountDetailOperationsDeleteAccountResponse = AccountDetailOperationsDeleteAccountResponses[keyof AccountDetailOperationsDeleteAccountResponses];
+
+export type AccountDetailOperationsUpdateAccountData = {
+    body: RemitImapUpdateAccountInput;
+    path: {
+        accountId: Uuid;
+    };
+    query?: never;
+    url: '/accounts/{accountId}';
+};
+
+export type AccountDetailOperationsUpdateAccountResponses = {
+    /**
+     * The request has succeeded.
+     */
+    200: RemitImapAccountResponse;
+};
+
+export type AccountDetailOperationsUpdateAccountResponse = AccountDetailOperationsUpdateAccountResponses[keyof AccountDetailOperationsUpdateAccountResponses];
+
+export type FilterOperationsListFiltersData = {
+    body?: never;
+    path: {
+        accountId: Uuid;
+    };
+    query?: {
+        continuationToken?: string;
+    };
+    url: '/accounts/{accountId}/filters';
+};
+
+export type FilterOperationsListFiltersResponses = {
+    /**
+     * The request has succeeded.
+     */
+    200: {
+        continuationToken?: String800;
+        items: Array<RemitImapFilterResponse>;
+    };
+};
+
+export type FilterOperationsListFiltersResponse = FilterOperationsListFiltersResponses[keyof FilterOperationsListFiltersResponses];
+
+export type FilterOperationsCreateFilterData = {
+    body: RemitImapCreateFilterInput;
+    path: {
+        accountId: Uuid;
+    };
+    query?: never;
+    url: '/accounts/{accountId}/filters';
+};
+
+export type FilterOperationsCreateFilterResponses = {
+    /**
+     * The request has succeeded.
+     */
+    200: RemitImapFilterResponse;
+};
+
+export type FilterOperationsCreateFilterResponse = FilterOperationsCreateFilterResponses[keyof FilterOperationsCreateFilterResponses];
+
+export type FilterDetailOperationsDeleteFilterData = {
+    body?: never;
+    path: {
+        accountId: Uuid;
+        filterId: Uuid;
+    };
+    query?: never;
+    url: '/accounts/{accountId}/filters/{filterId}';
+};
+
+export type FilterDetailOperationsDeleteFilterResponses = {
+    /**
+     * There is no content to send for this request, but the headers may be useful.
+     */
+    204: void;
+};
+
+export type FilterDetailOperationsDeleteFilterResponse = FilterDetailOperationsDeleteFilterResponses[keyof FilterDetailOperationsDeleteFilterResponses];
+
+export type FilterDetailOperationsGetFilterData = {
+    body?: never;
+    path: {
+        accountId: Uuid;
+        filterId: Uuid;
+    };
+    query?: never;
+    url: '/accounts/{accountId}/filters/{filterId}';
+};
+
+export type FilterDetailOperationsGetFilterResponses = {
+    /**
+     * The request has succeeded.
+     */
+    200: RemitImapFilterResponse;
+};
+
+export type FilterDetailOperationsGetFilterResponse = FilterDetailOperationsGetFilterResponses[keyof FilterDetailOperationsGetFilterResponses];
+
+export type FilterDetailOperationsUpdateFilterData = {
+    body: RemitImapUpdateFilterInput;
+    path: {
+        accountId: Uuid;
+        filterId: Uuid;
+    };
+    query?: never;
+    url: '/accounts/{accountId}/filters/{filterId}';
+};
+
+export type FilterDetailOperationsUpdateFilterResponses = {
+    /**
+     * The request has succeeded.
+     */
+    200: RemitImapFilterResponse;
+};
+
+export type FilterDetailOperationsUpdateFilterResponse = FilterDetailOperationsUpdateFilterResponses[keyof FilterDetailOperationsUpdateFilterResponses];
+
+export type FolderRoleOperationsAppointFolderRoleData = {
+    body: RemitImapAppointFolderRoleInput;
+    path: {
+        accountId: Uuid;
+        role: RemitImapCanonicalMailboxRole;
+    };
+    query?: never;
+    url: '/accounts/{accountId}/folder-roles/{role}';
+};
+
+export type FolderRoleOperationsAppointFolderRoleResponses = {
+    /**
+     * The request has succeeded.
+     */
+    200: RemitImapAccountResponse;
+};
+
+export type FolderRoleOperationsAppointFolderRoleResponse = FolderRoleOperationsAppointFolderRoleResponses[keyof FolderRoleOperationsAppointFolderRoleResponses];
+
+export type MailboxOperationsListMailboxesData = {
+    body?: never;
+    path: {
+        accountId: Uuid;
+    };
+    query?: {
+        continuationToken?: string;
+    };
+    url: '/accounts/{accountId}/mailboxes';
+};
+
+export type MailboxOperationsListMailboxesResponses = {
+    /**
+     * The request has succeeded.
+     */
+    200: {
+        continuationToken?: String800;
+        items: Array<RemitImapMailboxResponse>;
+    };
+};
+
+export type MailboxOperationsListMailboxesResponse = MailboxOperationsListMailboxesResponses[keyof MailboxOperationsListMailboxesResponses];
+
+export type MailboxOperationsCreateMailboxData = {
+    body: RemitImapCreateMailboxInput;
+    path: {
+        accountId: Uuid;
+    };
+    query?: never;
+    url: '/accounts/{accountId}/mailboxes';
+};
+
+export type MailboxOperationsCreateMailboxResponses = {
+    /**
+     * The request has succeeded.
+     */
+    200: RemitImapMailboxResponse;
+};
+
+export type MailboxOperationsCreateMailboxResponse = MailboxOperationsCreateMailboxResponses[keyof MailboxOperationsCreateMailboxResponses];
+
+export type MailboxDetailOperationsDeleteMailboxData = {
+    body?: never;
+    path: {
+        accountId: Uuid;
+        mailboxId: Uuid;
+    };
+    query?: never;
+    url: '/accounts/{accountId}/mailboxes/{mailboxId}';
+};
+
+export type MailboxDetailOperationsDeleteMailboxResponses = {
+    /**
+     * There is no content to send for this request, but the headers may be useful.
+     */
+    204: void;
+};
+
+export type MailboxDetailOperationsDeleteMailboxResponse = MailboxDetailOperationsDeleteMailboxResponses[keyof MailboxDetailOperationsDeleteMailboxResponses];
+
+export type MailboxDetailOperationsGetMailboxData = {
+    body?: never;
+    path: {
+        accountId: Uuid;
+        mailboxId: Uuid;
+    };
+    query?: never;
+    url: '/accounts/{accountId}/mailboxes/{mailboxId}';
+};
+
+export type MailboxDetailOperationsGetMailboxResponses = {
+    /**
+     * The request has succeeded.
+     */
+    200: RemitImapMailboxResponse;
+};
+
+export type MailboxDetailOperationsGetMailboxResponse = MailboxDetailOperationsGetMailboxResponses[keyof MailboxDetailOperationsGetMailboxResponses];
+
+export type MailboxDetailOperationsRenameMailboxData = {
+    body: RemitImapRenameMailboxInput;
+    path: {
+        accountId: Uuid;
+        mailboxId: Uuid;
+    };
+    query?: never;
+    url: '/accounts/{accountId}/mailboxes/{mailboxId}';
+};
+
+export type MailboxDetailOperationsRenameMailboxResponses = {
+    /**
+     * The request has succeeded.
+     */
+    200: RemitImapMailboxResponse;
+};
+
+export type MailboxDetailOperationsRenameMailboxResponse = MailboxDetailOperationsRenameMailboxResponses[keyof MailboxDetailOperationsRenameMailboxResponses];
+
+export type OrganizeOperationsCreateOrganizeJobData = {
+    body: RemitImapOrganizeInput;
+    path: {
+        accountId: Uuid;
+    };
+    query?: never;
+    url: '/accounts/{accountId}/organize';
+};
+
+export type OrganizeOperationsCreateOrganizeJobResponses = {
+    /**
+     * Response body for POST /accounts/{accountId}/organize
+     */
+    202: RemitImapCreateOrganizeJobResponse;
+};
+
+export type OrganizeOperationsCreateOrganizeJobResponse = OrganizeOperationsCreateOrganizeJobResponses[keyof OrganizeOperationsCreateOrganizeJobResponses];
+
+export type OrganizeOperationsPreviewOrganizeData = {
+    body: RemitImapOrganizeInput;
+    path: {
+        accountId: Uuid;
+    };
+    query?: never;
+    url: '/accounts/{accountId}/organize/preview';
+};
+
+export type OrganizeOperationsPreviewOrganizeResponses = {
+    /**
+     * The request has succeeded.
+     */
+    200: RemitImapOrganizePreviewResponse;
+};
+
+export type OrganizeOperationsPreviewOrganizeResponse = OrganizeOperationsPreviewOrganizeResponses[keyof OrganizeOperationsPreviewOrganizeResponses];
+
+export type OrganizeJobDetailOperationsGetOrganizeJobData = {
+    body?: never;
+    path: {
+        accountId: Uuid;
+        organizeJobId: Uuid;
+    };
+    query?: never;
+    url: '/accounts/{accountId}/organize/{organizeJobId}';
+};
+
+export type OrganizeJobDetailOperationsGetOrganizeJobResponses = {
+    /**
+     * The request has succeeded.
+     */
+    200: RemitImapOrganizeJobResponse;
+};
+
+export type OrganizeJobDetailOperationsGetOrganizeJobResponse = OrganizeJobDetailOperationsGetOrganizeJobResponses[keyof OrganizeJobDetailOperationsGetOrganizeJobResponses];
+
+export type SyncOperationsTriggerSyncData = {
+    body?: never;
+    path: {
+        accountId: Uuid;
+    };
+    query?: never;
+    url: '/accounts/{accountId}/sync';
+};
+
+export type SyncOperationsTriggerSyncResponses = {
+    /**
+     * The request has succeeded.
+     */
+    200: RemitImapSyncTriggerResponse;
+};
+
+export type SyncOperationsTriggerSyncResponse = SyncOperationsTriggerSyncResponses[keyof SyncOperationsTriggerSyncResponses];
+
+export type SyncOperationsGetSyncStatusData = {
+    body?: never;
+    path: {
+        accountId: Uuid;
+    };
+    query?: never;
+    url: '/accounts/{accountId}/sync/status';
+};
+
+export type SyncOperationsGetSyncStatusResponses = {
+    /**
+     * The request has succeeded.
+     */
+    200: RemitImapAccountSyncStatusResponse;
+};
+
+export type SyncOperationsGetSyncStatusResponse = SyncOperationsGetSyncStatusResponses[keyof SyncOperationsGetSyncStatusResponses];
+
+export type TrashOperationsEmptyTrashData = {
+    body?: never;
+    path: {
+        accountId: Uuid;
+    };
+    query?: never;
+    url: '/accounts/{accountId}/trash/empty';
+};
+
+export type TrashOperationsEmptyTrashResponses = {
+    /**
+     * The request has succeeded.
+     */
+    200: RemitImapEmptyTrashResponse;
+};
+
+export type TrashOperationsEmptyTrashResponse = TrashOperationsEmptyTrashResponses[keyof TrashOperationsEmptyTrashResponses];
+
+export type AddressOperationsSearchAddressesData = {
+    body?: never;
+    path?: never;
+    query: {
+        q: string;
+        limit?: number;
+    };
+    url: '/addresses/search';
+};
+
+export type AddressOperationsSearchAddressesResponses = {
+    /**
+     * The request has succeeded.
+     */
+    200: {
+        continuationToken?: String800;
+        items: Array<RemitImapAddressResponse>;
+    };
+};
+
+export type AddressOperationsSearchAddressesResponse = AddressOperationsSearchAddressesResponses[keyof AddressOperationsSearchAddressesResponses];
+
+export type AddressDetailOperationsUpdateAddressData = {
+    body: RemitImapUpdateAddressInput;
+    path: {
+        addressId: Uuid;
+    };
+    query?: never;
+    url: '/addresses/{addressId}';
+};
+
+export type AddressDetailOperationsUpdateAddressResponses = {
+    /**
+     * The request has succeeded.
+     */
+    200: RemitImapAddressResponse;
+};
+
+export type AddressDetailOperationsUpdateAddressResponse = AddressDetailOperationsUpdateAddressResponses[keyof AddressDetailOperationsUpdateAddressResponses];
+
+export type ConfigOperationsGetConfigData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/config';
+};
+
+export type ConfigOperationsGetConfigResponses = {
+    /**
+     * The request has succeeded.
+     */
+    200: RemitImapConfigDescriptionResponse;
+};
+
+export type ConfigOperationsGetConfigResponse = ConfigOperationsGetConfigResponses[keyof ConfigOperationsGetConfigResponses];
+
+export type ThreadOperationsListThreadsData = {
+    body?: never;
+    path: {
+        mailboxId: Uuid;
+    };
+    query?: {
+        continuationToken?: string;
+        order?: RemitImapSortOrder;
+    };
+    url: '/mailboxes/{mailboxId}/threads';
+};
+
+export type ThreadOperationsListThreadsResponses = {
+    /**
+     * The request has succeeded.
+     */
+    200: {
+        continuationToken?: String800;
+        items: Array<RemitImapThreadMessageResponse>;
+    };
+};
+
+export type ThreadOperationsListThreadsResponse = ThreadOperationsListThreadsResponses[keyof ThreadOperationsListThreadsResponses];
+
+export type ThreadOperationsSearchThreadsData = {
+    body?: never;
+    path: {
+        mailboxId: Uuid;
+    };
+    query?: {
+        continuationToken?: string;
+        order?: RemitImapSortOrder;
+        query?: string;
+        subject?: string;
+        from?: string;
+        unread?: boolean;
+        starred?: boolean;
+        attachments?: boolean;
+        /**
+         * Filter to messages whose From address has one of these trust levels. Off-row criterion, resolved by in-handler enrichment over the capped window.
+         */
+        senderTrust?: Array<RemitImapSenderTrust>;
+        /**
+         * Filter to messages with one of these header-derived categories. Off-row criterion, resolved by in-handler enrichment over the capped window.
+         */
+        category?: Array<RemitImapMessageCategory>;
+        /**
+         * Filter on the DKIM-alignment signal (true = DKIM mismatch). Off-row criterion; rows without an authenticity signal never match.
+         */
+        dkimMismatch?: boolean;
+        /**
+         * Include a count of matches within the server-capped window.
+         */
+        count?: boolean;
+        /**
+         * Return matching rows. Default true; set false for a count-only response.
+         */
+        results?: boolean;
+        /**
+         * Caller-set recency window, capped server-side at 500. Bounds the read.
+         */
+        limit?: number;
+    };
+    url: '/mailboxes/{mailboxId}/threads/search';
+};
+
+export type ThreadOperationsSearchThreadsResponses = {
+    /**
+     * The request has succeeded.
+     */
+    200: RemitImapThreadSearchResponse;
+};
+
+export type ThreadOperationsSearchThreadsResponse = ThreadOperationsSearchThreadsResponses[keyof ThreadOperationsSearchThreadsResponses];
+
+export type MeOperationsDeleteMeData = {
+    body: RemitImapDeleteMeInput;
+    path?: never;
+    query?: never;
+    url: '/me';
+};
+
+export type MeOperationsDeleteMeErrors = {
+    /**
+     * Validation error response
+     */
+    400: ApiError;
+};
+
+export type MeOperationsDeleteMeError = MeOperationsDeleteMeErrors[keyof MeOperationsDeleteMeErrors];
+
+export type MeOperationsDeleteMeResponses = {
+    /**
+     * Response for DELETE /me (account erasure request)
+     */
+    202: RemitImapDeleteAccountConfigResponse;
+};
+
+export type MeOperationsDeleteMeResponse = MeOperationsDeleteMeResponses[keyof MeOperationsDeleteMeResponses];
+
+export type MeOperationsCreateExportData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/me/export';
+};
+
+export type MeOperationsCreateExportResponses = {
+    /**
+     * Response body for POST /me/export
+     */
+    202: RemitImapCreateExportResponse;
+};
+
+export type MeOperationsCreateExportResponse = MeOperationsCreateExportResponses[keyof MeOperationsCreateExportResponses];
+
+export type MeOperationsGetExportData = {
+    body?: never;
+    path: {
+        exportId: string;
+    };
+    query?: never;
+    url: '/me/export/{exportId}';
+};
+
+export type MeOperationsGetExportResponses = {
+    /**
+     * The request has succeeded.
+     */
+    200: RemitImapAccountExportRequestResponse;
+};
+
+export type MeOperationsGetExportResponse = MeOperationsGetExportResponses[keyof MeOperationsGetExportResponses];
+
+export type MeOperationsListVipSuggestionsData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/me/vip-suggestions';
+};
+
+export type MeOperationsListVipSuggestionsResponses = {
+    /**
+     * The request has succeeded.
+     */
+    200: RemitImapVipSuggestionsResponse;
+};
+
+export type MeOperationsListVipSuggestionsResponse = MeOperationsListVipSuggestionsResponses[keyof MeOperationsListVipSuggestionsResponses];
+
+export type MessageBulkOperationsCopyMessagesData = {
+    body: RemitImapCopyMessagesInput;
+    path?: never;
+    query?: never;
+    url: '/messages/copy';
+};
+
+export type MessageBulkOperationsCopyMessagesResponses = {
+    /**
+     * The request has succeeded.
+     */
+    200: RemitImapMessageBulkOperationResult;
+};
+
+export type MessageBulkOperationsCopyMessagesResponse = MessageBulkOperationsCopyMessagesResponses[keyof MessageBulkOperationsCopyMessagesResponses];
+
+export type MessageBulkOperationsDeleteMessagesData = {
+    body: RemitImapDeleteMessagesInput;
+    path?: never;
+    query?: never;
+    url: '/messages/delete';
+};
+
+export type MessageBulkOperationsDeleteMessagesResponses = {
+    /**
+     * The request has succeeded.
+     */
+    200: RemitImapMessageBulkOperationResult;
+};
+
+export type MessageBulkOperationsDeleteMessagesResponse = MessageBulkOperationsDeleteMessagesResponses[keyof MessageBulkOperationsDeleteMessagesResponses];
+
+export type MessageBulkOperationsUpdateFlagsData = {
+    body: RemitImapBulkUpdateFlagsInput;
+    path?: never;
+    query?: never;
+    url: '/messages/flags';
+};
+
+export type MessageBulkOperationsUpdateFlagsResponses = {
+    /**
+     * The request has succeeded.
+     */
+    200: RemitImapMessageBulkOperationResult;
+};
+
+export type MessageBulkOperationsUpdateFlagsResponse = MessageBulkOperationsUpdateFlagsResponses[keyof MessageBulkOperationsUpdateFlagsResponses];
+
+export type MessageBulkOperationsMoveMessagesData = {
+    body: RemitImapMoveMessagesInput;
+    path?: never;
+    query?: never;
+    url: '/messages/move';
+};
+
+export type MessageBulkOperationsMoveMessagesResponses = {
+    /**
+     * The request has succeeded.
+     */
+    200: RemitImapMessageBulkOperationResult;
+};
+
+export type MessageBulkOperationsMoveMessagesResponse = MessageBulkOperationsMoveMessagesResponses[keyof MessageBulkOperationsMoveMessagesResponses];
+
+export type MessageOperationsDescribeMessageData = {
+    body?: never;
+    path: {
+        messageId: Uuid;
+    };
+    query?: never;
+    url: '/messages/{messageId}';
+};
+
+export type MessageOperationsDescribeMessageResponses = {
+    /**
+     * The request has succeeded.
+     */
+    200: RemitImapDescribeMessageResponse;
+};
+
+export type MessageOperationsDescribeMessageResponse = MessageOperationsDescribeMessageResponses[keyof MessageOperationsDescribeMessageResponses];
+
+export type MessageOperationsUpdateMessageFlagsData = {
+    body: RemitImapUpdateFlagsInput;
+    path: {
+        messageId: Uuid;
+    };
+    query?: never;
+    url: '/messages/{messageId}/flags';
+};
+
+export type MessageOperationsUpdateMessageFlagsResponses = {
+    /**
+     * The request has succeeded.
+     */
+    200: {
+        messageId: Uuid;
+        isRead: boolean;
+        isStarred: boolean;
+    };
+};
+
+export type MessageOperationsUpdateMessageFlagsResponse = MessageOperationsUpdateMessageFlagsResponses[keyof MessageOperationsUpdateMessageFlagsResponses];
+
+export type MessageOperationsGetRawMessageData = {
+    body?: never;
+    path: {
+        messageId: Uuid;
+    };
+    query?: never;
+    url: '/messages/{messageId}/raw';
+};
+
+export type MessageOperationsGetRawMessageResponses = {
+    /**
+     * The request has succeeded.
+     */
+    200: RemitImapRawMessageResponse;
+};
+
+export type MessageOperationsGetRawMessageResponse = MessageOperationsGetRawMessageResponses[keyof MessageOperationsGetRawMessageResponses];
+
+export type OutboxOperationsListOutboxMessagesData = {
+    body?: never;
+    path?: never;
+    query?: {
+        continuationToken?: string;
+    };
+    url: '/outbox';
+};
+
+export type OutboxOperationsListOutboxMessagesResponses = {
+    /**
+     * The request has succeeded.
+     */
+    200: {
+        continuationToken?: String800;
+        items: Array<RemitImapOutboxMessageResponse>;
+    };
+};
+
+export type OutboxOperationsListOutboxMessagesResponse = OutboxOperationsListOutboxMessagesResponses[keyof OutboxOperationsListOutboxMessagesResponses];
+
+export type OutboxOperationsCreateOutboxMessageData = {
+    body: RemitImapCreateOutboxMessageInput;
+    path?: never;
+    query?: never;
+    url: '/outbox';
+};
+
+export type OutboxOperationsCreateOutboxMessageResponses = {
+    /**
+     * The request has succeeded.
+     */
+    200: RemitImapOutboxMessageResponse;
+};
+
+export type OutboxOperationsCreateOutboxMessageResponse = OutboxOperationsCreateOutboxMessageResponses[keyof OutboxOperationsCreateOutboxMessageResponses];
+
+export type OutboxDetailOperationsDeleteOutboxMessageData = {
+    body?: never;
+    path: {
+        outboxMessageId: Uuid;
+    };
+    query?: never;
+    url: '/outbox/{outboxMessageId}';
+};
+
+export type OutboxDetailOperationsDeleteOutboxMessageResponses = {
+    /**
+     * There is no content to send for this request, but the headers may be useful.
+     */
+    204: void;
+};
+
+export type OutboxDetailOperationsDeleteOutboxMessageResponse = OutboxDetailOperationsDeleteOutboxMessageResponses[keyof OutboxDetailOperationsDeleteOutboxMessageResponses];
+
+export type OutboxDetailOperationsGetOutboxMessageData = {
+    body?: never;
+    path: {
+        outboxMessageId: Uuid;
+    };
+    query?: never;
+    url: '/outbox/{outboxMessageId}';
+};
+
+export type OutboxDetailOperationsGetOutboxMessageResponses = {
+    /**
+     * The request has succeeded.
+     */
+    200: RemitImapOutboxMessageResponse;
+};
+
+export type OutboxDetailOperationsGetOutboxMessageResponse = OutboxDetailOperationsGetOutboxMessageResponses[keyof OutboxDetailOperationsGetOutboxMessageResponses];
+
+export type OutboxDetailOperationsUpdateOutboxMessageData = {
+    body: RemitImapUpdateOutboxMessageInput;
+    path: {
+        outboxMessageId: Uuid;
+    };
+    query?: never;
+    url: '/outbox/{outboxMessageId}';
+};
+
+export type OutboxDetailOperationsUpdateOutboxMessageResponses = {
+    /**
+     * The request has succeeded.
+     */
+    200: RemitImapOutboxMessageResponse;
+};
+
+export type OutboxDetailOperationsUpdateOutboxMessageResponse = OutboxDetailOperationsUpdateOutboxMessageResponses[keyof OutboxDetailOperationsUpdateOutboxMessageResponses];
+
+export type OutboxDetailOperationsSendOutboxMessageData = {
+    body?: never;
+    path: {
+        outboxMessageId: Uuid;
+    };
+    query?: never;
+    url: '/outbox/{outboxMessageId}/send';
+};
+
+export type OutboxDetailOperationsSendOutboxMessageResponses = {
+    /**
+     * The request has succeeded.
+     */
+    200: RemitImapOutboxMessageResponse;
+};
+
+export type OutboxDetailOperationsSendOutboxMessageResponse = OutboxDetailOperationsSendOutboxMessageResponses[keyof OutboxDetailOperationsSendOutboxMessageResponses];
+
+export type SemanticSearchOperationsSemanticSearchData = {
+    body?: never;
+    path?: never;
+    query: {
+        /**
+         * Free-form natural-language query
+         */
+        query: string;
+        /**
+         * Restrict results to a single mailbox
+         */
+        mailboxId?: Uuid;
+        /**
+         * Lower bound on sentDate (epoch seconds, inclusive)
+         */
+        sentDateFrom?: number;
+        /**
+         * Upper bound on sentDate (epoch seconds, inclusive)
+         */
+        sentDateTo?: number;
+        /**
+         * Restrict to messages with or without attachments
+         */
+        hasAttachment?: boolean;
+        /**
+         * Restrict to starred or unstarred messages
+         */
+        hasStars?: boolean;
+        /**
+         * Restrict to read or unread messages
+         */
+        isRead?: boolean;
+        /**
+         * Restrict results to a single header-derived category
+         */
+        category?: RemitImapMessageCategory;
+        /**
+         * Maximum number of results to return
+         */
+        limit?: number;
+    };
+    url: '/search/semantic';
+};
+
+export type SemanticSearchOperationsSemanticSearchResponses = {
+    /**
+     * The request has succeeded.
+     */
+    200: {
+        items: Array<RemitImapSemanticSearchResult>;
+    };
+};
+
+export type SemanticSearchOperationsSemanticSearchResponse = SemanticSearchOperationsSemanticSearchResponses[keyof SemanticSearchOperationsSemanticSearchResponses];
+
+export type UnifiedThreadOperationsListAllThreadsData = {
+    body?: never;
+    path?: never;
+    query?: {
+        continuationToken?: string;
+        order?: RemitImapSortOrder;
+        limit?: number;
+    };
+    url: '/threads';
+};
+
+export type UnifiedThreadOperationsListAllThreadsResponses = {
+    /**
+     * The request has succeeded.
+     */
+    200: {
+        continuationToken?: String800;
+        items: Array<RemitImapThreadMessageResponse>;
+    };
+};
+
+export type UnifiedThreadOperationsListAllThreadsResponse = UnifiedThreadOperationsListAllThreadsResponses[keyof UnifiedThreadOperationsListAllThreadsResponses];
+
+export type ThreadDetailOperationsListThreadMessagesData = {
+    body?: never;
+    path: {
+        threadId: Uuid;
+    };
+    query?: {
+        order?: RemitImapSortOrder;
+        /**
+         * Filter messages to only those in this mailbox (useful for deduplication)
+         */
+        mailboxId?: Uuid;
+    };
+    url: '/threads/{threadId}/messages';
+};
+
+export type ThreadDetailOperationsListThreadMessagesResponses = {
+    /**
+     * The request has succeeded.
+     */
+    200: {
+        continuationToken?: String800;
+        items: Array<RemitImapThreadMessageResponse>;
+    };
+};
+
+export type ThreadDetailOperationsListThreadMessagesResponse = ThreadDetailOperationsListThreadMessagesResponses[keyof ThreadDetailOperationsListThreadMessagesResponses];