@homeflare/distilled-openbao 0.2.0

package/src/services/namespaces.ts

@@ -0,0 +1,707 @@
+// 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 DeleteNamespacesPathRequest {
+  /** Path of the namespace. */
+  path: string;
+}
+export const DeleteNamespacesPathRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    path: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({ method: "DELETE", uri: "/sys/namespaces/{path}", code: 200 }),
+  ),
+).annotate({
+  identifier: "DeleteNamespacesPathRequest",
+}) as any as S.Schema<DeleteNamespacesPathRequest>;
+
+export interface NamespacesDeleteNamespacesPathResponse {
+  /** Status of the deletion operation. */
+  status?: string;
+}
+export const NamespacesDeleteNamespacesPathResponse = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      status: S.optional(S.String),
+    }),
+).annotate({
+  identifier: "NamespacesDeleteNamespacesPathResponse",
+}) as any as S.Schema<NamespacesDeleteNamespacesPathResponse>;
+
+export interface LockNamespacesWriteNamespacesApiLockRequest {
+  /** Path of the namespace. */
+  path?: string;
+}
+export const LockNamespacesWriteNamespacesApiLockRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      path: S.optional(S.String),
+    }).pipe(
+      T.Http({
+        method: "POST",
+        uri: "/sys/namespaces/api-lock/lock",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "LockNamespacesWriteNamespacesApiLockRequest",
+  }) as any as S.Schema<LockNamespacesWriteNamespacesApiLockRequest>;
+
+export interface NamespacesWriteNamespacesApiLockLockResponse {
+  /** Unlock key required for unlocking the namespace. */
+  unlock_key?: string;
+}
+export const NamespacesWriteNamespacesApiLockLockResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      unlock_key: S.optional(S.String),
+    }),
+  ).annotate({
+    identifier: "NamespacesWriteNamespacesApiLockLockResponse",
+  }) as any as S.Schema<NamespacesWriteNamespacesApiLockLockResponse>;
+
+export interface NamespacesDeleteNamespacesPathDeleteSealedRequest {
+  /** Path of the namespace. */
+  path: string;
+}
+export const NamespacesDeleteNamespacesPathDeleteSealedRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      path: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "DELETE",
+        uri: "/sys/namespaces/{path}/delete-sealed",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "NamespacesDeleteNamespacesPathDeleteSealedRequest",
+  }) as any as S.Schema<NamespacesDeleteNamespacesPathDeleteSealedRequest>;
+
+export interface NamespacesDeleteNamespacesPathDeleteSealedResponse {
+  /** Status of the deletion operation. */
+  status?: string;
+}
+export const NamespacesDeleteNamespacesPathDeleteSealedResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      status: S.optional(S.String),
+    }),
+  ).annotate({
+    identifier: "NamespacesDeleteNamespacesPathDeleteSealedResponse",
+  }) as any as S.Schema<NamespacesDeleteNamespacesPathDeleteSealedResponse>;
+
+export interface NamespacesReadSealRequest {
+  /** Path of the namespace. */
+  path: string;
+}
+export const NamespacesReadSealRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    path: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/sys/namespaces/{path}/seal-status",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "NamespacesReadSealRequest",
+}) as any as S.Schema<NamespacesReadSealRequest>;
+
+export interface NamespacesReadSealResponse {
+  initialized?: boolean;
+  n?: number;
+  nonce?: string;
+  progress?: number;
+  sealed?: boolean;
+  t?: number;
+  type?: string;
+}
+export const NamespacesReadSealResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    initialized: S.optional(S.Boolean),
+    n: S.optional(S.Number),
+    nonce: S.optional(S.String),
+    progress: S.optional(S.Number),
+    sealed: S.optional(S.Boolean),
+    t: S.optional(S.Number),
+    type: S.optional(S.String),
+  }),
+).annotate({
+  identifier: "NamespacesReadSealResponse",
+}) as any as S.Schema<NamespacesReadSealResponse>;
+
+export type NamespacesScanNamespacesRequestList = "true";
+export const NamespacesScanNamespacesRequestList = S.String;
+
+export type NamespacesScanNamespacesRequestScan = "true";
+export const NamespacesScanNamespacesRequestScan = S.String;
+
+export interface NamespacesScanNamespacesRequest {
+  /** Must be set to `true` or else `scan` must be set to `true` */
+  list: NamespacesScanNamespacesRequestList | (string & {});
+  /** Must be set to `true` or else `list` must be set to `true` */
+  scan: NamespacesScanNamespacesRequestScan | (string & {});
+}
+export const NamespacesScanNamespacesRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    list: NamespacesScanNamespacesRequestList.pipe(T.Query()),
+    scan: NamespacesScanNamespacesRequestScan.pipe(T.Query()),
+  }).pipe(T.Http({ method: "GET", uri: "/sys/namespaces", code: 200 })),
+).annotate({
+  identifier: "NamespacesScanNamespacesRequest",
+}) as any as S.Schema<NamespacesScanNamespacesRequest>;
+
+/** List of namespace paths. */
+export type NamespacesScanNamespacesResponseKeysList = Array<string>;
+export const NamespacesScanNamespacesResponseKeysList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<NamespacesScanNamespacesResponseKeysList>;
+
+export interface NamespacesScanNamespacesResponse {
+  /** Map of namespace details by path. */
+  key_info?: unknown;
+  /** List of namespace paths. */
+  keys?: NamespacesScanNamespacesResponseKeysList;
+}
+export const NamespacesScanNamespacesResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    key_info: S.optional(S.Unknown),
+    keys: S.optional(NamespacesScanNamespacesResponseKeysList),
+  }),
+).annotate({
+  identifier: "NamespacesScanNamespacesResponse",
+}) as any as S.Schema<NamespacesScanNamespacesResponse>;
+
+export interface NamespacesUnsealRequest {
+  /** Path of the namespace. */
+  path: string;
+  /** Specifies a single namespace unseal key share. */
+  key?: string;
+  /** Specifies whether to reset an unseal process progress. */
+  reset?: boolean;
+}
+export const NamespacesUnsealRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    path: S.String.pipe(T.Label()),
+    key: S.optional(S.String),
+    reset: S.optional(S.Boolean),
+  }).pipe(
+    T.Http({ method: "POST", uri: "/sys/namespaces/{path}/unseal", code: 200 }),
+  ),
+).annotate({
+  identifier: "NamespacesUnsealRequest",
+}) as any as S.Schema<NamespacesUnsealRequest>;
+
+export interface NamespacesUnsealResponse {
+  initialized?: boolean;
+  n?: number;
+  nonce?: string;
+  progress?: number;
+  sealed?: boolean;
+  t?: number;
+  type?: string;
+}
+export const NamespacesUnsealResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    initialized: S.optional(S.Boolean),
+    n: S.optional(S.Number),
+    nonce: S.optional(S.String),
+    progress: S.optional(S.Number),
+    sealed: S.optional(S.Boolean),
+    t: S.optional(S.Number),
+    type: S.optional(S.String),
+  }),
+).annotate({
+  identifier: "NamespacesUnsealResponse",
+}) as any as S.Schema<NamespacesUnsealResponse>;
+
+export interface NamespacesWriteNamespacesApiLockLockPathRequest {
+  /** Path of the namespace. */
+  path: string;
+}
+export const NamespacesWriteNamespacesApiLockLockPathRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      path: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "POST",
+        uri: "/sys/namespaces/api-lock/lock/{path}",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "NamespacesWriteNamespacesApiLockLockPathRequest",
+  }) as any as S.Schema<NamespacesWriteNamespacesApiLockLockPathRequest>;
+
+export interface NamespacesWriteNamespacesApiLockLockPathResponse {
+  /** Unlock key required for unlocking the namespace. */
+  unlock_key?: string;
+}
+export const NamespacesWriteNamespacesApiLockLockPathResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      unlock_key: S.optional(S.String),
+    }),
+  ).annotate({
+    identifier: "NamespacesWriteNamespacesApiLockLockPathResponse",
+  }) as any as S.Schema<NamespacesWriteNamespacesApiLockLockPathResponse>;
+
+export interface NamespacesWriteNamespacesApiLockUnlockPathRequest {
+  /** Path of the namespace. */
+  path: string;
+  /** Unlock key required for unlocking the namespace */
+  unlock_key: string;
+}
+export const NamespacesWriteNamespacesApiLockUnlockPathRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      path: S.String.pipe(T.Label()),
+      unlock_key: S.String,
+    }).pipe(
+      T.Http({
+        method: "POST",
+        uri: "/sys/namespaces/api-lock/unlock/{path}",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "NamespacesWriteNamespacesApiLockUnlockPathRequest",
+  }) as any as S.Schema<NamespacesWriteNamespacesApiLockUnlockPathRequest>;
+
+export interface NamespacesWriteNamespacesApiLockUnlockPathResponse {}
+export const NamespacesWriteNamespacesApiLockUnlockPathResponse =
+  /*@__PURE__*/ S.suspend(() => S.Struct({})).annotate({
+    identifier: "NamespacesWriteNamespacesApiLockUnlockPathResponse",
+  }) as any as S.Schema<NamespacesWriteNamespacesApiLockUnlockPathResponse>;
+
+/** Specifies an array of PGP public keys used to encrypt the output unseal keys. */
+export type NamespacesWriteNamespacesPathRequestPgpKeysList = Array<string>;
+export const NamespacesWriteNamespacesPathRequestPgpKeysList =
+  /*@__PURE__*/ S.Array(
+    S.String,
+  ) as any as S.Schema<NamespacesWriteNamespacesPathRequestPgpKeysList>;
+
+export interface NamespacesWriteNamespacesPathRequest {
+  /** Path of the namespace. */
+  path: string;
+  /** User provided key-value pairs. */
+  custom_metadata?: unknown;
+  /** Specifies an array of PGP public keys used to encrypt the output unseal keys. */
+  pgp_keys?: NamespacesWriteNamespacesPathRequestPgpKeysList;
+  /** User provided seal config. */
+  seal?: string;
+}
+export const NamespacesWriteNamespacesPathRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      path: S.String.pipe(T.Label()),
+      custom_metadata: S.optional(S.Unknown),
+      pgp_keys: S.optional(NamespacesWriteNamespacesPathRequestPgpKeysList),
+      seal: S.optional(S.String),
+    }).pipe(
+      T.Http({ method: "POST", uri: "/sys/namespaces/{path}", code: 200 }),
+    ),
+).annotate({
+  identifier: "NamespacesWriteNamespacesPathRequest",
+}) as any as S.Schema<NamespacesWriteNamespacesPathRequest>;
+
+export interface NamespacesWriteNamespacesPathResponse {
+  /** User provided key-value pairs. */
+  custom_metadata?: unknown;
+  /** Accessor ID of the namespace. */
+  id?: string;
+  /** Key shares used to combine into unseal/recovery key of the namespace. */
+  key_shares?: unknown;
+  /** Number of keys required to reconstruct unseal/recovery key of the namespace. */
+  key_threshold?: number;
+  /** Flag representing the lock status of the namespace. */
+  locked?: boolean;
+  /** Path of the namespace. */
+  path?: string;
+  /** Flag representing the taint status of the namespace. */
+  tainted?: boolean;
+  /** Internal UUID of the namespace. */
+  uuid?: string;
+}
+export const NamespacesWriteNamespacesPathResponse = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      custom_metadata: S.optional(S.Unknown),
+      id: S.optional(S.String),
+      key_shares: S.optional(S.Unknown),
+      key_threshold: S.optional(S.Number),
+      locked: S.optional(S.Boolean),
+      path: S.optional(S.String),
+      tainted: S.optional(S.Boolean),
+      uuid: S.optional(S.String),
+    }),
+).annotate({
+  identifier: "NamespacesWriteNamespacesPathResponse",
+}) as any as S.Schema<NamespacesWriteNamespacesPathResponse>;
+
+/** Specifies an array of PGP public keys used to encrypt the output unseal keys. */
+export type PatchNamespacesPathRequestPgpKeysList = Array<string>;
+export const PatchNamespacesPathRequestPgpKeysList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<PatchNamespacesPathRequestPgpKeysList>;
+
+export interface PatchNamespacesPathRequest {
+  /** Path of the namespace. */
+  path: string;
+  /** User provided key-value pairs. */
+  custom_metadata?: unknown;
+  /** Specifies an array of PGP public keys used to encrypt the output unseal keys. */
+  pgp_keys?: PatchNamespacesPathRequestPgpKeysList;
+  /** User provided seal config. */
+  seal?: string;
+}
+export const PatchNamespacesPathRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    path: S.String.pipe(T.Label()),
+    custom_metadata: S.optional(S.Unknown),
+    pgp_keys: S.optional(PatchNamespacesPathRequestPgpKeysList),
+    seal: S.optional(S.String),
+  }).pipe(
+    T.Http({ method: "PATCH", uri: "/sys/namespaces/{path}", code: 200 }),
+  ),
+).annotate({
+  identifier: "PatchNamespacesPathRequest",
+}) as any as S.Schema<PatchNamespacesPathRequest>;
+
+export interface NamespacesPatchNamespacesPathResponse {
+  /** User provided key-value pairs. */
+  custom_metadata?: unknown;
+  /** Accessor ID of the namespace. */
+  id?: string;
+  /** Key shares used to combine into unseal/recovery key of the namespace. */
+  key_shares?: unknown;
+  /** Number of keys required to reconstruct unseal/recovery key of the namespace. */
+  key_threshold?: number;
+  /** Flag representing the lock status of the namespace. */
+  locked?: boolean;
+  /** Path of the namespace. */
+  path?: string;
+  /** Flag representing the taint status of the namespace. */
+  tainted?: boolean;
+  /** Internal UUID of the namespace. */
+  uuid?: string;
+}
+export const NamespacesPatchNamespacesPathResponse = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      custom_metadata: S.optional(S.Unknown),
+      id: S.optional(S.String),
+      key_shares: S.optional(S.Unknown),
+      key_threshold: S.optional(S.Number),
+      locked: S.optional(S.Boolean),
+      path: S.optional(S.String),
+      tainted: S.optional(S.Boolean),
+      uuid: S.optional(S.String),
+    }),
+).annotate({
+  identifier: "NamespacesPatchNamespacesPathResponse",
+}) as any as S.Schema<NamespacesPatchNamespacesPathResponse>;
+
+export interface ReadNamespacesPathRequest {
+  /** Path of the namespace. */
+  path: string;
+}
+export const ReadNamespacesPathRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    path: S.String.pipe(T.Label()),
+  }).pipe(T.Http({ method: "GET", uri: "/sys/namespaces/{path}", code: 200 })),
+).annotate({
+  identifier: "ReadNamespacesPathRequest",
+}) as any as S.Schema<ReadNamespacesPathRequest>;
+
+export interface NamespacesReadNamespacesPathResponse {
+  /** User provided key-value pairs. */
+  custom_metadata?: unknown;
+  /** Accessor ID of the namespace. */
+  id?: string;
+  /** Key shares used to combine into unseal/recovery key of the namespace. */
+  key_shares?: unknown;
+  /** Number of keys required to reconstruct unseal/recovery key of the namespace. */
+  key_threshold?: number;
+  /** Flag representing the lock status of the namespace. */
+  locked?: boolean;
+  /** Path of the namespace. */
+  path?: string;
+  /** Flag representing the taint status of the namespace. */
+  tainted?: boolean;
+  /** Internal UUID of the namespace. */
+  uuid?: string;
+}
+export const NamespacesReadNamespacesPathResponse = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      custom_metadata: S.optional(S.Unknown),
+      id: S.optional(S.String),
+      key_shares: S.optional(S.Unknown),
+      key_threshold: S.optional(S.Number),
+      locked: S.optional(S.Boolean),
+      path: S.optional(S.String),
+      tainted: S.optional(S.Boolean),
+      uuid: S.optional(S.String),
+    }),
+).annotate({
+  identifier: "NamespacesReadNamespacesPathResponse",
+}) as any as S.Schema<NamespacesReadNamespacesPathResponse>;
+
+export interface SealNamespaceRequest {
+  /** Path of the namespace. */
+  path: string;
+}
+export const SealNamespaceRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    path: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({ method: "POST", uri: "/sys/namespaces/{path}/seal", code: 200 }),
+  ),
+).annotate({
+  identifier: "SealNamespaceRequest",
+}) as any as S.Schema<SealNamespaceRequest>;
+
+export interface SealNamespaceResponse {}
+export const SealNamespaceResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "SealNamespaceResponse",
+}) as any as S.Schema<SealNamespaceResponse>;
+
+export interface UnlockNamespacesWriteNamespacesApiLockRequest {
+  /** Path of the namespace. */
+  path?: string;
+  /** Unlock key required for unlocking the namespace */
+  unlock_key: string;
+}
+export const UnlockNamespacesWriteNamespacesApiLockRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      path: S.optional(S.String),
+      unlock_key: S.String,
+    }).pipe(
+      T.Http({
+        method: "POST",
+        uri: "/sys/namespaces/api-lock/unlock",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "UnlockNamespacesWriteNamespacesApiLockRequest",
+  }) as any as S.Schema<UnlockNamespacesWriteNamespacesApiLockRequest>;
+
+export interface UnlockNamespacesWriteNamespacesApiLockResponse {}
+export const UnlockNamespacesWriteNamespacesApiLockResponse =
+  /*@__PURE__*/ S.suspend(() => S.Struct({})).annotate({
+    identifier: "UnlockNamespacesWriteNamespacesApiLockResponse",
+  }) as any as S.Schema<UnlockNamespacesWriteNamespacesApiLockResponse>;
+
+export type DeleteNamespacesPathError = OpenBaoOpError;
+/** Delete a namespace. */
+export const deleteNamespacesPath: API.OperationMethod<
+  DeleteNamespacesPathRequest,
+  NamespacesDeleteNamespacesPathResponse,
+  DeleteNamespacesPathError,
+  OpenBaoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteNamespacesPathRequest,
+  output: NamespacesDeleteNamespacesPathResponse,
+  errors: [],
+  protocol: OpenBaoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type LockNamespacesWriteNamespacesApiLockError = OpenBaoOpError;
+/** Lock a namespace. */
+export const lockNamespacesWriteNamespacesApiLock: API.OperationMethod<
+  LockNamespacesWriteNamespacesApiLockRequest,
+  NamespacesWriteNamespacesApiLockLockResponse,
+  LockNamespacesWriteNamespacesApiLockError,
+  OpenBaoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: LockNamespacesWriteNamespacesApiLockRequest,
+  output: NamespacesWriteNamespacesApiLockLockResponse,
+  errors: [],
+  protocol: OpenBaoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type NamespacesDeleteNamespacesPathDeleteSealedError = OpenBaoOpError;
+/** Delete a sealed namespace by wiping its physical storage. */
+export const namespacesDeleteNamespacesPathDeleteSealed: API.OperationMethod<
+  NamespacesDeleteNamespacesPathDeleteSealedRequest,
+  NamespacesDeleteNamespacesPathDeleteSealedResponse,
+  NamespacesDeleteNamespacesPathDeleteSealedError,
+  OpenBaoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: NamespacesDeleteNamespacesPathDeleteSealedRequest,
+  output: NamespacesDeleteNamespacesPathDeleteSealedResponse,
+  errors: [],
+  protocol: OpenBaoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type NamespacesReadSealError = OpenBaoOpError;
+/** Check the seal status of an OpenBao namespace. */
+export const namespacesReadSeal: API.OperationMethod<
+  NamespacesReadSealRequest,
+  NamespacesReadSealResponse,
+  NamespacesReadSealError,
+  OpenBaoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: NamespacesReadSealRequest,
+  output: NamespacesReadSealResponse,
+  errors: [],
+  protocol: OpenBaoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type NamespacesScanNamespacesError = OpenBaoOpError;
+/** Scan (recursively list) namespaces. */
+export const namespacesScanNamespaces: API.OperationMethod<
+  NamespacesScanNamespacesRequest,
+  NamespacesScanNamespacesResponse,
+  NamespacesScanNamespacesError,
+  OpenBaoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: NamespacesScanNamespacesRequest,
+  output: NamespacesScanNamespacesResponse,
+  errors: [],
+  protocol: OpenBaoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type NamespacesUnsealError = OpenBaoOpError;
+/** Unseal a namespace. */
+export const namespacesUnseal: API.OperationMethod<
+  NamespacesUnsealRequest,
+  NamespacesUnsealResponse,
+  NamespacesUnsealError,
+  OpenBaoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: NamespacesUnsealRequest,
+  output: NamespacesUnsealResponse,
+  errors: [],
+  protocol: OpenBaoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type NamespacesWriteNamespacesApiLockLockPathError = OpenBaoOpError;
+/** Lock a namespace. */
+export const namespacesWriteNamespacesApiLockLockPath: API.OperationMethod<
+  NamespacesWriteNamespacesApiLockLockPathRequest,
+  NamespacesWriteNamespacesApiLockLockPathResponse,
+  NamespacesWriteNamespacesApiLockLockPathError,
+  OpenBaoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: NamespacesWriteNamespacesApiLockLockPathRequest,
+  output: NamespacesWriteNamespacesApiLockLockPathResponse,
+  errors: [],
+  protocol: OpenBaoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type NamespacesWriteNamespacesApiLockUnlockPathError = OpenBaoOpError;
+/** Unlock a namespace. */
+export const namespacesWriteNamespacesApiLockUnlockPath: API.OperationMethod<
+  NamespacesWriteNamespacesApiLockUnlockPathRequest,
+  NamespacesWriteNamespacesApiLockUnlockPathResponse,
+  NamespacesWriteNamespacesApiLockUnlockPathError,
+  OpenBaoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: NamespacesWriteNamespacesApiLockUnlockPathRequest,
+  output: NamespacesWriteNamespacesApiLockUnlockPathResponse,
+  errors: [],
+  protocol: OpenBaoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type NamespacesWriteNamespacesPathError = OpenBaoOpError;
+/** Create or update a namespace. */
+export const namespacesWriteNamespacesPath: API.OperationMethod<
+  NamespacesWriteNamespacesPathRequest,
+  NamespacesWriteNamespacesPathResponse,
+  NamespacesWriteNamespacesPathError,
+  OpenBaoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: NamespacesWriteNamespacesPathRequest,
+  output: NamespacesWriteNamespacesPathResponse,
+  errors: [],
+  protocol: OpenBaoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type PatchNamespacesPathError = OpenBaoOpError;
+/** Update a namespace's custom metadata. */
+export const patchNamespacesPath: API.OperationMethod<
+  PatchNamespacesPathRequest,
+  NamespacesPatchNamespacesPathResponse,
+  PatchNamespacesPathError,
+  OpenBaoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PatchNamespacesPathRequest,
+  output: NamespacesPatchNamespacesPathResponse,
+  errors: [],
+  protocol: OpenBaoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ReadNamespacesPathError = OpenBaoOpError;
+/** Retrieve a namespace. */
+export const readNamespacesPath: API.OperationMethod<
+  ReadNamespacesPathRequest,
+  NamespacesReadNamespacesPathResponse,
+  ReadNamespacesPathError,
+  OpenBaoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ReadNamespacesPathRequest,
+  output: NamespacesReadNamespacesPathResponse,
+  errors: [],
+  protocol: OpenBaoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type SealNamespaceError = OpenBaoOpError;
+/** Seal a namespace. */
+export const sealNamespace: API.OperationMethod<
+  SealNamespaceRequest,
+  SealNamespaceResponse,
+  SealNamespaceError,
+  OpenBaoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: SealNamespaceRequest,
+  output: SealNamespaceResponse,
+  errors: [],
+  protocol: OpenBaoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type UnlockNamespacesWriteNamespacesApiLockError = OpenBaoOpError;
+/** Unlock a namespace. */
+export const unlockNamespacesWriteNamespacesApiLock: API.OperationMethod<
+  UnlockNamespacesWriteNamespacesApiLockRequest,
+  UnlockNamespacesWriteNamespacesApiLockResponse,
+  UnlockNamespacesWriteNamespacesApiLockError,
+  OpenBaoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: UnlockNamespacesWriteNamespacesApiLockRequest,
+  output: UnlockNamespacesWriteNamespacesApiLockResponse,
+  errors: [],
+  protocol: OpenBaoProtocol,
+  retry: Retry.Retry,
+}));