@remit/api-openapi-types 0.0.6 → 0.0.8

package/package.json

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

package/types.d.ts

@@ -13,6 +13,31 @@ declare namespace Components {
      * Lifecycle state of an account export request
      */
     export type AccountExportState = "Pending" | "Processing" | "Ready" | "Failed";
+    /**
+     * 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 CanonicalMailboxRole = "Inbox" | "Drafts" | "Sent" | "Archive" | "Junk" | "Trash" | "All" | "Flagged";
+    /**
+     * The pipeline step that refused a quarantined message.
+
+One member. No catch site on the sync path can currently tell a parse failure
+from an infrastructure failure: the per-message frame in `body-sync.ts` wraps
+the S3 body write, the parsed-body cache write, the body-part upserts, the
+placement move and the label and counter writes alongside the `simpleParser`
+call, and filters only connection drops out of it. A stage is added when a
+try block is narrowed far enough to attribute it, never ahead of that — an
+enum member that reached stored rows cannot be walked back.
+     */
+    export type QuarantineFailureStage = "BodyParse";
+    /**
+     * The specific defect within a stage.
+
+Closed rather than free text: this is the one diagnostic that is interpolated
+into the title of an issue filed under the user's own GitHub account, so its
+publishability has to be a property of the type instead of a claim about the
+writer. Grows with the same narrowing that grows QuarantineFailureStage.
+     */
+    export type QuarantineFailureCode = "UnterminatedMultipartBoundary" | "UnknownCharset" | "TruncatedBody";
     /**
      * Lifecycle state of an account configuration
      */
@@ -29,10 +54,6 @@ declare namespace Components {
      * Phase of the initial account sync lifecycle
      */
     export type SyncPhase = "idle" | "discovering_mailboxes" | "syncing_inbox" | "syncing_others" | "complete" | "error";
-    /**
-     * 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 CanonicalMailboxRole = "Inbox" | "Drafts" | "Sent" | "Archive" | "Junk" | "Trash" | "All" | "Flagged";
     /**
      * IMAP namespace types per RFC 9051 Section 6.3.10
      */
@@ -182,8 +203,10 @@ current enum emitter anyway, so the wire contract uses the bare form.
      */
     export type MessageFlagPushState = "pending" | "queued" | "processing" | "processed";
     export type UUID = string;
-    export type String800 = string;
     export type String512 = string;
+    export type String140 = string;
+    export type String64 = string;
+    export type String800 = string;
     export type String32 = string;
     export type String256 = string;
     /**
@@ -201,8 +224,6 @@ a compile-time error rather than a value that silently sorts incorrectly.
     export type SemanticVersion = string;
     export type String2048 = string;
     export type String200 = string;
-    export type String140 = string;
-    export type String64 = string;
     export interface CognitoAuthorizer {
       /**
        * API key authentication
@@ -452,6 +473,238 @@ a compile-time error rather than a value that silently sorts incorrectly.
        */
       errorMessage?: string;
     }
+    /**
+     * Everything quarantined for the current user, newest first. The list is small by design — a mailbox with a growing quarantine list is a bug being reported, not a page to paginate.
+     */
+    export interface QuarantineListResponse {
+      /**
+       * Quarantined messages, newest first.
+       */
+      entries: QuarantineResponse[];
+    }
+    /**
+     * A message the sync path could not apply, set aside so the mailbox cursor can
+advance past it (issue #72).
+
+Quarantine is a record, not a flag: the failing message was never written, so
+there is no row to mark. The record carries what was quarantined, why, and
+the diagnostics a bug report needs — it is the artifact, not a side effect of
+one.
+
+Two stored fields are shown on screen and never travel in a report:
+`mailboxPath` (folder names are the user's own words) and `failureMessage`
+(parser errors quote the input that broke them, and redacting arbitrary
+parser output is not solvable). Nothing else here is message content —
+no body, subject, addresses, attachment names, or Message-ID in the clear.
+
+The boundary this entity must not cross: a malformed message is
+quarantinable, an S3, queue or database failure is not. Writing an
+infrastructure failure here would advance the cursor past mail that is fine
+and tell the user it was unreadable.
+     */
+    export interface Quarantine {
+      /**
+       * Deterministic v5 identity derived from accountId, mailboxId, uidValidity and uid. Idempotent by construction: the same failing message keys the same row on every retry, so nothing has to check for an existing entry before writing one.
+       */
+      quarantineId: UUID;
+      /**
+       * Owning account configuration — the user. Scopes the settings list and the read endpoint.
+       */
+      accountConfigId: UUID;
+      /**
+       * Mail account the message arrived on. Part of the quarantineId derivation.
+       */
+      accountId: UUID;
+      /**
+       * Mailbox the message arrived in. Part of the quarantineId derivation.
+       */
+      mailboxId: UUID;
+      /**
+       * UIDVALIDITY of the mailbox when the message was set aside. A uid means nothing without it — only uidValidity + uid names a message forever (RFC 9051 2.3.1.1), and a mailbox keeps its mailboxId across a bump, so leaving this out would let a stale entry claim the identity of a later, unrelated message and suppress it from a sync round.
+       */
+      uidValidity: number;
+      /**
+       * The IMAP uid that was never written. Part of the quarantineId derivation.
+       */
+      uid: number;
+      /**
+       * Canonical role of the folder the message arrived in — travels in the report. Absent when the user has appointed no role to that folder, which is the normal state for a plain folder. A sentinel would mean a new member on the shared canonical-role enum, which FolderAppointment would then have to mean something by.
+       */
+      mailboxRole?: CanonicalMailboxRole;
+      /**
+       * The user's own folder name. Shown on screen, withheld from the report.
+       */
+      mailboxPath: String512;
+      /**
+       * Epoch millis the message was set aside.
+       */
+      quarantinedAt: number;
+      /**
+       * Rounds tried before the message was set aside.
+       */
+      attempts: number;
+      /**
+       * Pipeline step that refused the message.
+       */
+      failureStage: QuarantineFailureStage;
+      /**
+       * The specific defect. Closed vocabulary, because this is what a filed issue quotes.
+       */
+      failureCode: QuarantineFailureCode;
+      /**
+       * Parser error text. Shown on screen, never in the report.
+       */
+      failureMessage: String512;
+      /**
+       * Dot-numbered part path the failure is attributable to, off ROOT_PART_PATH. Absent when the failure belongs to no single node — every whole-body parse failure today.
+       */
+      failurePartPath?: String140;
+      /**
+       * Build of the imap-worker that failed to read the message. Named for the worker, not the app: the record is written by the sync worker, and stamping the client build on a backend parse failure points a maintainer at the wrong commit.
+       */
+      workerVersion: String64;
+      /**
+       * Top-level Content-Type, `type/subtype` only. Sender-controlled text — escape it wherever it is rendered. Absent together with the other BODYSTRUCTURE-derived fields when the message failed before its structure was read.
+       */
+      contentType?: String140;
+      /**
+       * Content-Transfer-Encoding as declared. Sender-controlled text. Absent when there was no BODYSTRUCTURE to read it from.
+       */
+      transferEncoding?: String64;
+      /**
+       * Declared charset. Sender-controlled text. Absent is meaningful: an undeclared charset is a cause in its own right, distinct from a charset nobody recognises.
+       */
+      charset?: String64;
+      /**
+       * RFC822.SIZE. Separates "too large" from "malformed". Absent when the FETCH that failed carried no size.
+       */
+      sizeBytes?: number;
+      /**
+       * The MIME tree, structure only, as a pre-order walk. The one field here that cannot be a column, because it is a tree; every other message-shape field is flat and stays typed. Empty when the message failed before its BODYSTRUCTURE was read.
+       */
+      structure: QuarantineMimeNode[];
+      /**
+       * SHA-256 of the Message-ID, `sha256:` prefixed. Pinned to one algorithm: correlating two reports of the same message is the whole point of the field, and two builds hashing differently make it useless. Absent when the message declared no Message-ID — a hash of the empty string would make every such message correlate with every other, which is worse than no value at all.
+       */
+      messageIdHash?: String140;
+      createdAt: number;
+      updatedAt: number;
+    }
+    /**
+     * One node of a quarantined message's MIME tree, in a pre-order walk.
+
+The tree is carried flat with an explicit `depth` rather than as nested
+children: a self-referential model is not expressible here (the entity
+emitter recurses forever on one), and the tree is only ever rendered as an
+indented list, which a pre-order walk reproduces exactly. Nothing caps the
+walk — it is as long as the message has parts.
+
+`contentType` is `type/subtype` only. BODYSTRUCTURE hands the type and its
+parameters over separately, so a node is built from `type`/`subtype` and
+never from a raw content-type line — parameters carry `name=` and
+`filename=`, which name the user's attachments.
+     */
+    export interface QuarantineMimeNode {
+      /**
+       * Nesting level, 0 for the root part.
+       */
+      depth: number;
+      /**
+       * Media type of this node, `type/subtype`, parameters stripped.
+       */
+      contentType: String140;
+    }
+    /**
+     * One quarantined message as the settings surface sees it.
+     */
+    export interface QuarantineResponse {
+      /**
+       * Deterministic v5 identity derived from accountId, mailboxId, uidValidity and uid. Idempotent by construction: the same failing message keys the same row on every retry, so nothing has to check for an existing entry before writing one.
+       */
+      quarantineId: UUID;
+      /**
+       * Owning account configuration — the user. Scopes the settings list and the read endpoint.
+       */
+      accountConfigId: UUID;
+      /**
+       * Mail account the message arrived on. Part of the quarantineId derivation.
+       */
+      accountId: UUID;
+      /**
+       * Mailbox the message arrived in. Part of the quarantineId derivation.
+       */
+      mailboxId: UUID;
+      /**
+       * UIDVALIDITY of the mailbox when the message was set aside. A uid means nothing without it — only uidValidity + uid names a message forever (RFC 9051 2.3.1.1), and a mailbox keeps its mailboxId across a bump, so leaving this out would let a stale entry claim the identity of a later, unrelated message and suppress it from a sync round.
+       */
+      uidValidity: number;
+      /**
+       * The IMAP uid that was never written. Part of the quarantineId derivation.
+       */
+      uid: number;
+      /**
+       * Canonical role of the folder the message arrived in — travels in the report. Absent when the user has appointed no role to that folder, which is the normal state for a plain folder. A sentinel would mean a new member on the shared canonical-role enum, which FolderAppointment would then have to mean something by.
+       */
+      mailboxRole?: CanonicalMailboxRole;
+      /**
+       * The user's own folder name. Shown on screen, withheld from the report.
+       */
+      mailboxPath: String512;
+      /**
+       * Epoch millis the message was set aside.
+       */
+      quarantinedAt: number;
+      /**
+       * Rounds tried before the message was set aside.
+       */
+      attempts: number;
+      /**
+       * Pipeline step that refused the message.
+       */
+      failureStage: QuarantineFailureStage;
+      /**
+       * The specific defect. Closed vocabulary, because this is what a filed issue quotes.
+       */
+      failureCode: QuarantineFailureCode;
+      /**
+       * Parser error text. Shown on screen, never in the report.
+       */
+      failureMessage: String512;
+      /**
+       * Dot-numbered part path the failure is attributable to, off ROOT_PART_PATH. Absent when the failure belongs to no single node — every whole-body parse failure today.
+       */
+      failurePartPath?: String140;
+      /**
+       * Build of the imap-worker that failed to read the message. Named for the worker, not the app: the record is written by the sync worker, and stamping the client build on a backend parse failure points a maintainer at the wrong commit.
+       */
+      workerVersion: String64;
+      /**
+       * Top-level Content-Type, `type/subtype` only. Sender-controlled text — escape it wherever it is rendered. Absent together with the other BODYSTRUCTURE-derived fields when the message failed before its structure was read.
+       */
+      contentType?: String140;
+      /**
+       * Content-Transfer-Encoding as declared. Sender-controlled text. Absent when there was no BODYSTRUCTURE to read it from.
+       */
+      transferEncoding?: String64;
+      /**
+       * Declared charset. Sender-controlled text. Absent is meaningful: an undeclared charset is a cause in its own right, distinct from a charset nobody recognises.
+       */
+      charset?: String64;
+      /**
+       * RFC822.SIZE. Separates "too large" from "malformed". Absent when the FETCH that failed carried no size.
+       */
+      sizeBytes?: number;
+      /**
+       * The MIME tree, structure only, as a pre-order walk. The one field here that cannot be a column, because it is a tree; every other message-shape field is flat and stays typed. Empty when the message failed before its BODYSTRUCTURE was read.
+       */
+      structure: QuarantineMimeNode[];
+      /**
+       * SHA-256 of the Message-ID, `sha256:` prefixed. Pinned to one algorithm: correlating two reports of the same message is the whole point of the field, and two builds hashing differently make it useless. Absent when the message declared no Message-ID — a hash of the empty string would make every such message correlate with every other, which is worse than no value at all.
+       */
+      messageIdHash?: String140;
+      createdAt: number;
+      updatedAt: number;
+    }
     /**
      * Full configuration description including accounts
      */
@@ -3772,6 +4025,11 @@ declare namespace Paths {
       export type $200 = void;
     }
   }
