@remit/api-openapi-types 0.0.43 → 0.0.45

package/package.json

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

package/types.d.ts

@@ -931,6 +931,10 @@ never from a raw content-type line — parameters carry `name=` and
        * Absent unless a configuration import is still waiting on folders IMAP has not produced yet (#1021). Nothing polls a separate route for it.
        */
       pendingImport?: PendingConfigImport;
+      /**
+       * Whether this instance stores a vector for every message — SEARCH_EMBEDDING_PROVIDER is anything but `off`. False is a setting an operator turns on (`remit semantic on`), not a failure: the Organize semantic widen and semantic (anchor) filters read stored vectors and have none, so they render an off state rather than an empty result. It rides the config read because it is a property of the deployment, not of a query (#1068).
+       */
+      semanticSearchEnabled: boolean;
     }
     /**
      * Configuration container for user accounts. Groups multiple IMAP accounts under a single user.
@@ -2430,6 +2434,93 @@ mutable overlay; this is the address.
     export interface CalendarNoContent {
       statusCode: 204;
     }
+    /**
+     * Whether a calendar has a feed address, and how old it is. The token is deliberately absent — it exists in the clear once, in the answer to the write that minted it.
+     */
+    export interface CalendarFeedStateResponse {
+      /**
+       * Collection this address serves
+       */
+      calendarId: UUID;
+      /**
+       * When this calendar first got a feed address
+       */
+      createdAt: number;
+      /**
+       * When the token was last replaced. `0` means it is still the first one.
+       */
+      rotatedAt: number;
+    }
+    /**
+     * A calendar's secret subscription address, with the token in the clear.
+
+Returned by the write that mints it and nowhere else. Only the hash is
+stored, so a client that loses this value rotates the feed rather than
+reading it back — which is also what makes the read side safe to leave
+tokenless.
+     */
+    export interface CalendarFeedResponse {
+      /**
+       * Collection this address serves
+       */
+      calendarId: UUID;
+      /**
+       * The token itself, base64url over 32 random bytes. It is the whole credential: the path `/feeds/calendar/{feedToken}.ics` needs nothing else, which is what lets a client that cannot sign in subscribe.
+       */
+      feedToken: String512;
+      /**
+       * When this calendar first got a feed address
+       */
+      createdAt: number;
+      /**
+       * When the token was last replaced. `0` means it is still the first one.
+       */
+      rotatedAt: number;
+    }
+    /**
+     * A whole calendar as iCalendar text, for a client that subscribed to the
+secret address.
+
+Recurring events are the stored masters with their RRULE, not an expansion:
+a subscriber renders its own occurrences and expects to keep doing so
+indefinitely, and an expansion would silently end at whatever horizon this
+server chose.
+
+The calendar's name travels as the `X-WR-CALNAME` property inside the
+VCALENDAR, which is where Apple Calendar, Google Calendar and Thunderbird
+read it from.
+     */
+    export interface CalendarFeedIcalResponse {
+      contentType: "text/calendar; charset=utf-8";
+      /**
+       * Strong entity tag over the bytes being served. A subscriber polls often and sends it back as `If-None-Match`.
+       */
+      etag: string;
+      /**
+       * HTTP-date the collection was last written, which is stamped by every event write and every event delete. The collection's own timestamp rather than its newest event: deleting the newest event leaves every survivor older than the change, and a validator that moved backwards would tell a subscriber its stale copy is current.
+       */
+      lastModified: string;
+      icalData: string;
+    }
+    /**
+     * The subscriber already holds these bytes. Answered when `If-None-Match` carries the tag the feed would serve, or when `If-Modified-Since` is not older than the calendar's last change.
+     */
+    export interface CalendarFeedNotModified {
+      statusCode: 304;
+      etag: string;
+      /**
+       * The same validator a 200 would have carried, so a subscriber that polls by date can keep doing so
+       */
+      lastModified: string;
+    }
+    /**
+     * No feed answers to this address. Unknown, revoked and malformed tokens are one answer with one body, so a caller learns nothing about which of the three it sent.
+     */
+    export interface CalendarFeedNotFound {
+      statusCode: 404;
+      contentType: "text/plain; charset=utf-8";
+      message: string;
+    }
     /**
      * Expanded occurrences in the requested window, in start order.
 
@@ -5728,6 +5819,52 @@ occurrences from every zone but its own.
       createdAt: number;
       updatedAt: number;
     }
+    /**
+     * The secret address a calendar is subscribed to from outside (issue #1067).
+
+A subscriber never signs in: Apple Calendar, Google Calendar and Thunderbird
+poll a URL and send no credential, so the URL is the credential. Only the
+SHA-256 hash of the token is stored — the plaintext is handed out once, at the
+write that mints it, and a caller that loses it rotates rather than reads it
+back.
+
+`feedTokenId` is derived from `calendarId`, so one calendar holds one active
+token by construction: rotating rewrites the row it already has, and the
+previous address stops resolving the moment the new hash lands. A second
+active address per calendar would be a credential nobody could see to revoke.
+
+The hash is a plain digest and deliberately not a slow one. The token carries
+32 random bytes, so there is nothing to brute-force and no password-equivalent
+to stretch; a KDF here would only make every poll from every subscribed client
+expensive.
+     */
+    export interface CalendarFeedToken {
+      /**
+       * Primary identifier, derived from calendarId
+       */
+      feedTokenId: UUID;
+      /**
+       * Owning account configuration
+       */
+      accountConfigId: UUID;
+      /**
+       * Collection this address serves
+       */
+      calendarId: UUID;
+      /**
+       * SHA-256 of the token, lower-case hex. The plaintext is never stored: a leaked database gives a reader no working subscription URL.
+       */
+      tokenHash: String64;
+      /**
+       * When this calendar first got a feed address. Survives a rotation — the feed is the same feed, under a new secret.
+       */
+      createdAt: number;
+      /**
+       * When the token was last replaced. `0` means it is still the one this calendar started with.
+       */
+      rotatedAt: number;
+      updatedAt: number;
+    }
     /**
      * Junction whose existence *is* a label assignment (RFC 030). Holds only ids
 and is hydrated with `batchGet`. Keyed by a deterministic UUID v5 derived
@@ -6103,6 +6240,47 @@ declare namespace Paths {
       export type $404 = void;
     }
   }
+  namespace GetCalendarFeed {
+    export interface PathParameters {
+      calendarId: Components.Schemas.UUID;
+    }
+    namespace Responses {
+      export type $200 = void;
+      export type $404 = void;
+    }
+  }
+  namespace PutCalendarFeed {
+    export interface PathParameters {
+      calendarId: Components.Schemas.UUID;
+    }
+    namespace Responses {
+      export type $200 = void;
+      export type $404 = void;
+    }
+  }
+  namespace RevokeCalendarFeed {
+    export interface PathParameters {
+      calendarId: Components.Schemas.UUID;
+    }
+    namespace Responses {
+      export type $204 = void;
+      export type $404 = void;
+    }
+  }
+  namespace GetCalendarFeedIcal {
+    export interface PathParameters {
+      feedToken: string;
+    }
+    export interface HeaderParameters {
+      ifNoneMatch?: string;
+      ifModifiedSince?: string;
+    }
+    namespace Responses {
+      export type $200 = void;
+      export type $304 = void;
+      export type $404 = void;
+    }
+  }
   namespace ListCalendarEvents {
     export interface QueryParameters {
       from: string;
@@ -6806,6 +6984,55 @@ export interface OperationMethods {
     data?: any,
     config?: AxiosRequestConfig
   ): OperationResponse<Paths.DeleteCalendar.Responses.$204>;
+  /**
+   * getCalendarFeed - Read whether this calendar has a feed address. Absent (404) until one is
+minted. The token is not here: it is stored as a hash, so the only
+moment it exists in the clear is the answer to the write below.
+   */
+  'getCalendarFeed'(
+    parameters?: Parameters<Paths.GetCalendarFeed.PathParameters> | null,
+    data?: any,
+    config?: AxiosRequestConfig
+  ): OperationResponse<Paths.GetCalendarFeed.Responses.$200>;
+  /**
+   * putCalendarFeed - Mint the calendar's feed address, or replace the one it has, and answer
+with the token in the clear. Idempotent in address rather than in value:
+one calendar holds one token, so a second call rotates — the previous
+URL stops resolving, which is how a subscription handed to the wrong
+person is taken back.
+
+This is the only response that ever carries the plaintext. A client that
+does not keep it rotates again.
+   */
+  'putCalendarFeed'(
+    parameters?: Parameters<Paths.PutCalendarFeed.PathParameters> | null,
+    data?: any,
+    config?: AxiosRequestConfig
+  ): OperationResponse<Paths.PutCalendarFeed.Responses.$200>;
+  /**
+   * revokeCalendarFeed - Revoke the calendar's feed address. Every subscribed client starts getting 404 on its next poll. Answered 404 when the calendar has no feed, so a revoke is never reported as having taken something away that was not there.
+   */
+  'revokeCalendarFeed'(
+    parameters?: Parameters<Paths.RevokeCalendarFeed.PathParameters> | null,
+    data?: any,
+    config?: AxiosRequestConfig
+  ): OperationResponse<Paths.RevokeCalendarFeed.Responses.$204>;
+  /**
+   * getCalendarFeedIcal - Serve a calendar as iCalendar text to whoever holds its secret address
+(issue #1067).
+
+Outside the session-auth surface on purpose: Apple Calendar, Google
+Calendar, Outlook and Thunderbird subscribe to a URL and never sign in,
+so the token in the path is the credential and the only one. It is
+compared against the stored hash rather than looked up in the clear, and
+an unknown, revoked or malformed token is the same 404 with the same body
+— a subscriber learns whether it still has access, and nothing else.
+   */
+  'getCalendarFeedIcal'(
+    parameters?: Parameters<Paths.GetCalendarFeedIcal.PathParameters & Paths.GetCalendarFeedIcal.HeaderParameters> | null,
+    data?: any,
+    config?: AxiosRequestConfig
+  ): OperationResponse<Paths.GetCalendarFeedIcal.Responses.$200>;
   /**
    * listCalendarEvents - Expanded event occurrences in a window. The server does the recurrence
 expansion and the client renders instances — no RRULE is ever evaluated
@@ -7550,6 +7777,59 @@ export interface PathsDictionary {
       config?: AxiosRequestConfig
     ): OperationResponse<Paths.DeleteCalendar.Responses.$204>;
   };
+  ['/calendars/{calendarId}/feed']: {
+    /**
+     * getCalendarFeed - Read whether this calendar has a feed address. Absent (404) until one is
+minted. The token is not here: it is stored as a hash, so the only
+moment it exists in the clear is the answer to the write below.
+     */
+    'get'(
+      parameters?: Parameters<Paths.GetCalendarFeed.PathParameters> | null,
+      data?: any,
+      config?: AxiosRequestConfig
+    ): OperationResponse<Paths.GetCalendarFeed.Responses.$200>;
+    /**
+     * putCalendarFeed - Mint the calendar's feed address, or replace the one it has, and answer
+with the token in the clear. Idempotent in address rather than in value:
+one calendar holds one token, so a second call rotates — the previous
+URL stops resolving, which is how a subscription handed to the wrong
+person is taken back.
+
+This is the only response that ever carries the plaintext. A client that
+does not keep it rotates again.
+     */
+    'put'(
+      parameters?: Parameters<Paths.PutCalendarFeed.PathParameters> | null,
+      data?: any,
+      config?: AxiosRequestConfig
+    ): OperationResponse<Paths.PutCalendarFeed.Responses.$200>;
+    /**
+     * revokeCalendarFeed - Revoke the calendar's feed address. Every subscribed client starts getting 404 on its next poll. Answered 404 when the calendar has no feed, so a revoke is never reported as having taken something away that was not there.
+     */
+    'delete'(
+      parameters?: Parameters<Paths.RevokeCalendarFeed.PathParameters> | null,
+      data?: any,
+      config?: AxiosRequestConfig
+    ): OperationResponse<Paths.RevokeCalendarFeed.Responses.$204>;
+  };
+  ['/feeds/calendar/{feedToken}.ics']: {
+    /**
+     * getCalendarFeedIcal - Serve a calendar as iCalendar text to whoever holds its secret address
+(issue #1067).
+
+Outside the session-auth surface on purpose: Apple Calendar, Google
+Calendar, Outlook and Thunderbird subscribe to a URL and never sign in,
+so the token in the path is the credential and the only one. It is
+compared against the stored hash rather than looked up in the clear, and
+an unknown, revoked or malformed token is the same 404 with the same body
+— a subscriber learns whether it still has access, and nothing else.
+     */
+    'get'(
+      parameters?: Parameters<Paths.GetCalendarFeedIcal.PathParameters> | null,
+      data?: any,
+      config?: AxiosRequestConfig
+    ): OperationResponse<Paths.GetCalendarFeedIcal.Responses.$200>;
+  };
   ['/calendar-events']: {
     /**
      * listCalendarEvents - Expanded event occurrences in a window. The server does the recurrence
@@ -8126,6 +8406,11 @@ export type CalendarResponse = Components.Schemas.CalendarResponse;
 export type CreateCalendarInput = Components.Schemas.CreateCalendarInput;
 export type UpdateCalendarInput = Components.Schemas.UpdateCalendarInput;
 export type CalendarNoContent = Components.Schemas.CalendarNoContent;
+export type CalendarFeedStateResponse = Components.Schemas.CalendarFeedStateResponse;
+export type CalendarFeedResponse = Components.Schemas.CalendarFeedResponse;
+export type CalendarFeedIcalResponse = Components.Schemas.CalendarFeedIcalResponse;
+export type CalendarFeedNotModified = Components.Schemas.CalendarFeedNotModified;
+export type CalendarFeedNotFound = Components.Schemas.CalendarFeedNotFound;
 export type CalendarEventListResponse = Components.Schemas.CalendarEventListResponse;
 export type CalendarEventInstance = Components.Schemas.CalendarEventInstance;
 export type CreateCalendarEventInput = Components.Schemas.CreateCalendarEventInput;
@@ -8227,6 +8512,7 @@ export type RawMessageStorage = Components.Schemas.RawMessageStorage;
 export type BodyPartStorage = Components.Schemas.BodyPartStorage;
 export type BodyPartContent = Components.Schemas.BodyPartContent;
 export type CalendarEventIndex = Components.Schemas.CalendarEventIndex;
+export type CalendarFeedToken = Components.Schemas.CalendarFeedToken;
 export type MessageLabel = Components.Schemas.MessageLabel;
 export type FilterAnchor = Components.Schemas.FilterAnchor;
 export type MicrosoftOAuthStartRequest = Components.Schemas.MicrosoftOAuthStartRequest;