@homeflare/distilled-openbao 0.2.0

package/src/services/kv.ts

@@ -0,0 +1,1480 @@
+// 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 KvDeleteDataPathRequest {
+  /** Path that the backend was mounted at */
+  kv_mount_path: string;
+  /** Location of the secret. */
+  path: string;
+}
+export const KvDeleteDataPathRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    kv_mount_path: S.String.pipe(T.Label()),
+    path: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "DELETE",
+      uri: "/{kv_mount_path}/data/{path}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "KvDeleteDataPathRequest",
+}) as any as S.Schema<KvDeleteDataPathRequest>;
+
+export interface KvDeleteDataPathResponse {}
+export const KvDeleteDataPathResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "KvDeleteDataPathResponse",
+}) as any as S.Schema<KvDeleteDataPathResponse>;
+
+export interface KvDeleteDataPathRequest2 {
+  /** Path that the backend was mounted at */
+  secret_mount_path: string;
+  /** Location of the secret. */
+  path: string;
+}
+export const KvDeleteDataPathRequest2 = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    secret_mount_path: S.String.pipe(T.Label()),
+    path: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "DELETE",
+      uri: "/{secret_mount_path}/data/{path}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "KvDeleteDataPathRequest2",
+}) as any as S.Schema<KvDeleteDataPathRequest2>;
+
+export interface KvDeleteDataPath2Response {}
+export const KvDeleteDataPath2Response = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "KvDeleteDataPath2Response",
+}) as any as S.Schema<KvDeleteDataPath2Response>;
+
+export interface KvDeleteMetadataPathRequest {
+  /** Path that the backend was mounted at */
+  kv_mount_path: string;
+  /** Location of the secret. */
+  path: string;
+}
+export const KvDeleteMetadataPathRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    kv_mount_path: S.String.pipe(T.Label()),
+    path: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "DELETE",
+      uri: "/{kv_mount_path}/metadata/{path}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "KvDeleteMetadataPathRequest",
+}) as any as S.Schema<KvDeleteMetadataPathRequest>;
+
+export interface KvDeleteMetadataPathResponse {}
+export const KvDeleteMetadataPathResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "KvDeleteMetadataPathResponse",
+}) as any as S.Schema<KvDeleteMetadataPathResponse>;
+
+export interface KvDeleteMetadataPathRequest2 {
+  /** Path that the backend was mounted at */
+  secret_mount_path: string;
+  /** Location of the secret. */
+  path: string;
+}
+export const KvDeleteMetadataPathRequest2 = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    secret_mount_path: S.String.pipe(T.Label()),
+    path: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "DELETE",
+      uri: "/{secret_mount_path}/metadata/{path}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "KvDeleteMetadataPathRequest2",
+}) as any as S.Schema<KvDeleteMetadataPathRequest2>;
+
+export interface KvDeleteMetadataPath2Response {}
+export const KvDeleteMetadataPath2Response = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "KvDeleteMetadataPath2Response",
+}) as any as S.Schema<KvDeleteMetadataPath2Response>;
+
+export interface KvPatchDataPathRequest {
+  /** Path that the backend was mounted at */
+  kv_mount_path: string;
+  /** Location of the secret. */
+  path: string;
+  /** The contents of the data map will be stored and returned on read. */
+  data?: unknown;
+  /** Options for writing a KV entry. Set the "cas" value to use a Check-And-Set operation. If not set the write will be allowed. If set to 0 a write will only be allowed if the key doesn’t exist. If the index is non-zero the write will only be allowed if the key’s current version matches the version specified in the cas parameter. */
+  options?: unknown;
+  /** If provided during a read, the value at the version number will be returned */
+  version?: number;
+}
+export const KvPatchDataPathRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    kv_mount_path: S.String.pipe(T.Label()),
+    path: S.String.pipe(T.Label()),
+    data: S.optional(S.Unknown),
+    options: S.optional(S.Unknown),
+    version: S.optional(S.Number),
+  }).pipe(
+    T.Http({ method: "PATCH", uri: "/{kv_mount_path}/data/{path}", code: 200 }),
+  ),
+).annotate({
+  identifier: "KvPatchDataPathRequest",
+}) as any as S.Schema<KvPatchDataPathRequest>;
+
+export interface KvPatchDataPathResponse {}
+export const KvPatchDataPathResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "KvPatchDataPathResponse",
+}) as any as S.Schema<KvPatchDataPathResponse>;
+
+export interface KvPatchDataPathRequest2 {
+  /** Path that the backend was mounted at */
+  secret_mount_path: string;
+  /** Location of the secret. */
+  path: string;
+  /** The contents of the data map will be stored and returned on read. */
+  data?: unknown;
+  /** Options for writing a KV entry. Set the "cas" value to use a Check-And-Set operation. If not set the write will be allowed. If set to 0 a write will only be allowed if the key doesn’t exist. If the index is non-zero the write will only be allowed if the key’s current version matches the version specified in the cas parameter. */
+  options?: unknown;
+  /** If provided during a read, the value at the version number will be returned */
+  version?: number;
+}
+export const KvPatchDataPathRequest2 = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    secret_mount_path: S.String.pipe(T.Label()),
+    path: S.String.pipe(T.Label()),
+    data: S.optional(S.Unknown),
+    options: S.optional(S.Unknown),
+    version: S.optional(S.Number),
+  }).pipe(
+    T.Http({
+      method: "PATCH",
+      uri: "/{secret_mount_path}/data/{path}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "KvPatchDataPathRequest2",
+}) as any as S.Schema<KvPatchDataPathRequest2>;
+
+export interface KvPatchDataPath2Response {}
+export const KvPatchDataPath2Response = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "KvPatchDataPath2Response",
+}) as any as S.Schema<KvPatchDataPath2Response>;
+
+export interface KvPatchMetadataPathRequest {
+  /** Path that the backend was mounted at */
+  kv_mount_path: string;
+  /** Location of the secret. */
+  path: string;
+  /** Optional entry to list begin listing after, not required to exist. Only used for listing. */
+  after?: string;
+  /** If true the key will require the cas parameter to be set on all write requests. If false, the backend’s configuration will be used. */
+  cas_required?: boolean;
+  /** User-provided key-value pairs that are used to describe arbitrary and version-agnostic information about a secret. */
+  custom_metadata?: unknown;
+  /** The length of time before a version is deleted. If not set, the backend's configured delete_version_after is used. Cannot be greater than the backend's delete_version_after. A zero duration clears the current setting. A negative duration will cause an error. */
+  delete_version_after?: number;
+  /** Optional number of entries to return; defaults to all entries. Only used for listing. */
+  limit?: number;
+  /** The number of versions to keep. If not set, the backend’s configured max version is used. */
+  max_versions?: number;
+  /** Check-and-set parameter for metadata updates. Must match the current metadata version for the update to succeed. Set to 0 for initial metadata creation. */
+  metadata_cas?: number;
+  /** If true the key will require the cas parameter to be set on all metadata update requests. If false, the backend's configuration will be used. */
+  metadata_cas_required?: boolean;
+}
+export const KvPatchMetadataPathRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    kv_mount_path: S.String.pipe(T.Label()),
+    path: S.String.pipe(T.Label()),
+    after: S.optional(S.String),
+    cas_required: S.optional(S.Boolean),
+    custom_metadata: S.optional(S.Unknown),
+    delete_version_after: S.optional(S.Number),
+    limit: S.optional(S.Number),
+    max_versions: S.optional(S.Number),
+    metadata_cas: S.optional(S.Number),
+    metadata_cas_required: S.optional(S.Boolean),
+  }).pipe(
+    T.Http({
+      method: "PATCH",
+      uri: "/{kv_mount_path}/metadata/{path}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "KvPatchMetadataPathRequest",
+}) as any as S.Schema<KvPatchMetadataPathRequest>;
+
+export interface KvPatchMetadataPathResponse {}
+export const KvPatchMetadataPathResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "KvPatchMetadataPathResponse",
+}) as any as S.Schema<KvPatchMetadataPathResponse>;
+
+export interface KvPatchMetadataPathRequest2 {
+  /** Path that the backend was mounted at */
+  secret_mount_path: string;
+  /** Location of the secret. */
+  path: string;
+  /** Optional entry to list begin listing after, not required to exist. Only used for listing. */
+  after?: string;
+  /** If true the key will require the cas parameter to be set on all write requests. If false, the backend’s configuration will be used. */
+  cas_required?: boolean;
+  /** User-provided key-value pairs that are used to describe arbitrary and version-agnostic information about a secret. */
+  custom_metadata?: unknown;
+  /** The length of time before a version is deleted. If not set, the backend's configured delete_version_after is used. Cannot be greater than the backend's delete_version_after. A zero duration clears the current setting. A negative duration will cause an error. */
+  delete_version_after?: number;
+  /** Optional number of entries to return; defaults to all entries. Only used for listing. */
+  limit?: number;
+  /** The number of versions to keep. If not set, the backend’s configured max version is used. */
+  max_versions?: number;
+  /** Check-and-set parameter for metadata updates. Must match the current metadata version for the update to succeed. Set to 0 for initial metadata creation. */
+  metadata_cas?: number;
+  /** If true the key will require the cas parameter to be set on all metadata update requests. If false, the backend's configuration will be used. */
+  metadata_cas_required?: boolean;
+}
+export const KvPatchMetadataPathRequest2 = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    secret_mount_path: S.String.pipe(T.Label()),
+    path: S.String.pipe(T.Label()),
+    after: S.optional(S.String),
+    cas_required: S.optional(S.Boolean),
+    custom_metadata: S.optional(S.Unknown),
+    delete_version_after: S.optional(S.Number),
+    limit: S.optional(S.Number),
+    max_versions: S.optional(S.Number),
+    metadata_cas: S.optional(S.Number),
+    metadata_cas_required: S.optional(S.Boolean),
+  }).pipe(
+    T.Http({
+      method: "PATCH",
+      uri: "/{secret_mount_path}/metadata/{path}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "KvPatchMetadataPathRequest2",
+}) as any as S.Schema<KvPatchMetadataPathRequest2>;
+
+export interface KvPatchMetadataPath2Response {}
+export const KvPatchMetadataPath2Response = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "KvPatchMetadataPath2Response",
+}) as any as S.Schema<KvPatchMetadataPath2Response>;
+
+export interface KvReadConfigRequest {
+  /** Path that the backend was mounted at */
+  kv_mount_path: string;
+}
+export const KvReadConfigRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    kv_mount_path: S.String.pipe(T.Label()),
+  }).pipe(T.Http({ method: "GET", uri: "/{kv_mount_path}/config", code: 200 })),
+).annotate({
+  identifier: "KvReadConfigRequest",
+}) as any as S.Schema<KvReadConfigRequest>;
+
+export interface KvReadConfigResponse {}
+export const KvReadConfigResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "KvReadConfigResponse",
+}) as any as S.Schema<KvReadConfigResponse>;
+
+export interface KvReadConfigRequest2 {
+  /** Path that the backend was mounted at */
+  secret_mount_path: string;
+}
+export const KvReadConfigRequest2 = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    secret_mount_path: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({ method: "GET", uri: "/{secret_mount_path}/config", code: 200 }),
+  ),
+).annotate({
+  identifier: "KvReadConfigRequest2",
+}) as any as S.Schema<KvReadConfigRequest2>;
+
+export interface KvReadConfig2Response {}
+export const KvReadConfig2Response = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "KvReadConfig2Response",
+}) as any as S.Schema<KvReadConfig2Response>;
+
+export interface KvReadDataPathRequest {
+  /** Path that the backend was mounted at */
+  kv_mount_path: string;
+  /** Location of the secret. */
+  path: string;
+}
+export const KvReadDataPathRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    kv_mount_path: S.String.pipe(T.Label()),
+    path: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({ method: "GET", uri: "/{kv_mount_path}/data/{path}", code: 200 }),
+  ),
+).annotate({
+  identifier: "KvReadDataPathRequest",
+}) as any as S.Schema<KvReadDataPathRequest>;
+
+export interface KvReadDataPathResponse {}
+export const KvReadDataPathResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "KvReadDataPathResponse",
+}) as any as S.Schema<KvReadDataPathResponse>;
+
+export interface KvReadDataPathRequest2 {
+  /** Path that the backend was mounted at */
+  secret_mount_path: string;
+  /** Location of the secret. */
+  path: string;
+}
+export const KvReadDataPathRequest2 = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    secret_mount_path: S.String.pipe(T.Label()),
+    path: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/{secret_mount_path}/data/{path}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "KvReadDataPathRequest2",
+}) as any as S.Schema<KvReadDataPathRequest2>;
+
+export interface KvReadDataPath2Response {}
+export const KvReadDataPath2Response = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "KvReadDataPath2Response",
+}) as any as S.Schema<KvReadDataPath2Response>;
+
+export interface KvReadMetadataPathRequest {
+  /** Path that the backend was mounted at */
+  kv_mount_path: string;
+  /** Location of the secret. */
+  path: string;
+  /** Return a list if `true` */
+  list?: string;
+  /** Return a recursive list if `true` */
+  scan?: string;
+}
+export const KvReadMetadataPathRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    kv_mount_path: S.String.pipe(T.Label()),
+    path: S.String.pipe(T.Label()),
+    list: S.optional(S.String.pipe(T.Query())),
+    scan: S.optional(S.String.pipe(T.Query())),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/{kv_mount_path}/metadata/{path}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "KvReadMetadataPathRequest",
+}) as any as S.Schema<KvReadMetadataPathRequest>;
+
+export interface KvReadMetadataPathResponse {}
+export const KvReadMetadataPathResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "KvReadMetadataPathResponse",
+}) as any as S.Schema<KvReadMetadataPathResponse>;
+
+export interface KvReadMetadataPathRequest2 {
+  /** Path that the backend was mounted at */
+  secret_mount_path: string;
+  /** Location of the secret. */
+  path: string;
+  /** Return a list if `true` */
+  list?: string;
+  /** Return a recursive list if `true` */
+  scan?: string;
+}
+export const KvReadMetadataPathRequest2 = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    secret_mount_path: S.String.pipe(T.Label()),
+    path: S.String.pipe(T.Label()),
+    list: S.optional(S.String.pipe(T.Query())),
+    scan: S.optional(S.String.pipe(T.Query())),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/{secret_mount_path}/metadata/{path}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "KvReadMetadataPathRequest2",
+}) as any as S.Schema<KvReadMetadataPathRequest2>;
+
+export interface KvReadMetadataPath2Response {}
+export const KvReadMetadataPath2Response = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "KvReadMetadataPath2Response",
+}) as any as S.Schema<KvReadMetadataPath2Response>;
+
+export interface KvReadSubkeysPathRequest {
+  /** Path that the backend was mounted at */
+  kv_mount_path: string;
+  /** Location of the secret. */
+  path: string;
+}
+export const KvReadSubkeysPathRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    kv_mount_path: S.String.pipe(T.Label()),
+    path: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/{kv_mount_path}/subkeys/{path}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "KvReadSubkeysPathRequest",
+}) as any as S.Schema<KvReadSubkeysPathRequest>;
+
+export interface KvReadSubkeysPathResponse {}
+export const KvReadSubkeysPathResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "KvReadSubkeysPathResponse",
+}) as any as S.Schema<KvReadSubkeysPathResponse>;
+
+export interface KvReadSubkeysPathRequest2 {
+  /** Path that the backend was mounted at */
+  secret_mount_path: string;
+  /** Location of the secret. */
+  path: string;
+}
+export const KvReadSubkeysPathRequest2 = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    secret_mount_path: S.String.pipe(T.Label()),
+    path: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/{secret_mount_path}/subkeys/{path}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "KvReadSubkeysPathRequest2",
+}) as any as S.Schema<KvReadSubkeysPathRequest2>;
+
+export interface KvReadSubkeysPath2Response {}
+export const KvReadSubkeysPath2Response = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "KvReadSubkeysPath2Response",
+}) as any as S.Schema<KvReadSubkeysPath2Response>;
+
+export type KvScanDetailedMetadataPathRequestList = "true";
+export const KvScanDetailedMetadataPathRequestList = S.String;
+
+export type KvScanDetailedMetadataPathRequestScan = "true";
+export const KvScanDetailedMetadataPathRequestScan = S.String;
+
+export interface KvScanDetailedMetadataPathRequest {
+  /** Path that the backend was mounted at */
+  kv_mount_path: string;
+  /** Location of the secret. */
+  path: string;
+  /** Must be set to `true` or else `scan` must be set to `true` */
+  list: KvScanDetailedMetadataPathRequestList | (string & {});
+  /** Must be set to `true` or else `list` must be set to `true` */
+  scan: KvScanDetailedMetadataPathRequestScan | (string & {});
+}
+export const KvScanDetailedMetadataPathRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    kv_mount_path: S.String.pipe(T.Label()),
+    path: S.String.pipe(T.Label()),
+    list: KvScanDetailedMetadataPathRequestList.pipe(T.Query()),
+    scan: KvScanDetailedMetadataPathRequestScan.pipe(T.Query()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/{kv_mount_path}/detailed-metadata/{path}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "KvScanDetailedMetadataPathRequest",
+}) as any as S.Schema<KvScanDetailedMetadataPathRequest>;
+
+export interface KvScanDetailedMetadataPathResponse {}
+export const KvScanDetailedMetadataPathResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "KvScanDetailedMetadataPathResponse",
+}) as any as S.Schema<KvScanDetailedMetadataPathResponse>;
+
+export type KvScanDetailedMetadataPathRequestList2 = "true";
+export const KvScanDetailedMetadataPathRequestList2 = S.String;
+
+export type KvScanDetailedMetadataPathRequestScan2 = "true";
+export const KvScanDetailedMetadataPathRequestScan2 = S.String;
+
+export interface KvScanDetailedMetadataPathRequest2 {
+  /** Path that the backend was mounted at */
+  secret_mount_path: string;
+  /** Location of the secret. */
+  path: string;
+  /** Must be set to `true` or else `scan` must be set to `true` */
+  list: KvScanDetailedMetadataPathRequestList2 | (string & {});
+  /** Must be set to `true` or else `list` must be set to `true` */
+  scan: KvScanDetailedMetadataPathRequestScan2 | (string & {});
+}
+export const KvScanDetailedMetadataPathRequest2 = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    secret_mount_path: S.String.pipe(T.Label()),
+    path: S.String.pipe(T.Label()),
+    list: KvScanDetailedMetadataPathRequestList2.pipe(T.Query()),
+    scan: KvScanDetailedMetadataPathRequestScan2.pipe(T.Query()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/{secret_mount_path}/detailed-metadata/{path}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "KvScanDetailedMetadataPathRequest2",
+}) as any as S.Schema<KvScanDetailedMetadataPathRequest2>;
+
+export interface KvScanDetailedMetadataPath2Response {}
+export const KvScanDetailedMetadataPath2Response = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "KvScanDetailedMetadataPath2Response",
+}) as any as S.Schema<KvScanDetailedMetadataPath2Response>;
+
+export interface KvWriteConfigRequest {
+  /** Path that the backend was mounted at */
+  kv_mount_path: string;
+  /** If true, the backend will require the cas parameter to be set for each write */
+  cas_required?: boolean;
+  /** If set, the length of time before a version is deleted. A negative duration disables the use of delete_version_after on all keys. A zero duration clears the current setting. Accepts a Go duration format string. */
+  delete_version_after?: number;
+  /** The number of versions to keep for each key. Defaults to 10 */
+  max_versions?: number;
+  /** If true, the backend will require the metadata_cas parameter to be set for each metadata update */
+  metadata_cas_required?: boolean;
+}
+export const KvWriteConfigRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    kv_mount_path: S.String.pipe(T.Label()),
+    cas_required: S.optional(S.Boolean),
+    delete_version_after: S.optional(S.Number),
+    max_versions: S.optional(S.Number),
+    metadata_cas_required: S.optional(S.Boolean),
+  }).pipe(
+    T.Http({ method: "POST", uri: "/{kv_mount_path}/config", code: 200 }),
+  ),
+).annotate({
+  identifier: "KvWriteConfigRequest",
+}) as any as S.Schema<KvWriteConfigRequest>;
+
+export interface KvWriteConfigResponse {}
+export const KvWriteConfigResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "KvWriteConfigResponse",
+}) as any as S.Schema<KvWriteConfigResponse>;
+
+export interface KvWriteConfigRequest2 {
+  /** Path that the backend was mounted at */
+  secret_mount_path: string;
+  /** If true, the backend will require the cas parameter to be set for each write */
+  cas_required?: boolean;
+  /** If set, the length of time before a version is deleted. A negative duration disables the use of delete_version_after on all keys. A zero duration clears the current setting. Accepts a Go duration format string. */
+  delete_version_after?: number;
+  /** The number of versions to keep for each key. Defaults to 10 */
+  max_versions?: number;
+  /** If true, the backend will require the metadata_cas parameter to be set for each metadata update */
+  metadata_cas_required?: boolean;
+}
+export const KvWriteConfigRequest2 = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    secret_mount_path: S.String.pipe(T.Label()),
+    cas_required: S.optional(S.Boolean),
+    delete_version_after: S.optional(S.Number),
+    max_versions: S.optional(S.Number),
+    metadata_cas_required: S.optional(S.Boolean),
+  }).pipe(
+    T.Http({ method: "POST", uri: "/{secret_mount_path}/config", code: 200 }),
+  ),
+).annotate({
+  identifier: "KvWriteConfigRequest2",
+}) as any as S.Schema<KvWriteConfigRequest2>;
+
+export interface KvWriteConfig2Response {}
+export const KvWriteConfig2Response = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "KvWriteConfig2Response",
+}) as any as S.Schema<KvWriteConfig2Response>;
+
+export interface KvWriteDataPathRequest {
+  /** Path that the backend was mounted at */
+  kv_mount_path: string;
+  /** Location of the secret. */
+  path: string;
+  /** The contents of the data map will be stored and returned on read. */
+  data?: unknown;
+  /** Options for writing a KV entry. Set the "cas" value to use a Check-And-Set operation. If not set the write will be allowed. If set to 0 a write will only be allowed if the key doesn’t exist. If the index is non-zero the write will only be allowed if the key’s current version matches the version specified in the cas parameter. */
+  options?: unknown;
+  /** If provided during a read, the value at the version number will be returned */
+  version?: number;
+}
+export const KvWriteDataPathRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    kv_mount_path: S.String.pipe(T.Label()),
+    path: S.String.pipe(T.Label()),
+    data: S.optional(S.Unknown),
+    options: S.optional(S.Unknown),
+    version: S.optional(S.Number),
+  }).pipe(
+    T.Http({ method: "POST", uri: "/{kv_mount_path}/data/{path}", code: 200 }),
+  ),
+).annotate({
+  identifier: "KvWriteDataPathRequest",
+}) as any as S.Schema<KvWriteDataPathRequest>;
+
+export interface KvWriteDataPathResponse {}
+export const KvWriteDataPathResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "KvWriteDataPathResponse",
+}) as any as S.Schema<KvWriteDataPathResponse>;
+
+export interface KvWriteDataPathRequest2 {
+  /** Path that the backend was mounted at */
+  secret_mount_path: string;
+  /** Location of the secret. */
+  path: string;
+  /** The contents of the data map will be stored and returned on read. */
+  data?: unknown;
+  /** Options for writing a KV entry. Set the "cas" value to use a Check-And-Set operation. If not set the write will be allowed. If set to 0 a write will only be allowed if the key doesn’t exist. If the index is non-zero the write will only be allowed if the key’s current version matches the version specified in the cas parameter. */
+  options?: unknown;
+  /** If provided during a read, the value at the version number will be returned */
+  version?: number;
+}
+export const KvWriteDataPathRequest2 = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    secret_mount_path: S.String.pipe(T.Label()),
+    path: S.String.pipe(T.Label()),
+    data: S.optional(S.Unknown),
+    options: S.optional(S.Unknown),
+    version: S.optional(S.Number),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/{secret_mount_path}/data/{path}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "KvWriteDataPathRequest2",
+}) as any as S.Schema<KvWriteDataPathRequest2>;
+
+export interface KvWriteDataPath2Response {}
+export const KvWriteDataPath2Response = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "KvWriteDataPath2Response",
+}) as any as S.Schema<KvWriteDataPath2Response>;
+
+/** The versions to be archived. The versioned data will not be deleted, but it will no longer be returned in normal get requests. */
+export type KvWriteDeletePathRequestVersionsList = Array<number>;
+export const KvWriteDeletePathRequestVersionsList = /*@__PURE__*/ S.Array(
+  S.Number,
+) as any as S.Schema<KvWriteDeletePathRequestVersionsList>;
+
+export interface KvWriteDeletePathRequest {
+  /** Path that the backend was mounted at */
+  kv_mount_path: string;
+  /** Location of the secret. */
+  path: string;
+  /** The versions to be archived. The versioned data will not be deleted, but it will no longer be returned in normal get requests. */
+  versions?: KvWriteDeletePathRequestVersionsList;
+}
+export const KvWriteDeletePathRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    kv_mount_path: S.String.pipe(T.Label()),
+    path: S.String.pipe(T.Label()),
+    versions: S.optional(KvWriteDeletePathRequestVersionsList),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/{kv_mount_path}/delete/{path}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "KvWriteDeletePathRequest",
+}) as any as S.Schema<KvWriteDeletePathRequest>;
+
+export interface KvWriteDeletePathResponse {}
+export const KvWriteDeletePathResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "KvWriteDeletePathResponse",
+}) as any as S.Schema<KvWriteDeletePathResponse>;
+
+/** The versions to be archived. The versioned data will not be deleted, but it will no longer be returned in normal get requests. */
+export type KvWriteDeletePathRequestVersionsList2 = Array<number>;
+export const KvWriteDeletePathRequestVersionsList2 = /*@__PURE__*/ S.Array(
+  S.Number,
+) as any as S.Schema<KvWriteDeletePathRequestVersionsList2>;
+
+export interface KvWriteDeletePathRequest2 {
+  /** Path that the backend was mounted at */
+  secret_mount_path: string;
+  /** Location of the secret. */
+  path: string;
+  /** The versions to be archived. The versioned data will not be deleted, but it will no longer be returned in normal get requests. */
+  versions?: KvWriteDeletePathRequestVersionsList2;
+}
+export const KvWriteDeletePathRequest2 = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    secret_mount_path: S.String.pipe(T.Label()),
+    path: S.String.pipe(T.Label()),
+    versions: S.optional(KvWriteDeletePathRequestVersionsList2),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/{secret_mount_path}/delete/{path}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "KvWriteDeletePathRequest2",
+}) as any as S.Schema<KvWriteDeletePathRequest2>;
+
+export interface KvWriteDeletePath2Response {}
+export const KvWriteDeletePath2Response = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "KvWriteDeletePath2Response",
+}) as any as S.Schema<KvWriteDeletePath2Response>;
+
+/** The versions to destroy. Their data will be permanently deleted. */
+export type KvWriteDestroyPathRequestVersionsList = Array<number>;
+export const KvWriteDestroyPathRequestVersionsList = /*@__PURE__*/ S.Array(
+  S.Number,
+) as any as S.Schema<KvWriteDestroyPathRequestVersionsList>;
+
+export interface KvWriteDestroyPathRequest {
+  /** Path that the backend was mounted at */
+  kv_mount_path: string;
+  /** Location of the secret. */
+  path: string;
+  /** The versions to destroy. Their data will be permanently deleted. */
+  versions?: KvWriteDestroyPathRequestVersionsList;
+}
+export const KvWriteDestroyPathRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    kv_mount_path: S.String.pipe(T.Label()),
+    path: S.String.pipe(T.Label()),
+    versions: S.optional(KvWriteDestroyPathRequestVersionsList),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/{kv_mount_path}/destroy/{path}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "KvWriteDestroyPathRequest",
+}) as any as S.Schema<KvWriteDestroyPathRequest>;
+
+export interface KvWriteDestroyPathResponse {}
+export const KvWriteDestroyPathResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "KvWriteDestroyPathResponse",
+}) as any as S.Schema<KvWriteDestroyPathResponse>;
+
+/** The versions to destroy. Their data will be permanently deleted. */
+export type KvWriteDestroyPathRequestVersionsList2 = Array<number>;
+export const KvWriteDestroyPathRequestVersionsList2 = /*@__PURE__*/ S.Array(
+  S.Number,
+) as any as S.Schema<KvWriteDestroyPathRequestVersionsList2>;
+
+export interface KvWriteDestroyPathRequest2 {
+  /** Path that the backend was mounted at */
+  secret_mount_path: string;
+  /** Location of the secret. */
+  path: string;
+  /** The versions to destroy. Their data will be permanently deleted. */
+  versions?: KvWriteDestroyPathRequestVersionsList2;
+}
+export const KvWriteDestroyPathRequest2 = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    secret_mount_path: S.String.pipe(T.Label()),
+    path: S.String.pipe(T.Label()),
+    versions: S.optional(KvWriteDestroyPathRequestVersionsList2),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/{secret_mount_path}/destroy/{path}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "KvWriteDestroyPathRequest2",
+}) as any as S.Schema<KvWriteDestroyPathRequest2>;
+
+export interface KvWriteDestroyPath2Response {}
+export const KvWriteDestroyPath2Response = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "KvWriteDestroyPath2Response",
+}) as any as S.Schema<KvWriteDestroyPath2Response>;
+
+export interface KvWriteMetadataPathRequest {
+  /** Path that the backend was mounted at */
+  kv_mount_path: string;
+  /** Location of the secret. */
+  path: string;
+  /** Optional entry to list begin listing after, not required to exist. Only used for listing. */
+  after?: string;
+  /** If true the key will require the cas parameter to be set on all write requests. If false, the backend’s configuration will be used. */
+  cas_required?: boolean;
+  /** User-provided key-value pairs that are used to describe arbitrary and version-agnostic information about a secret. */
+  custom_metadata?: unknown;
+  /** The length of time before a version is deleted. If not set, the backend's configured delete_version_after is used. Cannot be greater than the backend's delete_version_after. A zero duration clears the current setting. A negative duration will cause an error. */
+  delete_version_after?: number;
+  /** Optional number of entries to return; defaults to all entries. Only used for listing. */
+  limit?: number;
+  /** The number of versions to keep. If not set, the backend’s configured max version is used. */
+  max_versions?: number;
+  /** Check-and-set parameter for metadata updates. Must match the current metadata version for the update to succeed. Set to 0 for initial metadata creation. */
+  metadata_cas?: number;
+  /** If true the key will require the cas parameter to be set on all metadata update requests. If false, the backend's configuration will be used. */
+  metadata_cas_required?: boolean;
+}
+export const KvWriteMetadataPathRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    kv_mount_path: S.String.pipe(T.Label()),
+    path: S.String.pipe(T.Label()),
+    after: S.optional(S.String),
+    cas_required: S.optional(S.Boolean),
+    custom_metadata: S.optional(S.Unknown),
+    delete_version_after: S.optional(S.Number),
+    limit: S.optional(S.Number),
+    max_versions: S.optional(S.Number),
+    metadata_cas: S.optional(S.Number),
+    metadata_cas_required: S.optional(S.Boolean),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/{kv_mount_path}/metadata/{path}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "KvWriteMetadataPathRequest",
+}) as any as S.Schema<KvWriteMetadataPathRequest>;
+
+export interface KvWriteMetadataPathResponse {}
+export const KvWriteMetadataPathResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "KvWriteMetadataPathResponse",
+}) as any as S.Schema<KvWriteMetadataPathResponse>;
+
+export interface KvWriteMetadataPathRequest2 {
+  /** Path that the backend was mounted at */
+  secret_mount_path: string;
+  /** Location of the secret. */
+  path: string;
+  /** Optional entry to list begin listing after, not required to exist. Only used for listing. */
+  after?: string;
+  /** If true the key will require the cas parameter to be set on all write requests. If false, the backend’s configuration will be used. */
+  cas_required?: boolean;
+  /** User-provided key-value pairs that are used to describe arbitrary and version-agnostic information about a secret. */
+  custom_metadata?: unknown;
+  /** The length of time before a version is deleted. If not set, the backend's configured delete_version_after is used. Cannot be greater than the backend's delete_version_after. A zero duration clears the current setting. A negative duration will cause an error. */
+  delete_version_after?: number;
+  /** Optional number of entries to return; defaults to all entries. Only used for listing. */
+  limit?: number;
+  /** The number of versions to keep. If not set, the backend’s configured max version is used. */
+  max_versions?: number;
+  /** Check-and-set parameter for metadata updates. Must match the current metadata version for the update to succeed. Set to 0 for initial metadata creation. */
+  metadata_cas?: number;
+  /** If true the key will require the cas parameter to be set on all metadata update requests. If false, the backend's configuration will be used. */
+  metadata_cas_required?: boolean;
+}
+export const KvWriteMetadataPathRequest2 = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    secret_mount_path: S.String.pipe(T.Label()),
+    path: S.String.pipe(T.Label()),
+    after: S.optional(S.String),
+    cas_required: S.optional(S.Boolean),
+    custom_metadata: S.optional(S.Unknown),
+    delete_version_after: S.optional(S.Number),
+    limit: S.optional(S.Number),
+    max_versions: S.optional(S.Number),
+    metadata_cas: S.optional(S.Number),
+    metadata_cas_required: S.optional(S.Boolean),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/{secret_mount_path}/metadata/{path}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "KvWriteMetadataPathRequest2",
+}) as any as S.Schema<KvWriteMetadataPathRequest2>;
+
+export interface KvWriteMetadataPath2Response {}
+export const KvWriteMetadataPath2Response = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "KvWriteMetadataPath2Response",
+}) as any as S.Schema<KvWriteMetadataPath2Response>;
+
+/** The versions to unarchive. The versions will be restored and their data will be returned on normal get requests. */
+export type KvWriteUndeletePathRequestVersionsList = Array<number>;
+export const KvWriteUndeletePathRequestVersionsList = /*@__PURE__*/ S.Array(
+  S.Number,
+) as any as S.Schema<KvWriteUndeletePathRequestVersionsList>;
+
+export interface KvWriteUndeletePathRequest {
+  /** Path that the backend was mounted at */
+  kv_mount_path: string;
+  /** Location of the secret. */
+  path: string;
+  /** The versions to unarchive. The versions will be restored and their data will be returned on normal get requests. */
+  versions?: KvWriteUndeletePathRequestVersionsList;
+}
+export const KvWriteUndeletePathRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    kv_mount_path: S.String.pipe(T.Label()),
+    path: S.String.pipe(T.Label()),
+    versions: S.optional(KvWriteUndeletePathRequestVersionsList),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/{kv_mount_path}/undelete/{path}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "KvWriteUndeletePathRequest",
+}) as any as S.Schema<KvWriteUndeletePathRequest>;
+
+export interface KvWriteUndeletePathResponse {}
+export const KvWriteUndeletePathResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "KvWriteUndeletePathResponse",
+}) as any as S.Schema<KvWriteUndeletePathResponse>;
+
+/** The versions to unarchive. The versions will be restored and their data will be returned on normal get requests. */
+export type KvWriteUndeletePathRequestVersionsList2 = Array<number>;
+export const KvWriteUndeletePathRequestVersionsList2 = /*@__PURE__*/ S.Array(
+  S.Number,
+) as any as S.Schema<KvWriteUndeletePathRequestVersionsList2>;
+
+export interface KvWriteUndeletePathRequest2 {
+  /** Path that the backend was mounted at */
+  secret_mount_path: string;
+  /** Location of the secret. */
+  path: string;
+  /** The versions to unarchive. The versions will be restored and their data will be returned on normal get requests. */
+  versions?: KvWriteUndeletePathRequestVersionsList2;
+}
+export const KvWriteUndeletePathRequest2 = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    secret_mount_path: S.String.pipe(T.Label()),
+    path: S.String.pipe(T.Label()),
+    versions: S.optional(KvWriteUndeletePathRequestVersionsList2),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/{secret_mount_path}/undelete/{path}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "KvWriteUndeletePathRequest2",
+}) as any as S.Schema<KvWriteUndeletePathRequest2>;
+
+export interface KvWriteUndeletePath2Response {}
+export const KvWriteUndeletePath2Response = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "KvWriteUndeletePath2Response",
+}) as any as S.Schema<KvWriteUndeletePath2Response>;
+
+export type KvDeleteDataPathError = OpenBaoOpError;
+export const kvDeleteDataPath: API.OperationMethod<
+  KvDeleteDataPathRequest,
+  KvDeleteDataPathResponse,
+  KvDeleteDataPathError,
+  OpenBaoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: KvDeleteDataPathRequest,
+  output: KvDeleteDataPathResponse,
+  errors: [],
+  protocol: OpenBaoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type KvDeleteDataPath2Error = OpenBaoOpError;
+export const kvDeleteDataPath2: API.OperationMethod<
+  KvDeleteDataPathRequest2,
+  KvDeleteDataPath2Response,
+  KvDeleteDataPath2Error,
+  OpenBaoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: KvDeleteDataPathRequest2,
+  output: KvDeleteDataPath2Response,
+  errors: [],
+  protocol: OpenBaoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type KvDeleteMetadataPathError = OpenBaoOpError;
+export const kvDeleteMetadataPath: API.OperationMethod<
+  KvDeleteMetadataPathRequest,
+  KvDeleteMetadataPathResponse,
+  KvDeleteMetadataPathError,
+  OpenBaoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: KvDeleteMetadataPathRequest,
+  output: KvDeleteMetadataPathResponse,
+  errors: [],
+  protocol: OpenBaoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type KvDeleteMetadataPath2Error = OpenBaoOpError;
+export const kvDeleteMetadataPath2: API.OperationMethod<
+  KvDeleteMetadataPathRequest2,
+  KvDeleteMetadataPath2Response,
+  KvDeleteMetadataPath2Error,
+  OpenBaoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: KvDeleteMetadataPathRequest2,
+  output: KvDeleteMetadataPath2Response,
+  errors: [],
+  protocol: OpenBaoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type KvPatchDataPathError = OpenBaoOpError;
+export const kvPatchDataPath: API.OperationMethod<
+  KvPatchDataPathRequest,
+  KvPatchDataPathResponse,
+  KvPatchDataPathError,
+  OpenBaoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: KvPatchDataPathRequest,
+  output: KvPatchDataPathResponse,
+  errors: [],
+  protocol: OpenBaoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type KvPatchDataPath2Error = OpenBaoOpError;
+export const kvPatchDataPath2: API.OperationMethod<
+  KvPatchDataPathRequest2,
+  KvPatchDataPath2Response,
+  KvPatchDataPath2Error,
+  OpenBaoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: KvPatchDataPathRequest2,
+  output: KvPatchDataPath2Response,
+  errors: [],
+  protocol: OpenBaoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type KvPatchMetadataPathError = OpenBaoOpError;
+export const kvPatchMetadataPath: API.OperationMethod<
+  KvPatchMetadataPathRequest,
+  KvPatchMetadataPathResponse,
+  KvPatchMetadataPathError,
+  OpenBaoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: KvPatchMetadataPathRequest,
+  output: KvPatchMetadataPathResponse,
+  errors: [],
+  protocol: OpenBaoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type KvPatchMetadataPath2Error = OpenBaoOpError;
+export const kvPatchMetadataPath2: API.OperationMethod<
+  KvPatchMetadataPathRequest2,
+  KvPatchMetadataPath2Response,
+  KvPatchMetadataPath2Error,
+  OpenBaoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: KvPatchMetadataPathRequest2,
+  output: KvPatchMetadataPath2Response,
+  errors: [],
+  protocol: OpenBaoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type KvReadConfigError = OpenBaoOpError;
+/** Read the backend level settings. */
+export const kvReadConfig: API.OperationMethod<
+  KvReadConfigRequest,
+  KvReadConfigResponse,
+  KvReadConfigError,
+  OpenBaoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: KvReadConfigRequest,
+  output: KvReadConfigResponse,
+  errors: [],
+  protocol: OpenBaoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type KvReadConfig2Error = OpenBaoOpError;
+/** Read the backend level settings. */
+export const kvReadConfig2: API.OperationMethod<
+  KvReadConfigRequest2,
+  KvReadConfig2Response,
+  KvReadConfig2Error,
+  OpenBaoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: KvReadConfigRequest2,
+  output: KvReadConfig2Response,
+  errors: [],
+  protocol: OpenBaoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type KvReadDataPathError = OpenBaoOpError;
+export const kvReadDataPath: API.OperationMethod<
+  KvReadDataPathRequest,
+  KvReadDataPathResponse,
+  KvReadDataPathError,
+  OpenBaoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: KvReadDataPathRequest,
+  output: KvReadDataPathResponse,
+  errors: [],
+  protocol: OpenBaoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type KvReadDataPath2Error = OpenBaoOpError;
+export const kvReadDataPath2: API.OperationMethod<
+  KvReadDataPathRequest2,
+  KvReadDataPath2Response,
+  KvReadDataPath2Error,
+  OpenBaoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: KvReadDataPathRequest2,
+  output: KvReadDataPath2Response,
+  errors: [],
+  protocol: OpenBaoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type KvReadMetadataPathError = OpenBaoOpError;
+export const kvReadMetadataPath: API.OperationMethod<
+  KvReadMetadataPathRequest,
+  KvReadMetadataPathResponse,
+  KvReadMetadataPathError,
+  OpenBaoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: KvReadMetadataPathRequest,
+  output: KvReadMetadataPathResponse,
+  errors: [],
+  protocol: OpenBaoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type KvReadMetadataPath2Error = OpenBaoOpError;
+export const kvReadMetadataPath2: API.OperationMethod<
+  KvReadMetadataPathRequest2,
+  KvReadMetadataPath2Response,
+  KvReadMetadataPath2Error,
+  OpenBaoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: KvReadMetadataPathRequest2,
+  output: KvReadMetadataPath2Response,
+  errors: [],
+  protocol: OpenBaoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type KvReadSubkeysPathError = OpenBaoOpError;
+export const kvReadSubkeysPath: API.OperationMethod<
+  KvReadSubkeysPathRequest,
+  KvReadSubkeysPathResponse,
+  KvReadSubkeysPathError,
+  OpenBaoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: KvReadSubkeysPathRequest,
+  output: KvReadSubkeysPathResponse,
+  errors: [],
+  protocol: OpenBaoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type KvReadSubkeysPath2Error = OpenBaoOpError;
+export const kvReadSubkeysPath2: API.OperationMethod<
+  KvReadSubkeysPathRequest2,
+  KvReadSubkeysPath2Response,
+  KvReadSubkeysPath2Error,
+  OpenBaoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: KvReadSubkeysPathRequest2,
+  output: KvReadSubkeysPath2Response,
+  errors: [],
+  protocol: OpenBaoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type KvScanDetailedMetadataPathError = OpenBaoOpError;
+export const kvScanDetailedMetadataPath: API.OperationMethod<
+  KvScanDetailedMetadataPathRequest,
+  KvScanDetailedMetadataPathResponse,
+  KvScanDetailedMetadataPathError,
+  OpenBaoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: KvScanDetailedMetadataPathRequest,
+  output: KvScanDetailedMetadataPathResponse,
+  errors: [],
+  protocol: OpenBaoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type KvScanDetailedMetadataPath2Error = OpenBaoOpError;
+export const kvScanDetailedMetadataPath2: API.OperationMethod<
+  KvScanDetailedMetadataPathRequest2,
+  KvScanDetailedMetadataPath2Response,
+  KvScanDetailedMetadataPath2Error,
+  OpenBaoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: KvScanDetailedMetadataPathRequest2,
+  output: KvScanDetailedMetadataPath2Response,
+  errors: [],
+  protocol: OpenBaoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type KvWriteConfigError = OpenBaoOpError;
+/** Configure backend level settings that are applied to every key in the key-value store. */
+export const kvWriteConfig: API.OperationMethod<
+  KvWriteConfigRequest,
+  KvWriteConfigResponse,
+  KvWriteConfigError,
+  OpenBaoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: KvWriteConfigRequest,
+  output: KvWriteConfigResponse,
+  errors: [],
+  protocol: OpenBaoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type KvWriteConfig2Error = OpenBaoOpError;
+/** Configure backend level settings that are applied to every key in the key-value store. */
+export const kvWriteConfig2: API.OperationMethod<
+  KvWriteConfigRequest2,
+  KvWriteConfig2Response,
+  KvWriteConfig2Error,
+  OpenBaoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: KvWriteConfigRequest2,
+  output: KvWriteConfig2Response,
+  errors: [],
+  protocol: OpenBaoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type KvWriteDataPathError = OpenBaoOpError;
+export const kvWriteDataPath: API.OperationMethod<
+  KvWriteDataPathRequest,
+  KvWriteDataPathResponse,
+  KvWriteDataPathError,
+  OpenBaoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: KvWriteDataPathRequest,
+  output: KvWriteDataPathResponse,
+  errors: [],
+  protocol: OpenBaoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type KvWriteDataPath2Error = OpenBaoOpError;
+export const kvWriteDataPath2: API.OperationMethod<
+  KvWriteDataPathRequest2,
+  KvWriteDataPath2Response,
+  KvWriteDataPath2Error,
+  OpenBaoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: KvWriteDataPathRequest2,
+  output: KvWriteDataPath2Response,
+  errors: [],
+  protocol: OpenBaoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type KvWriteDeletePathError = OpenBaoOpError;
+export const kvWriteDeletePath: API.OperationMethod<
+  KvWriteDeletePathRequest,
+  KvWriteDeletePathResponse,
+  KvWriteDeletePathError,
+  OpenBaoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: KvWriteDeletePathRequest,
+  output: KvWriteDeletePathResponse,
+  errors: [],
+  protocol: OpenBaoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type KvWriteDeletePath2Error = OpenBaoOpError;
+export const kvWriteDeletePath2: API.OperationMethod<
+  KvWriteDeletePathRequest2,
+  KvWriteDeletePath2Response,
+  KvWriteDeletePath2Error,
+  OpenBaoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: KvWriteDeletePathRequest2,
+  output: KvWriteDeletePath2Response,
+  errors: [],
+  protocol: OpenBaoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type KvWriteDestroyPathError = OpenBaoOpError;
+export const kvWriteDestroyPath: API.OperationMethod<
+  KvWriteDestroyPathRequest,
+  KvWriteDestroyPathResponse,
+  KvWriteDestroyPathError,
+  OpenBaoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: KvWriteDestroyPathRequest,
+  output: KvWriteDestroyPathResponse,
+  errors: [],
+  protocol: OpenBaoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type KvWriteDestroyPath2Error = OpenBaoOpError;
+export const kvWriteDestroyPath2: API.OperationMethod<
+  KvWriteDestroyPathRequest2,
+  KvWriteDestroyPath2Response,
+  KvWriteDestroyPath2Error,
+  OpenBaoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: KvWriteDestroyPathRequest2,
+  output: KvWriteDestroyPath2Response,
+  errors: [],
+  protocol: OpenBaoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type KvWriteMetadataPathError = OpenBaoOpError;
+export const kvWriteMetadataPath: API.OperationMethod<
+  KvWriteMetadataPathRequest,
+  KvWriteMetadataPathResponse,
+  KvWriteMetadataPathError,
+  OpenBaoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: KvWriteMetadataPathRequest,
+  output: KvWriteMetadataPathResponse,
+  errors: [],
+  protocol: OpenBaoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type KvWriteMetadataPath2Error = OpenBaoOpError;
+export const kvWriteMetadataPath2: API.OperationMethod<
+  KvWriteMetadataPathRequest2,
+  KvWriteMetadataPath2Response,
+  KvWriteMetadataPath2Error,
+  OpenBaoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: KvWriteMetadataPathRequest2,
+  output: KvWriteMetadataPath2Response,
+  errors: [],
+  protocol: OpenBaoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type KvWriteUndeletePathError = OpenBaoOpError;
+export const kvWriteUndeletePath: API.OperationMethod<
+  KvWriteUndeletePathRequest,
+  KvWriteUndeletePathResponse,
+  KvWriteUndeletePathError,
+  OpenBaoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: KvWriteUndeletePathRequest,
+  output: KvWriteUndeletePathResponse,
+  errors: [],
+  protocol: OpenBaoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type KvWriteUndeletePath2Error = OpenBaoOpError;
+export const kvWriteUndeletePath2: API.OperationMethod<
+  KvWriteUndeletePathRequest2,
+  KvWriteUndeletePath2Response,
+  KvWriteUndeletePath2Error,
+  OpenBaoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: KvWriteUndeletePathRequest2,
+  output: KvWriteUndeletePath2Response,
+  errors: [],
+  protocol: OpenBaoProtocol,
+  retry: Retry.Retry,
+}));