+  namespace ListQuarantine {
+    namespace Responses {
+      export type $200 = void;
+    }
+  }
   namespace GetConfig {
     namespace Responses {
       export type $200 = void;
@@ -3994,6 +4252,7 @@ declare namespace Paths {
       order?: Components.Schemas.SortOrder;
       limit?: number;
       starred?: boolean;
+      query?: string;
     }
     namespace Responses {
       export type $200 = void;
@@ -4199,6 +4458,14 @@ export interface OperationMethods {
     data?: any,
     config?: AxiosRequestConfig
   ): OperationResponse<Paths.GetExport.Responses.$200>;
+  /**
+   * listQuarantine - List every message the sync path could not read, for the current user across all of their mail accounts (issue #72). Backs the quarantine section in settings. Unpaginated: the list is small by design, and an entry is a defect waiting to be reported rather than a page of mail.
+   */
+  'listQuarantine'(
+    parameters?: Parameters<UnknownParamsObject> | null,
+    data?: any,
+    config?: AxiosRequestConfig
+  ): OperationResponse<Paths.ListQuarantine.Responses.$200>;
   /**
    * getConfig - Get the current user's configuration including accounts and addresses
    */
@@ -4413,6 +4680,18 @@ Mute exclusion: muted accounts and muted mailboxes are excluded. The inbox/mute
 Pagination: pass the returned `continuationToken` to fetch the next page; keep paging until it is absent. In the default (INBOX) mode the INBOX/deleted filter is applied after the index read with a bounded read window per request, so a page may return FEWER than `limit` rows while still carrying a `continuationToken` — treat the presence of the token (not a full page) as the "more results" signal. No rows are skipped or duplicated across pages.
 
 Starred mode (`starred=true`): served by the `byStarred` LSI4 instead. A star is a marker on the mail rather than on its placement, so the INBOX scope does not apply and a starred thread in Archive is still returned. Excluded are muted and soft-deleted rows as usual, plus the folders a star never surfaces from: Junk, Trash, and Gmail's All Mail (a second copy of everything, whose rows would otherwise double every starred message). All filtering happens in the query, so a page is short only when the results are exhausted. Rows are per mailbox: the same mail filed in two folders is two rows sharing a `threadId`, and a client rendering one row per conversation collapses by `threadId` across the pages it has accumulated.
+
+Search mode (`query=<text>`): the listing widens past the INBOX scope to every non-muted mailbox of every non-muted account, and returns only rows whose subject or From address matches the text. This is the unscoped search of the daily brief: one query reaching every folder of every account. Whitespace splits the text into terms and every term must match (AND), each against subject OR From. Matching is case-insensitive substring, not tokenized full-text, so it neither stems nor ranks.
+
+Search scope: every non-muted mailbox EXCEPT Trash. The scope is defined by what it excludes, so anything a server offers that is not on that list is searched — Spam, Drafts and Gmail's virtual folders (All Mail, Starred, Important) included. Spam is deliberately in scope: the point of an unscoped search is that it reaches the folders the user did not think to look in. Combining `query` with `starred=true` searches the starred scope instead.
+
+Duplicates: a virtual folder holds a second copy of mail that also lives in a real folder, so a backend keying a row by its mailbox returns the same message several times — a starred, Important Gmail inbox message four times. The extras are dropped from the response by message identity, keeping the copy in a real folder, so one message is one row. This is done after the read rather than by barring those folders from the scope, because a message whose only stored row sits in one of them would otherwise become unfindable. De-duplication is per page: a duplicate split across a page boundary survives, the same caveat that applies to collapsing by `threadId`. A page may therefore return fewer rows than `limit` while still carrying a `continuationToken`.
+
+Search mode and pagination: `limit` is a page size over MATCHES, capped server-side at 500. A page may be shorter than `limit` for two reasons — the matches ran out, or duplicates were dropped from it — so treat the presence of a `continuationToken` as the "more results" signal rather than a full page. There is no total match count; page until the token is absent.
+
+What a row is in search mode: one per message, not one per mailbox. This differs from the starred mode above, where the same mail filed in two folders is two rows sharing a `threadId`. Collapsing by `threadId` is still a client's job if it renders one row per CONVERSATION, since distinct messages in one thread remain distinct rows here.
+
+Callers that omit `query` are unaffected: the INBOX (and starred) listings behave exactly as before.
    */
   'listAllThreads'(
     parameters?: Parameters<Paths.ListAllThreads.QueryParameters> | null,
@@ -4606,6 +4885,16 @@ export interface PathsDictionary {
       config?: AxiosRequestConfig
     ): OperationResponse<Paths.GetExport.Responses.$200>;
   };
+  ['/me/quarantine']: {
+    /**
+     * listQuarantine - List every message the sync path could not read, for the current user across all of their mail accounts (issue #72). Backs the quarantine section in settings. Unpaginated: the list is small by design, and an entry is a defect waiting to be reported rather than a page of mail.
+     */
+    'get'(
+      parameters?: Parameters<UnknownParamsObject> | null,
+      data?: any,
+      config?: AxiosRequestConfig
+    ): OperationResponse<Paths.ListQuarantine.Responses.$200>;
+  };
   ['/config']: {
     /**
      * getConfig - Get the current user's configuration including accounts and addresses
@@ -4857,6 +5146,18 @@ Mute exclusion: muted accounts and muted mailboxes are excluded. The inbox/mute
 Pagination: pass the returned `continuationToken` to fetch the next page; keep paging until it is absent. In the default (INBOX) mode the INBOX/deleted filter is applied after the index read with a bounded read window per request, so a page may return FEWER than `limit` rows while still carrying a `continuationToken` — treat the presence of the token (not a full page) as the "more results" signal. No rows are skipped or duplicated across pages.
 
 Starred mode (`starred=true`): served by the `byStarred` LSI4 instead. A star is a marker on the mail rather than on its placement, so the INBOX scope does not apply and a starred thread in Archive is still returned. Excluded are muted and soft-deleted rows as usual, plus the folders a star never surfaces from: Junk, Trash, and Gmail's All Mail (a second copy of everything, whose rows would otherwise double every starred message). All filtering happens in the query, so a page is short only when the results are exhausted. Rows are per mailbox: the same mail filed in two folders is two rows sharing a `threadId`, and a client rendering one row per conversation collapses by `threadId` across the pages it has accumulated.
+
+Search mode (`query=<text>`): the listing widens past the INBOX scope to every non-muted mailbox of every non-muted account, and returns only rows whose subject or From address matches the text. This is the unscoped search of the daily brief: one query reaching every folder of every account. Whitespace splits the text into terms and every term must match (AND), each against subject OR From. Matching is case-insensitive substring, not tokenized full-text, so it neither stems nor ranks.
+
+Search scope: every non-muted mailbox EXCEPT Trash. The scope is defined by what it excludes, so anything a server offers that is not on that list is searched — Spam, Drafts and Gmail's virtual folders (All Mail, Starred, Important) included. Spam is deliberately in scope: the point of an unscoped search is that it reaches the folders the user did not think to look in. Combining `query` with `starred=true` searches the starred scope instead.
+
+Duplicates: a virtual folder holds a second copy of mail that also lives in a real folder, so a backend keying a row by its mailbox returns the same message several times — a starred, Important Gmail inbox message four times. The extras are dropped from the response by message identity, keeping the copy in a real folder, so one message is one row. This is done after the read rather than by barring those folders from the scope, because a message whose only stored row sits in one of them would otherwise become unfindable. De-duplication is per page: a duplicate split across a page boundary survives, the same caveat that applies to collapsing by `threadId`. A page may therefore return fewer rows than `limit` while still carrying a `continuationToken`.
+
+Search mode and pagination: `limit` is a page size over MATCHES, capped server-side at 500. A page may be shorter than `limit` for two reasons — the matches ran out, or duplicates were dropped from it — so treat the presence of a `continuationToken` as the "more results" signal rather than a full page. There is no total match count; page until the token is absent.
+
+What a row is in search mode: one per message, not one per mailbox. This differs from the starred mode above, where the same mail filed in two folders is two rows sharing a `threadId`. Collapsing by `threadId` is still a client's job if it renders one row per CONVERSATION, since distinct messages in one thread remain distinct rows here.
+
+Callers that omit `query` are unaffected: the INBOX (and starred) listings behave exactly as before.
      */
     'get'(
       parameters?: Parameters<Paths.ListAllThreads.QueryParameters> | null,
@@ -5059,6 +5360,10 @@ export type VipSuggestionEntry = Components.Schemas.VipSuggestionEntry;
 export type CreateExportResponse = Components.Schemas.CreateExportResponse;
 export type AccountExportRequest = Components.Schemas.AccountExportRequest;
 export type AccountExportRequestResponse = Components.Schemas.AccountExportRequestResponse;
+export type QuarantineListResponse = Components.Schemas.QuarantineListResponse;
+export type Quarantine = Components.Schemas.Quarantine;
+export type QuarantineMimeNode = Components.Schemas.QuarantineMimeNode;
+export type QuarantineResponse = Components.Schemas.QuarantineResponse;
 export type ConfigDescriptionResponse = Components.Schemas.ConfigDescriptionResponse;
 export type AccountConfig = Components.Schemas.AccountConfig;
 export type AccountConfigResponse = Components.Schemas.AccountConfigResponse;
@@ -5161,11 +5466,13 @@ export type MicrosoftOAuthStartRequest = Components.Schemas.MicrosoftOAuthStartR
 export type MicrosoftOAuthStartResponse = Components.Schemas.MicrosoftOAuthStartResponse;
 export type IndexType = Components.Schemas.IndexType;
 export type AccountExportState = Components.Schemas.AccountExportState;
+export type CanonicalMailboxRole = Components.Schemas.CanonicalMailboxRole;
+export type QuarantineFailureStage = Components.Schemas.QuarantineFailureStage;
+export type QuarantineFailureCode = Components.Schemas.QuarantineFailureCode;
 export type AccountConfigState = Components.Schemas.AccountConfigState;
 export type AccountAuthType = Components.Schemas.AccountAuthType;
 export type ConnectionState = Components.Schemas.ConnectionState;
 export type SyncPhase = Components.Schemas.SyncPhase;
-export type CanonicalMailboxRole = Components.Schemas.CanonicalMailboxRole;
 export type NamespaceType = Components.Schemas.NamespaceType;
 export type MailboxSyncStatus = Components.Schemas.MailboxSyncStatus;
 export type MailboxCursorState = Components.Schemas.MailboxCursorState;
@@ -5203,12 +5510,12 @@ export type MessagePlacementMoveState = Components.Schemas.MessagePlacementMoveS
 export type FlagPushOperation = Components.Schemas.FlagPushOperation;
 export type MessageFlagPushState = Components.Schemas.MessageFlagPushState;
 export type UUID = Components.Schemas.UUID;
-export type String800 = Components.Schemas.String800;
 export type String512 = Components.Schemas.String512;
+export type String140 = Components.Schemas.String140;
+export type String64 = Components.Schemas.String64;
+export type String800 = Components.Schemas.String800;
 export type String32 = Components.Schemas.String32;
 export type String256 = Components.Schemas.String256;
 export type SemanticVersion = Components.Schemas.SemanticVersion;
 export type String2048 = Components.Schemas.String2048;
 export type String200 = Components.Schemas.String200;
-export type String140 = Components.Schemas.String140;
-export type String64 = Components.Schemas.String64;