@remit/api-openapi-types 0.0.44 → 0.0.45

package/package.json

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

package/types.d.ts

@@ -2434,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.
 
@@ -5732,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
@@ -6107,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;
@@ -6810,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
@@ -7554,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
@@ -8130,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;
@@ -8231,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;