@homeflare/distilled-openbao 0.2.0

package/src/services/rotate.ts

@@ -0,0 +1,1088 @@
+// AUTO-GENERATED by scripts/generate.ts from .generated-specs (specs/spec-mirror-openbao, generated — see fetch-specs.ts). Do not edit.
+import * as S from "@distilled.cloud/core/schema";
+import * as API from "@distilled.cloud/core/api";
+import * as T from "../traits.ts";
+import {
+  OpenBaoProtocol,
+  type OpenBaoOpError,
+  type OpenBaoOpContext,
+} from "../protocol.ts";
+import * as Retry from "../retry.ts";
+
+export type { OpenBaoOpError, OpenBaoOpContext };
+
+export interface RotateAttemptCancelRequest {}
+export const RotateAttemptCancelRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}).pipe(
+    T.Http({ method: "DELETE", uri: "/sys/rotate/root/init", code: 200 }),
+  ),
+).annotate({
+  identifier: "RotateAttemptCancelRequest",
+}) as any as S.Schema<RotateAttemptCancelRequest>;
+
+export interface RotateAttemptCancelResponse {}
+export const RotateAttemptCancelResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "RotateAttemptCancelResponse",
+}) as any as S.Schema<RotateAttemptCancelResponse>;
+
+export interface RotateAttemptCancelRotateRecoveryInitRequest {}
+export const RotateAttemptCancelRotateRecoveryInitRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({}).pipe(
+      T.Http({ method: "DELETE", uri: "/sys/rotate/recovery/init", code: 200 }),
+    ),
+  ).annotate({
+    identifier: "RotateAttemptCancelRotateRecoveryInitRequest",
+  }) as any as S.Schema<RotateAttemptCancelRotateRecoveryInitRequest>;
+
+export interface RotateAttemptCancelRotateRecoveryInitResponse {}
+export const RotateAttemptCancelRotateRecoveryInitResponse =
+  /*@__PURE__*/ S.suspend(() => S.Struct({})).annotate({
+    identifier: "RotateAttemptCancelRotateRecoveryInitResponse",
+  }) as any as S.Schema<RotateAttemptCancelRotateRecoveryInitResponse>;
+
+/** Specifies an array of PGP public keys used to encrypt the output unseal keys. */
+export type RotateAttemptInitializeRequestPgpKeysList = Array<string>;
+export const RotateAttemptInitializeRequestPgpKeysList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<RotateAttemptInitializeRequestPgpKeysList>;
+
+export interface RotateAttemptInitializeRequest {
+  /** Specifies if using PGP-encrypted keys, whether OpenBao should also store a plaintext backup of the said keys. */
+  backup?: boolean;
+  /** Specifies an array of PGP public keys used to encrypt the output unseal keys. */
+  pgp_keys?: RotateAttemptInitializeRequestPgpKeysList;
+  /** Enables verification which after successful authorization with the current unseal keys, ensures the new unseal keys are returned but the root key is not actually rotated. */
+  require_verification?: boolean;
+  /** Specifies the number of shares to split the root key into. */
+  secret_shares: number;
+  /** Specifies the number of shares required to reconstruct the root key. */
+  secret_threshold: number;
+}
+export const RotateAttemptInitializeRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    backup: S.optional(S.Boolean),
+    pgp_keys: S.optional(RotateAttemptInitializeRequestPgpKeysList),
+    require_verification: S.optional(S.Boolean),
+    secret_shares: S.Number,
+    secret_threshold: S.Number,
+  }).pipe(T.Http({ method: "POST", uri: "/sys/rotate/root/init", code: 200 })),
+).annotate({
+  identifier: "RotateAttemptInitializeRequest",
+}) as any as S.Schema<RotateAttemptInitializeRequest>;
+
+export type RotateAttemptInitializeResponseKeysList = Array<string>;
+export const RotateAttemptInitializeResponseKeysList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<RotateAttemptInitializeResponseKeysList>;
+
+export type RotateAttemptInitializeResponseKeysBase64List = Array<string>;
+export const RotateAttemptInitializeResponseKeysBase64List =
+  /*@__PURE__*/ S.Array(
+    S.String,
+  ) as any as S.Schema<RotateAttemptInitializeResponseKeysBase64List>;
+
+export type RotateAttemptInitializeResponsePgpFingerprintsList = Array<string>;
+export const RotateAttemptInitializeResponsePgpFingerprintsList =
+  /*@__PURE__*/ S.Array(
+    S.String,
+  ) as any as S.Schema<RotateAttemptInitializeResponsePgpFingerprintsList>;
+
+export interface RotateAttemptInitializeResponse {
+  backup?: boolean;
+  complete?: boolean;
+  keys?: RotateAttemptInitializeResponseKeysList;
+  keys_base64?: RotateAttemptInitializeResponseKeysBase64List;
+  n?: number;
+  nonce?: string;
+  pgp_fingerprints?: RotateAttemptInitializeResponsePgpFingerprintsList;
+  progress?: number;
+  required?: number;
+  started?: boolean;
+  t?: number;
+  verification_nonce?: string;
+  verification_required?: boolean;
+}
+export const RotateAttemptInitializeResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    backup: S.optional(S.Boolean),
+    complete: S.optional(S.Boolean),
+    keys: S.optional(RotateAttemptInitializeResponseKeysList),
+    keys_base64: S.optional(RotateAttemptInitializeResponseKeysBase64List),
+    n: S.optional(S.Number),
+    nonce: S.optional(S.String),
+    pgp_fingerprints: S.optional(
+      RotateAttemptInitializeResponsePgpFingerprintsList,
+    ),
+    progress: S.optional(S.Number),
+    required: S.optional(S.Number),
+    started: S.optional(S.Boolean),
+    t: S.optional(S.Number),
+    verification_nonce: S.optional(S.String),
+    verification_required: S.optional(S.Boolean),
+  }),
+).annotate({
+  identifier: "RotateAttemptInitializeResponse",
+}) as any as S.Schema<RotateAttemptInitializeResponse>;
+
+/** Specifies an array of PGP public keys used to encrypt the output unseal keys. */
+export type RotateAttemptInitializeRotateRecoveryInitRequestPgpKeysList =
+  Array<string>;
+export const RotateAttemptInitializeRotateRecoveryInitRequestPgpKeysList =
+  /*@__PURE__*/ S.Array(
+    S.String,
+  ) as any as S.Schema<RotateAttemptInitializeRotateRecoveryInitRequestPgpKeysList>;
+
+export interface RotateAttemptInitializeRotateRecoveryInitRequest {
+  /** Specifies if using PGP-encrypted keys, whether OpenBao should also store a plaintext backup of the said keys. */
+  backup?: boolean;
+  /** Specifies an array of PGP public keys used to encrypt the output unseal keys. */
+  pgp_keys?: RotateAttemptInitializeRotateRecoveryInitRequestPgpKeysList;
+  /** Enables verification which after successful authorization with the current unseal keys, ensures the new unseal keys are returned but the root key is not actually rotated. */
+  require_verification?: boolean;
+  /** Specifies the number of shares to split the root key into. */
+  secret_shares: number;
+  /** Specifies the number of shares required to reconstruct the root key. */
+  secret_threshold: number;
+}
+export const RotateAttemptInitializeRotateRecoveryInitRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      backup: S.optional(S.Boolean),
+      pgp_keys: S.optional(
+        RotateAttemptInitializeRotateRecoveryInitRequestPgpKeysList,
+      ),
+      require_verification: S.optional(S.Boolean),
+      secret_shares: S.Number,
+      secret_threshold: S.Number,
+    }).pipe(
+      T.Http({ method: "POST", uri: "/sys/rotate/recovery/init", code: 200 }),
+    ),
+  ).annotate({
+    identifier: "RotateAttemptInitializeRotateRecoveryInitRequest",
+  }) as any as S.Schema<RotateAttemptInitializeRotateRecoveryInitRequest>;
+
+export type RotateAttemptInitializeRotateRecoveryInitResponseKeysList =
+  Array<string>;
+export const RotateAttemptInitializeRotateRecoveryInitResponseKeysList =
+  /*@__PURE__*/ S.Array(
+    S.String,
+  ) as any as S.Schema<RotateAttemptInitializeRotateRecoveryInitResponseKeysList>;
+
+export type RotateAttemptInitializeRotateRecoveryInitResponseKeysBase64List =
+  Array<string>;
+export const RotateAttemptInitializeRotateRecoveryInitResponseKeysBase64List =
+  /*@__PURE__*/ S.Array(
+    S.String,
+  ) as any as S.Schema<RotateAttemptInitializeRotateRecoveryInitResponseKeysBase64List>;
+
+export type RotateAttemptInitializeRotateRecoveryInitResponsePgpFingerprintsList =
+  Array<string>;
+export const RotateAttemptInitializeRotateRecoveryInitResponsePgpFingerprintsList =
+  /*@__PURE__*/ S.Array(
+    S.String,
+  ) as any as S.Schema<RotateAttemptInitializeRotateRecoveryInitResponsePgpFingerprintsList>;
+
+export interface RotateAttemptInitializeRotateRecoveryInitResponse {
+  backup?: boolean;
+  complete?: boolean;
+  keys?: RotateAttemptInitializeRotateRecoveryInitResponseKeysList;
+  keys_base64?: RotateAttemptInitializeRotateRecoveryInitResponseKeysBase64List;
+  n?: number;
+  nonce?: string;
+  pgp_fingerprints?: RotateAttemptInitializeRotateRecoveryInitResponsePgpFingerprintsList;
+  progress?: number;
+  required?: number;
+  started?: boolean;
+  t?: number;
+  verification_nonce?: string;
+  verification_required?: boolean;
+}
+export const RotateAttemptInitializeRotateRecoveryInitResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      backup: S.optional(S.Boolean),
+      complete: S.optional(S.Boolean),
+      keys: S.optional(
+        RotateAttemptInitializeRotateRecoveryInitResponseKeysList,
+      ),
+      keys_base64: S.optional(
+        RotateAttemptInitializeRotateRecoveryInitResponseKeysBase64List,
+      ),
+      n: S.optional(S.Number),
+      nonce: S.optional(S.String),
+      pgp_fingerprints: S.optional(
+        RotateAttemptInitializeRotateRecoveryInitResponsePgpFingerprintsList,
+      ),
+      progress: S.optional(S.Number),
+      required: S.optional(S.Number),
+      started: S.optional(S.Boolean),
+      t: S.optional(S.Number),
+      verification_nonce: S.optional(S.String),
+      verification_required: S.optional(S.Boolean),
+    }),
+  ).annotate({
+    identifier: "RotateAttemptInitializeRotateRecoveryInitResponse",
+  }) as any as S.Schema<RotateAttemptInitializeRotateRecoveryInitResponse>;
+
+export interface RotateAttemptReadProgressRequest {}
+export const RotateAttemptReadProgressRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}).pipe(
+    T.Http({ method: "GET", uri: "/sys/rotate/root/init", code: 200 }),
+  ),
+).annotate({
+  identifier: "RotateAttemptReadProgressRequest",
+}) as any as S.Schema<RotateAttemptReadProgressRequest>;
+
+/** Specifies an array of PGP public keys used to encrypt the output unseal keys. */
+export type RotateAttemptReadProgressResponsePgpKeysList = Array<string>;
+export const RotateAttemptReadProgressResponsePgpKeysList =
+  /*@__PURE__*/ S.Array(
+    S.String,
+  ) as any as S.Schema<RotateAttemptReadProgressResponsePgpKeysList>;
+
+export interface RotateAttemptReadProgressResponse {
+  /** Specifies if using PGP-encrypted keys, whether OpenBao should also store a plaintext backup of the said keys. */
+  backup?: boolean;
+  /** Specifies an array of PGP public keys used to encrypt the output unseal keys. */
+  pgp_keys?: RotateAttemptReadProgressResponsePgpKeysList;
+  /** Enables verification which after successful authorization with the current unseal keys, ensures the new unseal keys are returned but the root key is not actually rotated. */
+  require_verification?: boolean;
+  /** Specifies the number of shares to split the root key into. */
+  secret_shares?: number;
+  /** Specifies the number of shares required to reconstruct the root key. */
+  secret_threshold?: number;
+}
+export const RotateAttemptReadProgressResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    backup: S.optional(S.Boolean),
+    pgp_keys: S.optional(RotateAttemptReadProgressResponsePgpKeysList),
+    require_verification: S.optional(S.Boolean),
+    secret_shares: S.optional(S.Number),
+    secret_threshold: S.optional(S.Number),
+  }),
+).annotate({
+  identifier: "RotateAttemptReadProgressResponse",
+}) as any as S.Schema<RotateAttemptReadProgressResponse>;
+
+export interface RotateAttemptReadRotateRecoveryInitRequest {}
+export const RotateAttemptReadRotateRecoveryInitRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({}).pipe(
+      T.Http({ method: "GET", uri: "/sys/rotate/recovery/init", code: 200 }),
+    ),
+  ).annotate({
+    identifier: "RotateAttemptReadRotateRecoveryInitRequest",
+  }) as any as S.Schema<RotateAttemptReadRotateRecoveryInitRequest>;
+
+/** Specifies an array of PGP public keys used to encrypt the output unseal keys. */
+export type RotateAttemptReadRotateRecoveryInitResponsePgpKeysList =
+  Array<string>;
+export const RotateAttemptReadRotateRecoveryInitResponsePgpKeysList =
+  /*@__PURE__*/ S.Array(
+    S.String,
+  ) as any as S.Schema<RotateAttemptReadRotateRecoveryInitResponsePgpKeysList>;
+
+export interface RotateAttemptReadRotateRecoveryInitResponse {
+  /** Specifies if using PGP-encrypted keys, whether OpenBao should also store a plaintext backup of the said keys. */
+  backup?: boolean;
+  /** Specifies an array of PGP public keys used to encrypt the output unseal keys. */
+  pgp_keys?: RotateAttemptReadRotateRecoveryInitResponsePgpKeysList;
+  /** Enables verification which after successful authorization with the current unseal keys, ensures the new unseal keys are returned but the root key is not actually rotated. */
+  require_verification?: boolean;
+  /** Specifies the number of shares to split the root key into. */
+  secret_shares?: number;
+  /** Specifies the number of shares required to reconstruct the root key. */
+  secret_threshold?: number;
+}
+export const RotateAttemptReadRotateRecoveryInitResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      backup: S.optional(S.Boolean),
+      pgp_keys: S.optional(
+        RotateAttemptReadRotateRecoveryInitResponsePgpKeysList,
+      ),
+      require_verification: S.optional(S.Boolean),
+      secret_shares: S.optional(S.Number),
+      secret_threshold: S.optional(S.Number),
+    }),
+  ).annotate({
+    identifier: "RotateAttemptReadRotateRecoveryInitResponse",
+  }) as any as S.Schema<RotateAttemptReadRotateRecoveryInitResponse>;
+
+export interface RotateAttemptUpdateRequest {
+  /** Specifies a single unseal key share. */
+  key?: string;
+  /** Specifies the nonce of the rotation attempt. */
+  nonce?: string;
+}
+export const RotateAttemptUpdateRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    key: S.optional(S.String),
+    nonce: S.optional(S.String),
+  }).pipe(
+    T.Http({ method: "POST", uri: "/sys/rotate/root/update", code: 200 }),
+  ),
+).annotate({
+  identifier: "RotateAttemptUpdateRequest",
+}) as any as S.Schema<RotateAttemptUpdateRequest>;
+
+export type RotateAttemptUpdateResponseKeysList = Array<string>;
+export const RotateAttemptUpdateResponseKeysList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<RotateAttemptUpdateResponseKeysList>;
+
+export type RotateAttemptUpdateResponseKeysBase64List = Array<string>;
+export const RotateAttemptUpdateResponseKeysBase64List = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<RotateAttemptUpdateResponseKeysBase64List>;
+
+export type RotateAttemptUpdateResponsePgpFingerprintsList = Array<string>;
+export const RotateAttemptUpdateResponsePgpFingerprintsList =
+  /*@__PURE__*/ S.Array(
+    S.String,
+  ) as any as S.Schema<RotateAttemptUpdateResponsePgpFingerprintsList>;
+
+export interface RotateAttemptUpdateResponse {
+  backup?: boolean;
+  complete?: boolean;
+  keys?: RotateAttemptUpdateResponseKeysList;
+  keys_base64?: RotateAttemptUpdateResponseKeysBase64List;
+  n?: number;
+  nonce?: string;
+  pgp_fingerprints?: RotateAttemptUpdateResponsePgpFingerprintsList;
+  progress?: number;
+  required?: number;
+  started?: boolean;
+  t?: number;
+  verification_nonce?: string;
+  verification_required?: boolean;
+}
+export const RotateAttemptUpdateResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    backup: S.optional(S.Boolean),
+    complete: S.optional(S.Boolean),
+    keys: S.optional(RotateAttemptUpdateResponseKeysList),
+    keys_base64: S.optional(RotateAttemptUpdateResponseKeysBase64List),
+    n: S.optional(S.Number),
+    nonce: S.optional(S.String),
+    pgp_fingerprints: S.optional(
+      RotateAttemptUpdateResponsePgpFingerprintsList,
+    ),
+    progress: S.optional(S.Number),
+    required: S.optional(S.Number),
+    started: S.optional(S.Boolean),
+    t: S.optional(S.Number),
+    verification_nonce: S.optional(S.String),
+    verification_required: S.optional(S.Boolean),
+  }),
+).annotate({
+  identifier: "RotateAttemptUpdateResponse",
+}) as any as S.Schema<RotateAttemptUpdateResponse>;
+
+export interface RotateAttemptUpdateRotateRecoveryUpdateRequest {
+  /** Specifies a single unseal key share. */
+  key?: string;
+  /** Specifies the nonce of the rotation attempt. */
+  nonce?: string;
+}
+export const RotateAttemptUpdateRotateRecoveryUpdateRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      key: S.optional(S.String),
+      nonce: S.optional(S.String),
+    }).pipe(
+      T.Http({ method: "POST", uri: "/sys/rotate/recovery/update", code: 200 }),
+    ),
+  ).annotate({
+    identifier: "RotateAttemptUpdateRotateRecoveryUpdateRequest",
+  }) as any as S.Schema<RotateAttemptUpdateRotateRecoveryUpdateRequest>;
+
+export type RotateAttemptUpdateRotateRecoveryUpdateResponseKeysList =
+  Array<string>;
+export const RotateAttemptUpdateRotateRecoveryUpdateResponseKeysList =
+  /*@__PURE__*/ S.Array(
+    S.String,
+  ) as any as S.Schema<RotateAttemptUpdateRotateRecoveryUpdateResponseKeysList>;
+
+export type RotateAttemptUpdateRotateRecoveryUpdateResponseKeysBase64List =
+  Array<string>;
+export const RotateAttemptUpdateRotateRecoveryUpdateResponseKeysBase64List =
+  /*@__PURE__*/ S.Array(
+    S.String,
+  ) as any as S.Schema<RotateAttemptUpdateRotateRecoveryUpdateResponseKeysBase64List>;
+
+export type RotateAttemptUpdateRotateRecoveryUpdateResponsePgpFingerprintsList =
+  Array<string>;
+export const RotateAttemptUpdateRotateRecoveryUpdateResponsePgpFingerprintsList =
+  /*@__PURE__*/ S.Array(
+    S.String,
+  ) as any as S.Schema<RotateAttemptUpdateRotateRecoveryUpdateResponsePgpFingerprintsList>;
+
+export interface RotateAttemptUpdateRotateRecoveryUpdateResponse {
+  backup?: boolean;
+  complete?: boolean;
+  keys?: RotateAttemptUpdateRotateRecoveryUpdateResponseKeysList;
+  keys_base64?: RotateAttemptUpdateRotateRecoveryUpdateResponseKeysBase64List;
+  n?: number;
+  nonce?: string;
+  pgp_fingerprints?: RotateAttemptUpdateRotateRecoveryUpdateResponsePgpFingerprintsList;
+  progress?: number;
+  required?: number;
+  started?: boolean;
+  t?: number;
+  verification_nonce?: string;
+  verification_required?: boolean;
+}
+export const RotateAttemptUpdateRotateRecoveryUpdateResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      backup: S.optional(S.Boolean),
+      complete: S.optional(S.Boolean),
+      keys: S.optional(RotateAttemptUpdateRotateRecoveryUpdateResponseKeysList),
+      keys_base64: S.optional(
+        RotateAttemptUpdateRotateRecoveryUpdateResponseKeysBase64List,
+      ),
+      n: S.optional(S.Number),
+      nonce: S.optional(S.String),
+      pgp_fingerprints: S.optional(
+        RotateAttemptUpdateRotateRecoveryUpdateResponsePgpFingerprintsList,
+      ),
+      progress: S.optional(S.Number),
+      required: S.optional(S.Number),
+      started: S.optional(S.Boolean),
+      t: S.optional(S.Number),
+      verification_nonce: S.optional(S.String),
+      verification_required: S.optional(S.Boolean),
+    }),
+  ).annotate({
+    identifier: "RotateAttemptUpdateRotateRecoveryUpdateResponse",
+  }) as any as S.Schema<RotateAttemptUpdateRotateRecoveryUpdateResponse>;
+
+export interface RotateDeleteBackupKeyRequest {}
+export const RotateDeleteBackupKeyRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}).pipe(
+    T.Http({ method: "DELETE", uri: "/sys/rotate/root/backup", code: 200 }),
+  ),
+).annotate({
+  identifier: "RotateDeleteBackupKeyRequest",
+}) as any as S.Schema<RotateDeleteBackupKeyRequest>;
+
+export interface RotateDeleteBackupKeyResponse {}
+export const RotateDeleteBackupKeyResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "RotateDeleteBackupKeyResponse",
+}) as any as S.Schema<RotateDeleteBackupKeyResponse>;
+
+export interface RotateDeleteRotateRecoveryBackupRequest {}
+export const RotateDeleteRotateRecoveryBackupRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({}).pipe(
+      T.Http({
+        method: "DELETE",
+        uri: "/sys/rotate/recovery/backup",
+        code: 200,
+      }),
+    ),
+).annotate({
+  identifier: "RotateDeleteRotateRecoveryBackupRequest",
+}) as any as S.Schema<RotateDeleteRotateRecoveryBackupRequest>;
+
+export interface RotateDeleteRotateRecoveryBackupResponse {}
+export const RotateDeleteRotateRecoveryBackupResponse = /*@__PURE__*/ S.suspend(
+  () => S.Struct({}),
+).annotate({
+  identifier: "RotateDeleteRotateRecoveryBackupResponse",
+}) as any as S.Schema<RotateDeleteRotateRecoveryBackupResponse>;
+
+export interface RotateEncryptionKeyRequest {}
+export const RotateEncryptionKeyRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}).pipe(T.Http({ method: "POST", uri: "/sys/rotate", code: 200 })),
+).annotate({
+  identifier: "RotateEncryptionKeyRequest",
+}) as any as S.Schema<RotateEncryptionKeyRequest>;
+
+export interface RotateEncryptionKeyResponse {}
+export const RotateEncryptionKeyResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "RotateEncryptionKeyResponse",
+}) as any as S.Schema<RotateEncryptionKeyResponse>;
+
+export interface RotateReadBackupKeyRequest {}
+export const RotateReadBackupKeyRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}).pipe(
+    T.Http({ method: "GET", uri: "/sys/rotate/root/backup", code: 200 }),
+  ),
+).annotate({
+  identifier: "RotateReadBackupKeyRequest",
+}) as any as S.Schema<RotateReadBackupKeyRequest>;
+
+export type RotateReadBackupKeyResponseKeysList = Array<string>;
+export const RotateReadBackupKeyResponseKeysList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<RotateReadBackupKeyResponseKeysList>;
+
+export type RotateReadBackupKeyResponseKeysBase64List = Array<string>;
+export const RotateReadBackupKeyResponseKeysBase64List = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<RotateReadBackupKeyResponseKeysBase64List>;
+
+export interface RotateReadBackupKeyResponse {
+  keys?: RotateReadBackupKeyResponseKeysList;
+  keys_base64?: RotateReadBackupKeyResponseKeysBase64List;
+  nonce?: string;
+}
+export const RotateReadBackupKeyResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    keys: S.optional(RotateReadBackupKeyResponseKeysList),
+    keys_base64: S.optional(RotateReadBackupKeyResponseKeysBase64List),
+    nonce: S.optional(S.String),
+  }),
+).annotate({
+  identifier: "RotateReadBackupKeyResponse",
+}) as any as S.Schema<RotateReadBackupKeyResponse>;
+
+export interface RotateReadRotateRecoveryBackupRequest {}
+export const RotateReadRotateRecoveryBackupRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({}).pipe(
+      T.Http({ method: "GET", uri: "/sys/rotate/recovery/backup", code: 200 }),
+    ),
+).annotate({
+  identifier: "RotateReadRotateRecoveryBackupRequest",
+}) as any as S.Schema<RotateReadRotateRecoveryBackupRequest>;
+
+export type RotateReadRotateRecoveryBackupResponseKeysList = Array<string>;
+export const RotateReadRotateRecoveryBackupResponseKeysList =
+  /*@__PURE__*/ S.Array(
+    S.String,
+  ) as any as S.Schema<RotateReadRotateRecoveryBackupResponseKeysList>;
+
+export type RotateReadRotateRecoveryBackupResponseKeysBase64List =
+  Array<string>;
+export const RotateReadRotateRecoveryBackupResponseKeysBase64List =
+  /*@__PURE__*/ S.Array(
+    S.String,
+  ) as any as S.Schema<RotateReadRotateRecoveryBackupResponseKeysBase64List>;
+
+export interface RotateReadRotateRecoveryBackupResponse {
+  keys?: RotateReadRotateRecoveryBackupResponseKeysList;
+  keys_base64?: RotateReadRotateRecoveryBackupResponseKeysBase64List;
+  nonce?: string;
+}
+export const RotateReadRotateRecoveryBackupResponse = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      keys: S.optional(RotateReadRotateRecoveryBackupResponseKeysList),
+      keys_base64: S.optional(
+        RotateReadRotateRecoveryBackupResponseKeysBase64List,
+      ),
+      nonce: S.optional(S.String),
+    }),
+).annotate({
+  identifier: "RotateReadRotateRecoveryBackupResponse",
+}) as any as S.Schema<RotateReadRotateRecoveryBackupResponse>;
+
+export interface RotateRotateKeyringRequest {}
+export const RotateRotateKeyringRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}).pipe(
+    T.Http({ method: "POST", uri: "/sys/rotate/keyring", code: 200 }),
+  ),
+).annotate({
+  identifier: "RotateRotateKeyringRequest",
+}) as any as S.Schema<RotateRotateKeyringRequest>;
+
+export interface RotateRotateKeyringResponse {}
+export const RotateRotateKeyringResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "RotateRotateKeyringResponse",
+}) as any as S.Schema<RotateRotateKeyringResponse>;
+
+export interface RotateVerificationCancelRequest {}
+export const RotateVerificationCancelRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}).pipe(
+    T.Http({ method: "DELETE", uri: "/sys/rotate/root/verify", code: 200 }),
+  ),
+).annotate({
+  identifier: "RotateVerificationCancelRequest",
+}) as any as S.Schema<RotateVerificationCancelRequest>;
+
+export interface RotateVerificationCancelResponse {
+  n?: number;
+  nonce?: string;
+  progress?: number;
+  started?: boolean;
+  t?: number;
+}
+export const RotateVerificationCancelResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    n: S.optional(S.Number),
+    nonce: S.optional(S.String),
+    progress: S.optional(S.Number),
+    started: S.optional(S.Boolean),
+    t: S.optional(S.Number),
+  }),
+).annotate({
+  identifier: "RotateVerificationCancelResponse",
+}) as any as S.Schema<RotateVerificationCancelResponse>;
+
+export interface RotateVerificationCancelRotateRecoveryVerifyRequest {}
+export const RotateVerificationCancelRotateRecoveryVerifyRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({}).pipe(
+      T.Http({
+        method: "DELETE",
+        uri: "/sys/rotate/recovery/verify",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "RotateVerificationCancelRotateRecoveryVerifyRequest",
+  }) as any as S.Schema<RotateVerificationCancelRotateRecoveryVerifyRequest>;
+
+export interface RotateVerificationCancelRotateRecoveryVerifyResponse {
+  n?: number;
+  nonce?: string;
+  progress?: number;
+  started?: boolean;
+  t?: number;
+}
+export const RotateVerificationCancelRotateRecoveryVerifyResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      n: S.optional(S.Number),
+      nonce: S.optional(S.String),
+      progress: S.optional(S.Number),
+      started: S.optional(S.Boolean),
+      t: S.optional(S.Number),
+    }),
+  ).annotate({
+    identifier: "RotateVerificationCancelRotateRecoveryVerifyResponse",
+  }) as any as S.Schema<RotateVerificationCancelRotateRecoveryVerifyResponse>;
+
+export interface RotateVerificationReadProgressRequest {}
+export const RotateVerificationReadProgressRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({}).pipe(
+      T.Http({ method: "GET", uri: "/sys/rotate/root/verify", code: 200 }),
+    ),
+).annotate({
+  identifier: "RotateVerificationReadProgressRequest",
+}) as any as S.Schema<RotateVerificationReadProgressRequest>;
+
+export interface RotateVerificationReadProgressResponse {
+  n?: number;
+  nonce?: string;
+  progress?: number;
+  started?: boolean;
+  t?: number;
+}
+export const RotateVerificationReadProgressResponse = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      n: S.optional(S.Number),
+      nonce: S.optional(S.String),
+      progress: S.optional(S.Number),
+      started: S.optional(S.Boolean),
+      t: S.optional(S.Number),
+    }),
+).annotate({
+  identifier: "RotateVerificationReadProgressResponse",
+}) as any as S.Schema<RotateVerificationReadProgressResponse>;
+
+export interface RotateVerificationReadRotateRecoveryVerifyRequest {}
+export const RotateVerificationReadRotateRecoveryVerifyRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({}).pipe(
+      T.Http({ method: "GET", uri: "/sys/rotate/recovery/verify", code: 200 }),
+    ),
+  ).annotate({
+    identifier: "RotateVerificationReadRotateRecoveryVerifyRequest",
+  }) as any as S.Schema<RotateVerificationReadRotateRecoveryVerifyRequest>;
+
+export interface RotateVerificationReadRotateRecoveryVerifyResponse {
+  n?: number;
+  nonce?: string;
+  progress?: number;
+  started?: boolean;
+  t?: number;
+}
+export const RotateVerificationReadRotateRecoveryVerifyResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      n: S.optional(S.Number),
+      nonce: S.optional(S.String),
+      progress: S.optional(S.Number),
+      started: S.optional(S.Boolean),
+      t: S.optional(S.Number),
+    }),
+  ).annotate({
+    identifier: "RotateVerificationReadRotateRecoveryVerifyResponse",
+  }) as any as S.Schema<RotateVerificationReadRotateRecoveryVerifyResponse>;
+
+export interface RotateVerificationUpdateRequest {
+  /** Specifies a single unseal share key from the new set of shares. */
+  key?: string;
+  /** Specifies the nonce of the rotation verification operation. */
+  nonce?: string;
+}
+export const RotateVerificationUpdateRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    key: S.optional(S.String),
+    nonce: S.optional(S.String),
+  }).pipe(
+    T.Http({ method: "POST", uri: "/sys/rotate/root/verify", code: 200 }),
+  ),
+).annotate({
+  identifier: "RotateVerificationUpdateRequest",
+}) as any as S.Schema<RotateVerificationUpdateRequest>;
+
+export interface RotateVerificationUpdateResponse {
+  complete?: boolean;
+  nonce?: string;
+}
+export const RotateVerificationUpdateResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    complete: S.optional(S.Boolean),
+    nonce: S.optional(S.String),
+  }),
+).annotate({
+  identifier: "RotateVerificationUpdateResponse",
+}) as any as S.Schema<RotateVerificationUpdateResponse>;
+
+export interface RotateVerificationUpdateRotateRecoveryVerifyRequest {
+  /** Specifies a single unseal share key from the new set of shares. */
+  key?: string;
+  /** Specifies the nonce of the rotation verification operation. */
+  nonce?: string;
+}
+export const RotateVerificationUpdateRotateRecoveryVerifyRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      key: S.optional(S.String),
+      nonce: S.optional(S.String),
+    }).pipe(
+      T.Http({ method: "POST", uri: "/sys/rotate/recovery/verify", code: 200 }),
+    ),
+  ).annotate({
+    identifier: "RotateVerificationUpdateRotateRecoveryVerifyRequest",
+  }) as any as S.Schema<RotateVerificationUpdateRotateRecoveryVerifyRequest>;
+
+export interface RotateVerificationUpdateRotateRecoveryVerifyResponse {
+  complete?: boolean;
+  nonce?: string;
+}
+export const RotateVerificationUpdateRotateRecoveryVerifyResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      complete: S.optional(S.Boolean),
+      nonce: S.optional(S.String),
+    }),
+  ).annotate({
+    identifier: "RotateVerificationUpdateRotateRecoveryVerifyResponse",
+  }) as any as S.Schema<RotateVerificationUpdateRotateRecoveryVerifyResponse>;
+
+export type RotateAttemptCancelError = OpenBaoOpError;
+/** Cancels any in-progress rotate root operation. This clears the rotate settings as well as any progress made. This must be called to change the parameters of the rotate. Note: verification is still a part of a rotate. If rotating is canceled during the verification flow, the current unseal keys remain valid. */
+export const rotateAttemptCancel: API.OperationMethod<
+  RotateAttemptCancelRequest,
+  RotateAttemptCancelResponse,
+  RotateAttemptCancelError,
+  OpenBaoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: RotateAttemptCancelRequest,
+  output: RotateAttemptCancelResponse,
+  errors: [],
+  protocol: OpenBaoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type RotateAttemptCancelRotateRecoveryInitError = OpenBaoOpError;
+/** Cancels any in-progress rotate root operation. This clears the rotate settings as well as any progress made. This must be called to change the parameters of the rotate. Note: verification is still a part of a rotate. If rotating is canceled during the verification flow, the current unseal keys remain valid. */
+export const rotateAttemptCancelRotateRecoveryInit: API.OperationMethod<
+  RotateAttemptCancelRotateRecoveryInitRequest,
+  RotateAttemptCancelRotateRecoveryInitResponse,
+  RotateAttemptCancelRotateRecoveryInitError,
+  OpenBaoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: RotateAttemptCancelRotateRecoveryInitRequest,
+  output: RotateAttemptCancelRotateRecoveryInitResponse,
+  errors: [],
+  protocol: OpenBaoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type RotateAttemptInitializeError = OpenBaoOpError;
+/** Initializes a new root rotate attempt. Only a single rotate attempt can take place at a time, and changing the parameters of a rotate requires canceling and starting a new rotation, which will also provide a new nonce. */
+export const rotateAttemptInitialize: API.OperationMethod<
+  RotateAttemptInitializeRequest,
+  RotateAttemptInitializeResponse,
+  RotateAttemptInitializeError,
+  OpenBaoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: RotateAttemptInitializeRequest,
+  output: RotateAttemptInitializeResponse,
+  errors: [],
+  protocol: OpenBaoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type RotateAttemptInitializeRotateRecoveryInitError = OpenBaoOpError;
+/** Initializes a new root rotate attempt. Only a single rotate attempt can take place at a time, and changing the parameters of a rotate requires canceling and starting a new rotation, which will also provide a new nonce. */
+export const rotateAttemptInitializeRotateRecoveryInit: API.OperationMethod<
+  RotateAttemptInitializeRotateRecoveryInitRequest,
+  RotateAttemptInitializeRotateRecoveryInitResponse,
+  RotateAttemptInitializeRotateRecoveryInitError,
+  OpenBaoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: RotateAttemptInitializeRotateRecoveryInitRequest,
+  output: RotateAttemptInitializeRotateRecoveryInitResponse,
+  errors: [],
+  protocol: OpenBaoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type RotateAttemptReadProgressError = OpenBaoOpError;
+/** Reads the configuration and progress of the current root rotate attempt. */
+export const rotateAttemptReadProgress: API.OperationMethod<
+  RotateAttemptReadProgressRequest,
+  RotateAttemptReadProgressResponse,
+  RotateAttemptReadProgressError,
+  OpenBaoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: RotateAttemptReadProgressRequest,
+  output: RotateAttemptReadProgressResponse,
+  errors: [],
+  protocol: OpenBaoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type RotateAttemptReadRotateRecoveryInitError = OpenBaoOpError;
+/** Reads the configuration and progress of the current root rotate attempt. */
+export const rotateAttemptReadRotateRecoveryInit: API.OperationMethod<
+  RotateAttemptReadRotateRecoveryInitRequest,
+  RotateAttemptReadRotateRecoveryInitResponse,
+  RotateAttemptReadRotateRecoveryInitError,
+  OpenBaoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: RotateAttemptReadRotateRecoveryInitRequest,
+  output: RotateAttemptReadRotateRecoveryInitResponse,
+  errors: [],
+  protocol: OpenBaoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type RotateAttemptUpdateError = OpenBaoOpError;
+/** Enter a single unseal key share to progress the rotation of the root key of OpenBao. */
+export const rotateAttemptUpdate: API.OperationMethod<
+  RotateAttemptUpdateRequest,
+  RotateAttemptUpdateResponse,
+  RotateAttemptUpdateError,
+  OpenBaoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: RotateAttemptUpdateRequest,
+  output: RotateAttemptUpdateResponse,
+  errors: [],
+  protocol: OpenBaoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type RotateAttemptUpdateRotateRecoveryUpdateError = OpenBaoOpError;
+/** Enter a single unseal key share to progress the rotation of the root key of OpenBao. */
+export const rotateAttemptUpdateRotateRecoveryUpdate: API.OperationMethod<
+  RotateAttemptUpdateRotateRecoveryUpdateRequest,
+  RotateAttemptUpdateRotateRecoveryUpdateResponse,
+  RotateAttemptUpdateRotateRecoveryUpdateError,
+  OpenBaoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: RotateAttemptUpdateRotateRecoveryUpdateRequest,
+  output: RotateAttemptUpdateRotateRecoveryUpdateResponse,
+  errors: [],
+  protocol: OpenBaoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type RotateDeleteBackupKeyError = OpenBaoOpError;
+/** Delete the backup copy of PGP-encrypted unseal keys. */
+export const rotateDeleteBackupKey: API.OperationMethod<
+  RotateDeleteBackupKeyRequest,
+  RotateDeleteBackupKeyResponse,
+  RotateDeleteBackupKeyError,
+  OpenBaoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: RotateDeleteBackupKeyRequest,
+  output: RotateDeleteBackupKeyResponse,
+  errors: [],
+  protocol: OpenBaoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type RotateDeleteRotateRecoveryBackupError = OpenBaoOpError;
+/** Delete the backup copy of PGP-encrypted unseal keys. */
+export const rotateDeleteRotateRecoveryBackup: API.OperationMethod<
+  RotateDeleteRotateRecoveryBackupRequest,
+  RotateDeleteRotateRecoveryBackupResponse,
+  RotateDeleteRotateRecoveryBackupError,
+  OpenBaoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: RotateDeleteRotateRecoveryBackupRequest,
+  output: RotateDeleteRotateRecoveryBackupResponse,
+  errors: [],
+  protocol: OpenBaoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type RotateEncryptionKeyError = OpenBaoOpError;
+/** Rotate the encryption key. */
+export const rotateEncryptionKey: API.OperationMethod<
+  RotateEncryptionKeyRequest,
+  RotateEncryptionKeyResponse,
+  RotateEncryptionKeyError,
+  OpenBaoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: RotateEncryptionKeyRequest,
+  output: RotateEncryptionKeyResponse,
+  errors: [],
+  protocol: OpenBaoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type RotateReadBackupKeyError = OpenBaoOpError;
+/** Return the backup copy of PGP-encrypted unseal keys. */
+export const rotateReadBackupKey: API.OperationMethod<
+  RotateReadBackupKeyRequest,
+  RotateReadBackupKeyResponse,
+  RotateReadBackupKeyError,
+  OpenBaoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: RotateReadBackupKeyRequest,
+  output: RotateReadBackupKeyResponse,
+  errors: [],
+  protocol: OpenBaoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type RotateReadRotateRecoveryBackupError = OpenBaoOpError;
+/** Return the backup copy of PGP-encrypted unseal keys. */
+export const rotateReadRotateRecoveryBackup: API.OperationMethod<
+  RotateReadRotateRecoveryBackupRequest,
+  RotateReadRotateRecoveryBackupResponse,
+  RotateReadRotateRecoveryBackupError,
+  OpenBaoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: RotateReadRotateRecoveryBackupRequest,
+  output: RotateReadRotateRecoveryBackupResponse,
+  errors: [],
+  protocol: OpenBaoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type RotateRotateKeyringError = OpenBaoOpError;
+/** Rotate the encryption key. */
+export const rotateRotateKeyring: API.OperationMethod<
+  RotateRotateKeyringRequest,
+  RotateRotateKeyringResponse,
+  RotateRotateKeyringError,
+  OpenBaoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: RotateRotateKeyringRequest,
+  output: RotateRotateKeyringResponse,
+  errors: [],
+  protocol: OpenBaoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type RotateVerificationCancelError = OpenBaoOpError;
+/** Cancel any in-progress rotate verification operation. This clears any progress made and resets the nonce. Unlike a `DELETE` against `sys/rotate/(root/recovery)/init`, this only resets the current verification operation, not the entire rotate atttempt. */
+export const rotateVerificationCancel: API.OperationMethod<
+  RotateVerificationCancelRequest,
+  RotateVerificationCancelResponse,
+  RotateVerificationCancelError,
+  OpenBaoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: RotateVerificationCancelRequest,
+  output: RotateVerificationCancelResponse,
+  errors: [],
+  protocol: OpenBaoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type RotateVerificationCancelRotateRecoveryVerifyError = OpenBaoOpError;
+/** Cancel any in-progress rotate verification operation. This clears any progress made and resets the nonce. Unlike a `DELETE` against `sys/rotate/(root/recovery)/init`, this only resets the current verification operation, not the entire rotate atttempt. */
+export const rotateVerificationCancelRotateRecoveryVerify: API.OperationMethod<
+  RotateVerificationCancelRotateRecoveryVerifyRequest,
+  RotateVerificationCancelRotateRecoveryVerifyResponse,
+  RotateVerificationCancelRotateRecoveryVerifyError,
+  OpenBaoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: RotateVerificationCancelRotateRecoveryVerifyRequest,
+  output: RotateVerificationCancelRotateRecoveryVerifyResponse,
+  errors: [],
+  protocol: OpenBaoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type RotateVerificationReadProgressError = OpenBaoOpError;
+/** Read the configuration and progress of the current rotate verification attempt. */
+export const rotateVerificationReadProgress: API.OperationMethod<
+  RotateVerificationReadProgressRequest,
+  RotateVerificationReadProgressResponse,
+  RotateVerificationReadProgressError,
+  OpenBaoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: RotateVerificationReadProgressRequest,
+  output: RotateVerificationReadProgressResponse,
+  errors: [],
+  protocol: OpenBaoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type RotateVerificationReadRotateRecoveryVerifyError = OpenBaoOpError;
+/** Read the configuration and progress of the current rotate verification attempt. */
+export const rotateVerificationReadRotateRecoveryVerify: API.OperationMethod<
+  RotateVerificationReadRotateRecoveryVerifyRequest,
+  RotateVerificationReadRotateRecoveryVerifyResponse,
+  RotateVerificationReadRotateRecoveryVerifyError,
+  OpenBaoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: RotateVerificationReadRotateRecoveryVerifyRequest,
+  output: RotateVerificationReadRotateRecoveryVerifyResponse,
+  errors: [],
+  protocol: OpenBaoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type RotateVerificationUpdateError = OpenBaoOpError;
+/** Enter a single new key share to progress the rotation verification operation. */
+export const rotateVerificationUpdate: API.OperationMethod<
+  RotateVerificationUpdateRequest,
+  RotateVerificationUpdateResponse,
+  RotateVerificationUpdateError,
+  OpenBaoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: RotateVerificationUpdateRequest,
+  output: RotateVerificationUpdateResponse,
+  errors: [],
+  protocol: OpenBaoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type RotateVerificationUpdateRotateRecoveryVerifyError = OpenBaoOpError;
+/** Enter a single new key share to progress the rotation verification operation. */
+export const rotateVerificationUpdateRotateRecoveryVerify: API.OperationMethod<
+  RotateVerificationUpdateRotateRecoveryVerifyRequest,
+  RotateVerificationUpdateRotateRecoveryVerifyResponse,
+  RotateVerificationUpdateRotateRecoveryVerifyError,
+  OpenBaoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: RotateVerificationUpdateRotateRecoveryVerifyRequest,
+  output: RotateVerificationUpdateRotateRecoveryVerifyResponse,
+  errors: [],
+  protocol: OpenBaoProtocol,
+  retry: Retry.Retry,
+}));