@homeflare/distilled-proxmox-backup 0.2.0

package/src/services/admin.ts

@@ -0,0 +1,3258 @@
+// AUTO-GENERATED by scripts/generate.ts from .generated-specs (apidoc.js, via scripts/apidoc.ts — see its header). 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 {
+  ProxmoxBackupProtocol,
+  type ProxmoxBackupOpError,
+  type ProxmoxBackupOpContext,
+} from "../protocol.ts";
+import * as Retry from "../retry.ts";
+
+export type { ProxmoxBackupOpError, ProxmoxBackupOpContext };
+
+export type CreateAdminDatastoreChangeOwnerRequestBackupType =
+  | "vm"
+  | "ct"
+  | "host";
+export const CreateAdminDatastoreChangeOwnerRequestBackupType = S.String;
+
+export interface CreateAdminDatastoreChangeOwnerRequest {
+  store: string;
+  /** Backup ID. */
+  backup_id: string;
+  /** Backup types. */
+  backup_type: CreateAdminDatastoreChangeOwnerRequestBackupType | (string & {});
+  /** Authentication ID */
+  new_owner: string;
+  /** Namespace. */
+  ns?: string;
+}
+export const CreateAdminDatastoreChangeOwnerRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      store: S.String.pipe(T.Label()),
+      backup_id: S.String.pipe(T.Body("backup-id")),
+      backup_type: CreateAdminDatastoreChangeOwnerRequestBackupType.pipe(
+        T.Body("backup-type"),
+      ),
+      new_owner: S.String.pipe(T.Body("new-owner")),
+      ns: S.optional(S.String),
+    }).pipe(
+      T.Http({
+        method: "POST",
+        uri: "/admin/datastore/{store}/change-owner",
+        code: 200,
+        contentType: "form-urlencoded",
+      }),
+    ),
+).annotate({
+  identifier: "CreateAdminDatastoreChangeOwnerRequest",
+}) as any as S.Schema<CreateAdminDatastoreChangeOwnerRequest>;
+
+export interface CreateAdminDatastoreChangeOwnerResponse {}
+export const CreateAdminDatastoreChangeOwnerResponse = /*@__PURE__*/ S.suspend(
+  () => S.Struct({}),
+).annotate({
+  identifier: "CreateAdminDatastoreChangeOwnerResponse",
+}) as any as S.Schema<CreateAdminDatastoreChangeOwnerResponse>;
+
+export interface CreateAdminDatastoreGcRequest {
+  store: string;
+}
+export const CreateAdminDatastoreGcRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    store: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({ method: "POST", uri: "/admin/datastore/{store}/gc", code: 200 }),
+  ),
+).annotate({
+  identifier: "CreateAdminDatastoreGcRequest",
+}) as any as S.Schema<CreateAdminDatastoreGcRequest>;
+
+export type CreateAdminDatastoreGcResponse = string;
+export const CreateAdminDatastoreGcResponse = /*@__PURE__*/ S.suspend(() =>
+  S.String.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "CreateAdminDatastoreGcResponse",
+}) as any as S.Schema<CreateAdminDatastoreGcResponse>;
+
+export interface CreateAdminDatastoreMountRequest {
+  store: string;
+}
+export const CreateAdminDatastoreMountRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    store: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/admin/datastore/{store}/mount",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "CreateAdminDatastoreMountRequest",
+}) as any as S.Schema<CreateAdminDatastoreMountRequest>;
+
+export type CreateAdminDatastoreMountResponse = string;
+export const CreateAdminDatastoreMountResponse = /*@__PURE__*/ S.suspend(() =>
+  S.String.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "CreateAdminDatastoreMountResponse",
+}) as any as S.Schema<CreateAdminDatastoreMountResponse>;
+
+export interface CreateAdminDatastoreNamespaceRequest {
+  store: string;
+  /** The name of the new namespace to add at the parent. */
+  name: string;
+  /** Namespace. */
+  parent?: string;
+}
+export const CreateAdminDatastoreNamespaceRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      store: S.String.pipe(T.Label()),
+      name: S.String,
+      parent: S.optional(S.String),
+    }).pipe(
+      T.Http({
+        method: "POST",
+        uri: "/admin/datastore/{store}/namespace",
+        code: 200,
+        contentType: "form-urlencoded",
+      }),
+    ),
+).annotate({
+  identifier: "CreateAdminDatastoreNamespaceRequest",
+}) as any as S.Schema<CreateAdminDatastoreNamespaceRequest>;
+
+export type CreateAdminDatastoreNamespaceResponse = string;
+export const CreateAdminDatastoreNamespaceResponse = /*@__PURE__*/ S.suspend(
+  () => S.String.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "CreateAdminDatastoreNamespaceResponse",
+}) as any as S.Schema<CreateAdminDatastoreNamespaceResponse>;
+
+export type CreateAdminDatastorePruneRequestBackupType = "vm" | "ct" | "host";
+export const CreateAdminDatastorePruneRequestBackupType = S.String;
+
+export interface CreateAdminDatastorePruneRequest {
+  store: string;
+  /** Backup ID. */
+  backup_id: string;
+  /** Backup types. */
+  backup_type: CreateAdminDatastorePruneRequestBackupType | (string & {});
+  /** Just show what prune would do, but do not delete anything. */
+  dry_run?: string;
+  /** Number of daily backups to keep. */
+  keep_daily?: string;
+  /** Number of hourly backups to keep. */
+  keep_hourly?: string;
+  /** Number of backups to keep. */
+  keep_last?: string;
+  /** Number of monthly backups to keep. */
+  keep_monthly?: string;
+  /** Number of weekly backups to keep. */
+  keep_weekly?: string;
+  /** Number of yearly backups to keep. */
+  keep_yearly?: string;
+  /** Namespace. */
+  ns?: string;
+  /** Spins up an asynchronous task that does the work. */
+  use_task?: string;
+}
+export const CreateAdminDatastorePruneRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    store: S.String.pipe(T.Label()),
+    backup_id: S.String.pipe(T.Body("backup-id")),
+    backup_type: CreateAdminDatastorePruneRequestBackupType.pipe(
+      T.Body("backup-type"),
+    ),
+    dry_run: S.optional(S.String.pipe(T.Body("dry-run"))),
+    keep_daily: S.optional(S.String.pipe(T.Body("keep-daily"))),
+    keep_hourly: S.optional(S.String.pipe(T.Body("keep-hourly"))),
+    keep_last: S.optional(S.String.pipe(T.Body("keep-last"))),
+    keep_monthly: S.optional(S.String.pipe(T.Body("keep-monthly"))),
+    keep_weekly: S.optional(S.String.pipe(T.Body("keep-weekly"))),
+    keep_yearly: S.optional(S.String.pipe(T.Body("keep-yearly"))),
+    ns: S.optional(S.String),
+    use_task: S.optional(S.String.pipe(T.Body("use-task"))),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/admin/datastore/{store}/prune",
+      code: 200,
+      contentType: "form-urlencoded",
+    }),
+  ),
+).annotate({
+  identifier: "CreateAdminDatastorePruneRequest",
+}) as any as S.Schema<CreateAdminDatastorePruneRequest>;
+
+export type CreateAdminDatastorePruneResponseBodyItemBackupType =
+  | "vm"
+  | "ct"
+  | "host";
+export const CreateAdminDatastorePruneResponseBodyItemBackupType = S.String;
+
+export interface CreateAdminDatastorePruneResponseBodyItem {
+  backup_id?: string;
+  backup_time?: number;
+  backup_type?: CreateAdminDatastorePruneResponseBodyItemBackupType;
+  keep: unknown;
+}
+export const CreateAdminDatastorePruneResponseBodyItem =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      backup_id: S.optional(S.String.pipe(T.Body("backup-id"))),
+      backup_time: S.optional(S.Number.pipe(T.Body("backup-time"))),
+      backup_type: S.optional(
+        CreateAdminDatastorePruneResponseBodyItemBackupType.pipe(
+          T.Body("backup-type"),
+        ),
+      ),
+      keep: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "CreateAdminDatastorePruneResponseBodyItem",
+  }) as any as S.Schema<CreateAdminDatastorePruneResponseBodyItem>;
+
+export type CreateAdminDatastorePruneResponseBodyList =
+  Array<CreateAdminDatastorePruneResponseBodyItem>;
+export const CreateAdminDatastorePruneResponseBodyList = /*@__PURE__*/ S.Array(
+  CreateAdminDatastorePruneResponseBodyItem,
+) as any as S.Schema<CreateAdminDatastorePruneResponseBodyList>;
+
+export type CreateAdminDatastorePruneResponse =
+  CreateAdminDatastorePruneResponseBodyList;
+export const CreateAdminDatastorePruneResponse = /*@__PURE__*/ S.suspend(() =>
+  CreateAdminDatastorePruneResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "CreateAdminDatastorePruneResponse",
+}) as any as S.Schema<CreateAdminDatastorePruneResponse>;
+
+export interface CreateAdminDatastorePruneDatastoreRequest {
+  store: string;
+  /** Just show what prune would do, but do not delete anything. */
+  dry_run?: string;
+  /** Number of daily backups to keep. */
+  keep_daily?: string;
+  /** Number of hourly backups to keep. */
+  keep_hourly?: string;
+  /** Number of backups to keep. */
+  keep_last?: string;
+  /** Number of monthly backups to keep. */
+  keep_monthly?: string;
+  /** Number of weekly backups to keep. */
+  keep_weekly?: string;
+  /** Number of yearly backups to keep. */
+  keep_yearly?: string;
+  /** How many levels of namespaces should be operated on (0 == no recursion, empty == automatic full recursion, namespace depths reduce maximum allowed value) */
+  max_depth?: string;
+  /** Namespace. */
+  ns?: string;
+}
+export const CreateAdminDatastorePruneDatastoreRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      store: S.String.pipe(T.Label()),
+      dry_run: S.optional(S.String.pipe(T.Body("dry-run"))),
+      keep_daily: S.optional(S.String.pipe(T.Body("keep-daily"))),
+      keep_hourly: S.optional(S.String.pipe(T.Body("keep-hourly"))),
+      keep_last: S.optional(S.String.pipe(T.Body("keep-last"))),
+      keep_monthly: S.optional(S.String.pipe(T.Body("keep-monthly"))),
+      keep_weekly: S.optional(S.String.pipe(T.Body("keep-weekly"))),
+      keep_yearly: S.optional(S.String.pipe(T.Body("keep-yearly"))),
+      max_depth: S.optional(S.String.pipe(T.Body("max-depth"))),
+      ns: S.optional(S.String),
+    }).pipe(
+      T.Http({
+        method: "POST",
+        uri: "/admin/datastore/{store}/prune-datastore",
+        code: 200,
+        contentType: "form-urlencoded",
+      }),
+    ),
+  ).annotate({
+    identifier: "CreateAdminDatastorePruneDatastoreRequest",
+  }) as any as S.Schema<CreateAdminDatastorePruneDatastoreRequest>;
+
+export type CreateAdminDatastorePruneDatastoreResponse = string;
+export const CreateAdminDatastorePruneDatastoreResponse =
+  /*@__PURE__*/ S.suspend(() => S.String.pipe(T.RawResponseRoot())).annotate({
+    identifier: "CreateAdminDatastorePruneDatastoreResponse",
+  }) as any as S.Schema<CreateAdminDatastorePruneDatastoreResponse>;
+
+export interface CreateAdminDatastoreUnmountRequest {
+  store: string;
+}
+export const CreateAdminDatastoreUnmountRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    store: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/admin/datastore/{store}/unmount",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "CreateAdminDatastoreUnmountRequest",
+}) as any as S.Schema<CreateAdminDatastoreUnmountRequest>;
+
+export type CreateAdminDatastoreUnmountResponse = string;
+export const CreateAdminDatastoreUnmountResponse = /*@__PURE__*/ S.suspend(() =>
+  S.String.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "CreateAdminDatastoreUnmountResponse",
+}) as any as S.Schema<CreateAdminDatastoreUnmountResponse>;
+
+export type DeleteAdminDatastoreGroupsRequestBackupType = "vm" | "ct" | "host";
+export const DeleteAdminDatastoreGroupsRequestBackupType = S.String;
+
+export interface DeleteAdminDatastoreGroupsRequest {
+  store: string;
+  /** Backup ID. */
+  backup_id: string;
+  /** Backup types. */
+  backup_type: DeleteAdminDatastoreGroupsRequestBackupType | (string & {});
+  /** Return error when group cannot be deleted because of protected snapshots */
+  error_on_protected?: string;
+  /** Namespace. */
+  ns?: string;
+}
+export const DeleteAdminDatastoreGroupsRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    store: S.String.pipe(T.Label()),
+    backup_id: S.String.pipe(T.Body("backup-id")),
+    backup_type: DeleteAdminDatastoreGroupsRequestBackupType.pipe(
+      T.Body("backup-type"),
+    ),
+    error_on_protected: S.optional(S.String.pipe(T.Body("error-on-protected"))),
+    ns: S.optional(S.String),
+  }).pipe(
+    T.Http({
+      method: "DELETE",
+      uri: "/admin/datastore/{store}/groups",
+      code: 200,
+      contentType: "form-urlencoded",
+    }),
+  ),
+).annotate({
+  identifier: "DeleteAdminDatastoreGroupsRequest",
+}) as any as S.Schema<DeleteAdminDatastoreGroupsRequest>;
+
+export interface DeleteAdminDatastoreGroupsResponse {
+  protected_snapshots?: number;
+  removed_groups?: number;
+  removed_snapshots?: number;
+}
+export const DeleteAdminDatastoreGroupsResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    protected_snapshots: S.optional(
+      S.Number.pipe(T.Body("protected-snapshots")),
+    ),
+    removed_groups: S.optional(S.Number.pipe(T.Body("removed-groups"))),
+    removed_snapshots: S.optional(S.Number.pipe(T.Body("removed-snapshots"))),
+  }),
+).annotate({
+  identifier: "DeleteAdminDatastoreGroupsResponse",
+}) as any as S.Schema<DeleteAdminDatastoreGroupsResponse>;
+
+export interface DeleteAdminDatastoreNamespaceRequest {
+  store: string;
+  /** If set, all groups will be destroyed in the whole hierarchy below andincluding `ns`. If not set, only empty namespaces will be pruned. */
+  delete_groups?: string;
+  /** Return error when namespace cannot be deleted because of protected snapshots */
+  error_on_protected?: string;
+  /** Namespace. */
+  ns: string;
+}
+export const DeleteAdminDatastoreNamespaceRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      store: S.String.pipe(T.Label()),
+      delete_groups: S.optional(S.String.pipe(T.Body("delete-groups"))),
+      error_on_protected: S.optional(
+        S.String.pipe(T.Body("error-on-protected")),
+      ),
+      ns: S.String,
+    }).pipe(
+      T.Http({
+        method: "DELETE",
+        uri: "/admin/datastore/{store}/namespace",
+        code: 200,
+        contentType: "form-urlencoded",
+      }),
+    ),
+).annotate({
+  identifier: "DeleteAdminDatastoreNamespaceRequest",
+}) as any as S.Schema<DeleteAdminDatastoreNamespaceRequest>;
+
+export interface DeleteAdminDatastoreNamespaceResponse {}
+export const DeleteAdminDatastoreNamespaceResponse = /*@__PURE__*/ S.suspend(
+  () => S.Struct({}),
+).annotate({
+  identifier: "DeleteAdminDatastoreNamespaceResponse",
+}) as any as S.Schema<DeleteAdminDatastoreNamespaceResponse>;
+
+export type DeleteAdminDatastoreSnapshotsRequestBackupType =
+  | "vm"
+  | "ct"
+  | "host";
+export const DeleteAdminDatastoreSnapshotsRequestBackupType = S.String;
+
+export interface DeleteAdminDatastoreSnapshotsRequest {
+  store: string;
+  /** Backup ID. */
+  backup_id: string;
+  /** Backup time (Unix epoch.) */
+  backup_time: string;
+  /** Backup types. */
+  backup_type: DeleteAdminDatastoreSnapshotsRequestBackupType | (string & {});
+  /** Namespace. */
+  ns?: string;
+}
+export const DeleteAdminDatastoreSnapshotsRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      store: S.String.pipe(T.Label()),
+      backup_id: S.String.pipe(T.Body("backup-id")),
+      backup_time: S.String.pipe(T.Body("backup-time")),
+      backup_type: DeleteAdminDatastoreSnapshotsRequestBackupType.pipe(
+        T.Body("backup-type"),
+      ),
+      ns: S.optional(S.String),
+    }).pipe(
+      T.Http({
+        method: "DELETE",
+        uri: "/admin/datastore/{store}/snapshots",
+        code: 200,
+        contentType: "form-urlencoded",
+      }),
+    ),
+).annotate({
+  identifier: "DeleteAdminDatastoreSnapshotsRequest",
+}) as any as S.Schema<DeleteAdminDatastoreSnapshotsRequest>;
+
+export interface DeleteAdminDatastoreSnapshotsResponse {}
+export const DeleteAdminDatastoreSnapshotsResponse = /*@__PURE__*/ S.suspend(
+  () => S.Struct({}),
+).annotate({
+  identifier: "DeleteAdminDatastoreSnapshotsResponse",
+}) as any as S.Schema<DeleteAdminDatastoreSnapshotsResponse>;
+
+export interface GetAdminRequest {}
+export const GetAdminRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}).pipe(T.Http({ method: "GET", uri: "/admin", code: 200 })),
+).annotate({
+  identifier: "GetAdminRequest",
+}) as any as S.Schema<GetAdminRequest>;
+
+export interface GetAdminResponse {}
+export const GetAdminResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "GetAdminResponse",
+}) as any as S.Schema<GetAdminResponse>;
+
+export interface GetAdminDatastoreRequest {
+  store: string;
+}
+export const GetAdminDatastoreRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    store: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({ method: "GET", uri: "/admin/datastore/{store}", code: 200 }),
+  ),
+).annotate({
+  identifier: "GetAdminDatastoreRequest",
+}) as any as S.Schema<GetAdminDatastoreRequest>;
+
+export interface GetAdminDatastoreResponse {}
+export const GetAdminDatastoreResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "GetAdminDatastoreResponse",
+}) as any as S.Schema<GetAdminDatastoreResponse>;
+
+export interface GetAdminDatastoreActiveOperationsRequest {
+  store: string;
+}
+export const GetAdminDatastoreActiveOperationsRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      store: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "GET",
+        uri: "/admin/datastore/{store}/active-operations",
+        code: 200,
+      }),
+    ),
+).annotate({
+  identifier: "GetAdminDatastoreActiveOperationsRequest",
+}) as any as S.Schema<GetAdminDatastoreActiveOperationsRequest>;
+
+export interface GetAdminDatastoreActiveOperationsResponse {}
+export const GetAdminDatastoreActiveOperationsResponse =
+  /*@__PURE__*/ S.suspend(() => S.Struct({})).annotate({
+    identifier: "GetAdminDatastoreActiveOperationsResponse",
+  }) as any as S.Schema<GetAdminDatastoreActiveOperationsResponse>;
+
+export type GetAdminDatastoreCatalogRequestBackupType = "vm" | "ct" | "host";
+export const GetAdminDatastoreCatalogRequestBackupType = S.String;
+
+export interface GetAdminDatastoreCatalogRequest {
+  store: string;
+  /** Backup archive name. */
+  archive_name?: string;
+  /** Backup ID. */
+  backup_id: string;
+  /** Backup time (Unix epoch.) */
+  backup_time: string;
+  /** Backup types. */
+  backup_type: GetAdminDatastoreCatalogRequestBackupType | (string & {});
+  /** Base64 encoded path. */
+  filepath: string;
+  /** Namespace. */
+  ns?: string;
+}
+export const GetAdminDatastoreCatalogRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    store: S.String.pipe(T.Label()),
+    archive_name: S.optional(S.String.pipe(T.Query("archive-name"))),
+    backup_id: S.String.pipe(T.Query("backup-id")),
+    backup_time: S.String.pipe(T.Query("backup-time")),
+    backup_type: GetAdminDatastoreCatalogRequestBackupType.pipe(
+      T.Query("backup-type"),
+    ),
+    filepath: S.String.pipe(T.Query()),
+    ns: S.optional(S.String.pipe(T.Query())),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/admin/datastore/{store}/catalog",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "GetAdminDatastoreCatalogRequest",
+}) as any as S.Schema<GetAdminDatastoreCatalogRequest>;
+
+export interface GetAdminDatastoreCatalogResponse {}
+export const GetAdminDatastoreCatalogResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "GetAdminDatastoreCatalogResponse",
+}) as any as S.Schema<GetAdminDatastoreCatalogResponse>;
+
+export type GetAdminDatastoreDownloadRequestBackupType = "vm" | "ct" | "host";
+export const GetAdminDatastoreDownloadRequestBackupType = S.String;
+
+export interface GetAdminDatastoreDownloadRequest {
+  store: string;
+  /** Backup ID. */
+  backup_id: string;
+  /** Backup time (Unix epoch.) */
+  backup_time: string;
+  /** Backup type. */
+  backup_type: GetAdminDatastoreDownloadRequestBackupType | (string & {});
+  /** Backup archive name. */
+  file_name: string;
+  /** Namespace. */
+  ns?: string;
+}
+export const GetAdminDatastoreDownloadRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    store: S.String.pipe(T.Label()),
+    backup_id: S.String.pipe(T.Query("backup-id")),
+    backup_time: S.String.pipe(T.Query("backup-time")),
+    backup_type: GetAdminDatastoreDownloadRequestBackupType.pipe(
+      T.Query("backup-type"),
+    ),
+    file_name: S.String.pipe(T.Query("file-name")),
+    ns: S.optional(S.String.pipe(T.Query())),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/admin/datastore/{store}/download",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "GetAdminDatastoreDownloadRequest",
+}) as any as S.Schema<GetAdminDatastoreDownloadRequest>;
+
+export interface GetAdminDatastoreDownloadResponse {}
+export const GetAdminDatastoreDownloadResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "GetAdminDatastoreDownloadResponse",
+}) as any as S.Schema<GetAdminDatastoreDownloadResponse>;
+
+export type GetAdminDatastoreDownloadDecodedRequestBackupType =
+  | "vm"
+  | "ct"
+  | "host";
+export const GetAdminDatastoreDownloadDecodedRequestBackupType = S.String;
+
+export interface GetAdminDatastoreDownloadDecodedRequest {
+  store: string;
+  /** Backup ID. */
+  backup_id: string;
+  /** Backup time (Unix epoch.) */
+  backup_time: string;
+  /** Backup type. */
+  backup_type:
+    | GetAdminDatastoreDownloadDecodedRequestBackupType
+    | (string & {});
+  /** Backup archive name. */
+  file_name: string;
+  /** Namespace. */
+  ns?: string;
+}
+export const GetAdminDatastoreDownloadDecodedRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      store: S.String.pipe(T.Label()),
+      backup_id: S.String.pipe(T.Query("backup-id")),
+      backup_time: S.String.pipe(T.Query("backup-time")),
+      backup_type: GetAdminDatastoreDownloadDecodedRequestBackupType.pipe(
+        T.Query("backup-type"),
+      ),
+      file_name: S.String.pipe(T.Query("file-name")),
+      ns: S.optional(S.String.pipe(T.Query())),
+    }).pipe(
+      T.Http({
+        method: "GET",
+        uri: "/admin/datastore/{store}/download-decoded",
+        code: 200,
+      }),
+    ),
+).annotate({
+  identifier: "GetAdminDatastoreDownloadDecodedRequest",
+}) as any as S.Schema<GetAdminDatastoreDownloadDecodedRequest>;
+
+export interface GetAdminDatastoreDownloadDecodedResponse {}
+export const GetAdminDatastoreDownloadDecodedResponse = /*@__PURE__*/ S.suspend(
+  () => S.Struct({}),
+).annotate({
+  identifier: "GetAdminDatastoreDownloadDecodedResponse",
+}) as any as S.Schema<GetAdminDatastoreDownloadDecodedResponse>;
+
+export interface GetAdminDatastoreGcRequest {
+  store: string;
+}
+export const GetAdminDatastoreGcRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    store: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({ method: "GET", uri: "/admin/datastore/{store}/gc", code: 200 }),
+  ),
+).annotate({
+  identifier: "GetAdminDatastoreGcRequest",
+}) as any as S.Schema<GetAdminDatastoreGcRequest>;
+
+export interface GetAdminDatastoreGcResponseCacheStats {
+  hits: number;
+  misses: number;
+}
+export const GetAdminDatastoreGcResponseCacheStats = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      hits: S.Number,
+      misses: S.Number,
+    }),
+).annotate({
+  identifier: "GetAdminDatastoreGcResponseCacheStats",
+}) as any as S.Schema<GetAdminDatastoreGcResponseCacheStats>;
+
+export interface GetAdminDatastoreGcResponse {
+  cache_stats?: GetAdminDatastoreGcResponseCacheStats;
+  disk_bytes?: number;
+  disk_chunks?: number;
+  duration?: number;
+  index_data_bytes?: number;
+  index_file_count?: number;
+  last_run_endtime?: number;
+  last_run_state?: string;
+  next_run?: number;
+  pending_bytes?: number;
+  pending_chunks?: number;
+  removed_bad?: number;
+  removed_bytes?: number;
+  removed_chunks?: number;
+  schedule?: string;
+  still_bad?: number;
+  store: string;
+  upid?: string;
+}
+export const GetAdminDatastoreGcResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    cache_stats: S.optional(
+      GetAdminDatastoreGcResponseCacheStats.pipe(T.Body("cache-stats")),
+    ),
+    disk_bytes: S.optional(S.Number.pipe(T.Body("disk-bytes"))),
+    disk_chunks: S.optional(S.Number.pipe(T.Body("disk-chunks"))),
+    duration: S.optional(S.Number),
+    index_data_bytes: S.optional(S.Number.pipe(T.Body("index-data-bytes"))),
+    index_file_count: S.optional(S.Number.pipe(T.Body("index-file-count"))),
+    last_run_endtime: S.optional(S.Number.pipe(T.Body("last-run-endtime"))),
+    last_run_state: S.optional(S.String.pipe(T.Body("last-run-state"))),
+    next_run: S.optional(S.Number.pipe(T.Body("next-run"))),
+    pending_bytes: S.optional(S.Number.pipe(T.Body("pending-bytes"))),
+    pending_chunks: S.optional(S.Number.pipe(T.Body("pending-chunks"))),
+    removed_bad: S.optional(S.Number.pipe(T.Body("removed-bad"))),
+    removed_bytes: S.optional(S.Number.pipe(T.Body("removed-bytes"))),
+    removed_chunks: S.optional(S.Number.pipe(T.Body("removed-chunks"))),
+    schedule: S.optional(S.String),
+    still_bad: S.optional(S.Number.pipe(T.Body("still-bad"))),
+    store: S.String,
+    upid: S.optional(S.String),
+  }),
+).annotate({
+  identifier: "GetAdminDatastoreGcResponse",
+}) as any as S.Schema<GetAdminDatastoreGcResponse>;
+
+export type GetAdminDatastoreGroupNotesRequestBackupType = "vm" | "ct" | "host";
+export const GetAdminDatastoreGroupNotesRequestBackupType = S.String;
+
+export interface GetAdminDatastoreGroupNotesRequest {
+  store: string;
+  /** Backup ID. */
+  backup_id: string;
+  /** Backup types. */
+  backup_type: GetAdminDatastoreGroupNotesRequestBackupType | (string & {});
+  /** Namespace. */
+  ns?: string;
+}
+export const GetAdminDatastoreGroupNotesRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    store: S.String.pipe(T.Label()),
+    backup_id: S.String.pipe(T.Query("backup-id")),
+    backup_type: GetAdminDatastoreGroupNotesRequestBackupType.pipe(
+      T.Query("backup-type"),
+    ),
+    ns: S.optional(S.String.pipe(T.Query())),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/admin/datastore/{store}/group-notes",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "GetAdminDatastoreGroupNotesRequest",
+}) as any as S.Schema<GetAdminDatastoreGroupNotesRequest>;
+
+export interface GetAdminDatastoreGroupNotesResponse {}
+export const GetAdminDatastoreGroupNotesResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "GetAdminDatastoreGroupNotesResponse",
+}) as any as S.Schema<GetAdminDatastoreGroupNotesResponse>;
+
+export type GetAdminDatastoreNotesRequestBackupType = "vm" | "ct" | "host";
+export const GetAdminDatastoreNotesRequestBackupType = S.String;
+
+export interface GetAdminDatastoreNotesRequest {
+  store: string;
+  /** Backup ID. */
+  backup_id: string;
+  /** Backup time (Unix epoch.) */
+  backup_time: string;
+  /** Backup types. */
+  backup_type: GetAdminDatastoreNotesRequestBackupType | (string & {});
+  /** Namespace. */
+  ns?: string;
+}
+export const GetAdminDatastoreNotesRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    store: S.String.pipe(T.Label()),
+    backup_id: S.String.pipe(T.Query("backup-id")),
+    backup_time: S.String.pipe(T.Query("backup-time")),
+    backup_type: GetAdminDatastoreNotesRequestBackupType.pipe(
+      T.Query("backup-type"),
+    ),
+    ns: S.optional(S.String.pipe(T.Query())),
+  }).pipe(
+    T.Http({ method: "GET", uri: "/admin/datastore/{store}/notes", code: 200 }),
+  ),
+).annotate({
+  identifier: "GetAdminDatastoreNotesRequest",
+}) as any as S.Schema<GetAdminDatastoreNotesRequest>;
+
+export interface GetAdminDatastoreNotesResponse {}
+export const GetAdminDatastoreNotesResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "GetAdminDatastoreNotesResponse",
+}) as any as S.Schema<GetAdminDatastoreNotesResponse>;
+
+export type GetAdminDatastoreProtectedRequestBackupType = "vm" | "ct" | "host";
+export const GetAdminDatastoreProtectedRequestBackupType = S.String;
+
+export interface GetAdminDatastoreProtectedRequest {
+  store: string;
+  /** Backup ID. */
+  backup_id: string;
+  /** Backup time (Unix epoch.) */
+  backup_time: string;
+  /** Backup types. */
+  backup_type: GetAdminDatastoreProtectedRequestBackupType | (string & {});
+  /** Namespace. */
+  ns?: string;
+}
+export const GetAdminDatastoreProtectedRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    store: S.String.pipe(T.Label()),
+    backup_id: S.String.pipe(T.Query("backup-id")),
+    backup_time: S.String.pipe(T.Query("backup-time")),
+    backup_type: GetAdminDatastoreProtectedRequestBackupType.pipe(
+      T.Query("backup-type"),
+    ),
+    ns: S.optional(S.String.pipe(T.Query())),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/admin/datastore/{store}/protected",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "GetAdminDatastoreProtectedRequest",
+}) as any as S.Schema<GetAdminDatastoreProtectedRequest>;
+
+export interface GetAdminDatastoreProtectedResponse {}
+export const GetAdminDatastoreProtectedResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "GetAdminDatastoreProtectedResponse",
+}) as any as S.Schema<GetAdminDatastoreProtectedResponse>;
+
+export type GetAdminDatastorePxarFileDownloadRequestBackupType =
+  | "vm"
+  | "ct"
+  | "host";
+export const GetAdminDatastorePxarFileDownloadRequestBackupType = S.String;
+
+export interface GetAdminDatastorePxarFileDownloadRequest {
+  store: string;
+  /** Backup archive name. */
+  archive_name?: string;
+  /** Backup ID. */
+  backup_id: string;
+  /** Backup time (Unix epoch.) */
+  backup_time: string;
+  /** Backup type. */
+  backup_type:
+    | GetAdminDatastorePxarFileDownloadRequestBackupType
+    | (string & {});
+  /** Base64 encoded path */
+  filepath: string;
+  /** Namespace. */
+  ns?: string;
+  /** Download as .tar.zst */
+  tar?: string;
+}
+export const GetAdminDatastorePxarFileDownloadRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      store: S.String.pipe(T.Label()),
+      archive_name: S.optional(S.String.pipe(T.Query("archive-name"))),
+      backup_id: S.String.pipe(T.Query("backup-id")),
+      backup_time: S.String.pipe(T.Query("backup-time")),
+      backup_type: GetAdminDatastorePxarFileDownloadRequestBackupType.pipe(
+        T.Query("backup-type"),
+      ),
+      filepath: S.String.pipe(T.Query()),
+      ns: S.optional(S.String.pipe(T.Query())),
+      tar: S.optional(S.String.pipe(T.Query())),
+    }).pipe(
+      T.Http({
+        method: "GET",
+        uri: "/admin/datastore/{store}/pxar-file-download",
+        code: 200,
+      }),
+    ),
+).annotate({
+  identifier: "GetAdminDatastorePxarFileDownloadRequest",
+}) as any as S.Schema<GetAdminDatastorePxarFileDownloadRequest>;
+
+export interface GetAdminDatastorePxarFileDownloadResponse {}
+export const GetAdminDatastorePxarFileDownloadResponse =
+  /*@__PURE__*/ S.suspend(() => S.Struct({})).annotate({
+    identifier: "GetAdminDatastorePxarFileDownloadResponse",
+  }) as any as S.Schema<GetAdminDatastorePxarFileDownloadResponse>;
+
+export type GetAdminDatastoreRrdRequestCf = "MAX" | "AVERAGE";
+export const GetAdminDatastoreRrdRequestCf = S.String;
+
+export type GetAdminDatastoreRrdRequestTimeframe =
+  | "hour"
+  | "day"
+  | "week"
+  | "month"
+  | "year"
+  | "decade";
+export const GetAdminDatastoreRrdRequestTimeframe = S.String;
+
+export interface GetAdminDatastoreRrdRequest {
+  store: string;
+  /** RRD consolidation mode */
+  cf: GetAdminDatastoreRrdRequestCf | (string & {});
+  /** RRD time frame */
+  timeframe: GetAdminDatastoreRrdRequestTimeframe | (string & {});
+}
+export const GetAdminDatastoreRrdRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    store: S.String.pipe(T.Label()),
+    cf: GetAdminDatastoreRrdRequestCf.pipe(T.Query()),
+    timeframe: GetAdminDatastoreRrdRequestTimeframe.pipe(T.Query()),
+  }).pipe(
+    T.Http({ method: "GET", uri: "/admin/datastore/{store}/rrd", code: 200 }),
+  ),
+).annotate({
+  identifier: "GetAdminDatastoreRrdRequest",
+}) as any as S.Schema<GetAdminDatastoreRrdRequest>;
+
+export interface GetAdminDatastoreRrdResponse {}
+export const GetAdminDatastoreRrdResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "GetAdminDatastoreRrdResponse",
+}) as any as S.Schema<GetAdminDatastoreRrdResponse>;
+
+export interface GetAdminDatastoreStatusRequest {
+  store: string;
+  /** Include additional information like snapshot counts and GC status. */
+  verbose?: string;
+}
+export const GetAdminDatastoreStatusRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    store: S.String.pipe(T.Label()),
+    verbose: S.optional(S.String.pipe(T.Query())),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/admin/datastore/{store}/status",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "GetAdminDatastoreStatusRequest",
+}) as any as S.Schema<GetAdminDatastoreStatusRequest>;
+
+export type GetAdminDatastoreStatusResponseBackendType = "filesystem" | "s3";
+export const GetAdminDatastoreStatusResponseBackendType = S.String;
+
+export interface GetAdminDatastoreStatusResponseCountsCt {
+  groups: number;
+  snapshots: number;
+}
+export const GetAdminDatastoreStatusResponseCountsCt = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      groups: S.Number,
+      snapshots: S.Number,
+    }),
+).annotate({
+  identifier: "GetAdminDatastoreStatusResponseCountsCt",
+}) as any as S.Schema<GetAdminDatastoreStatusResponseCountsCt>;
+
+export type GetAdminDatastoreStatusResponseCountsHost =
+  GetAdminDatastoreStatusResponseCountsCt;
+export const GetAdminDatastoreStatusResponseCountsHost =
+  GetAdminDatastoreStatusResponseCountsCt;
+
+export type GetAdminDatastoreStatusResponseCountsOther =
+  GetAdminDatastoreStatusResponseCountsCt;
+export const GetAdminDatastoreStatusResponseCountsOther =
+  GetAdminDatastoreStatusResponseCountsCt;
+
+export type GetAdminDatastoreStatusResponseCountsVm =
+  GetAdminDatastoreStatusResponseCountsCt;
+export const GetAdminDatastoreStatusResponseCountsVm =
+  GetAdminDatastoreStatusResponseCountsCt;
+
+export interface GetAdminDatastoreStatusResponseCounts {
+  ct?: GetAdminDatastoreStatusResponseCountsCt;
+  host?: GetAdminDatastoreStatusResponseCountsCt;
+  other?: GetAdminDatastoreStatusResponseCountsCt;
+  vm?: GetAdminDatastoreStatusResponseCountsCt;
+}
+export const GetAdminDatastoreStatusResponseCounts = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      ct: S.optional(GetAdminDatastoreStatusResponseCountsCt),
+      host: S.optional(GetAdminDatastoreStatusResponseCountsCt),
+      other: S.optional(GetAdminDatastoreStatusResponseCountsCt),
+      vm: S.optional(GetAdminDatastoreStatusResponseCountsCt),
+    }),
+).annotate({
+  identifier: "GetAdminDatastoreStatusResponseCounts",
+}) as any as S.Schema<GetAdminDatastoreStatusResponseCounts>;
+
+export type GetAdminDatastoreStatusResponseGcStatusCacheStats =
+  GetAdminDatastoreGcResponseCacheStats;
+export const GetAdminDatastoreStatusResponseGcStatusCacheStats =
+  GetAdminDatastoreGcResponseCacheStats;
+
+export interface GetAdminDatastoreStatusResponseGcStatus {
+  cache_stats?: GetAdminDatastoreGcResponseCacheStats;
+  disk_bytes?: number;
+  disk_chunks?: number;
+  index_data_bytes?: number;
+  index_file_count?: number;
+  pending_bytes?: number;
+  pending_chunks?: number;
+  removed_bad?: number;
+  removed_bytes?: number;
+  removed_chunks?: number;
+  still_bad?: number;
+  upid?: string;
+}
+export const GetAdminDatastoreStatusResponseGcStatus = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      cache_stats: S.optional(
+        GetAdminDatastoreGcResponseCacheStats.pipe(T.Body("cache-stats")),
+      ),
+      disk_bytes: S.optional(S.Number.pipe(T.Body("disk-bytes"))),
+      disk_chunks: S.optional(S.Number.pipe(T.Body("disk-chunks"))),
+      index_data_bytes: S.optional(S.Number.pipe(T.Body("index-data-bytes"))),
+      index_file_count: S.optional(S.Number.pipe(T.Body("index-file-count"))),
+      pending_bytes: S.optional(S.Number.pipe(T.Body("pending-bytes"))),
+      pending_chunks: S.optional(S.Number.pipe(T.Body("pending-chunks"))),
+      removed_bad: S.optional(S.Number.pipe(T.Body("removed-bad"))),
+      removed_bytes: S.optional(S.Number.pipe(T.Body("removed-bytes"))),
+      removed_chunks: S.optional(S.Number.pipe(T.Body("removed-chunks"))),
+      still_bad: S.optional(S.Number.pipe(T.Body("still-bad"))),
+      upid: S.optional(S.String),
+    }),
+).annotate({
+  identifier: "GetAdminDatastoreStatusResponseGcStatus",
+}) as any as S.Schema<GetAdminDatastoreStatusResponseGcStatus>;
+
+export interface GetAdminDatastoreStatusResponseS3Statistics {
+  delete: number;
+  downloaded: number;
+  get: number;
+  head: number;
+  post: number;
+  put: number;
+  uploaded: number;
+}
+export const GetAdminDatastoreStatusResponseS3Statistics =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      delete: S.Number,
+      downloaded: S.Number,
+      get: S.Number,
+      head: S.Number,
+      post: S.Number,
+      put: S.Number,
+      uploaded: S.Number,
+    }),
+  ).annotate({
+    identifier: "GetAdminDatastoreStatusResponseS3Statistics",
+  }) as any as S.Schema<GetAdminDatastoreStatusResponseS3Statistics>;
+
+export interface GetAdminDatastoreStatusResponse {
+  avail: number;
+  backend_type?: GetAdminDatastoreStatusResponseBackendType;
+  counts?: GetAdminDatastoreStatusResponseCounts;
+  gc_status?: GetAdminDatastoreStatusResponseGcStatus;
+  s3_statistics?: GetAdminDatastoreStatusResponseS3Statistics;
+  total: number;
+  used: number;
+}
+export const GetAdminDatastoreStatusResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    avail: S.Number,
+    backend_type: S.optional(
+      GetAdminDatastoreStatusResponseBackendType.pipe(T.Body("backend-type")),
+    ),
+    counts: S.optional(GetAdminDatastoreStatusResponseCounts),
+    gc_status: S.optional(
+      GetAdminDatastoreStatusResponseGcStatus.pipe(T.Body("gc-status")),
+    ),
+    s3_statistics: S.optional(
+      GetAdminDatastoreStatusResponseS3Statistics.pipe(T.Body("s3-statistics")),
+    ),
+    total: S.Number,
+    used: S.Number,
+  }),
+).annotate({
+  identifier: "GetAdminDatastoreStatusResponse",
+}) as any as S.Schema<GetAdminDatastoreStatusResponse>;
+
+export interface GetAdminGcRequest {
+  store: string;
+}
+export const GetAdminGcRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    store: S.String.pipe(T.Label()),
+  }).pipe(T.Http({ method: "GET", uri: "/admin/gc/{store}", code: 200 })),
+).annotate({
+  identifier: "GetAdminGcRequest",
+}) as any as S.Schema<GetAdminGcRequest>;
+
+export type GetAdminGcResponseBodyItemCacheStats =
+  GetAdminDatastoreGcResponseCacheStats;
+export const GetAdminGcResponseBodyItemCacheStats =
+  GetAdminDatastoreGcResponseCacheStats;
+
+export interface GetAdminGcResponseBodyItem {
+  cache_stats?: GetAdminDatastoreGcResponseCacheStats;
+  disk_bytes?: number;
+  disk_chunks?: number;
+  duration?: number;
+  index_data_bytes?: number;
+  index_file_count?: number;
+  last_run_endtime?: number;
+  last_run_state?: string;
+  next_run?: number;
+  pending_bytes?: number;
+  pending_chunks?: number;
+  removed_bad?: number;
+  removed_bytes?: number;
+  removed_chunks?: number;
+  schedule?: string;
+  still_bad?: number;
+  store: string;
+  upid?: string;
+}
+export const GetAdminGcResponseBodyItem = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    cache_stats: S.optional(
+      GetAdminDatastoreGcResponseCacheStats.pipe(T.Body("cache-stats")),
+    ),
+    disk_bytes: S.optional(S.Number.pipe(T.Body("disk-bytes"))),
+    disk_chunks: S.optional(S.Number.pipe(T.Body("disk-chunks"))),
+    duration: S.optional(S.Number),
+    index_data_bytes: S.optional(S.Number.pipe(T.Body("index-data-bytes"))),
+    index_file_count: S.optional(S.Number.pipe(T.Body("index-file-count"))),
+    last_run_endtime: S.optional(S.Number.pipe(T.Body("last-run-endtime"))),
+    last_run_state: S.optional(S.String.pipe(T.Body("last-run-state"))),
+    next_run: S.optional(S.Number.pipe(T.Body("next-run"))),
+    pending_bytes: S.optional(S.Number.pipe(T.Body("pending-bytes"))),
+    pending_chunks: S.optional(S.Number.pipe(T.Body("pending-chunks"))),
+    removed_bad: S.optional(S.Number.pipe(T.Body("removed-bad"))),
+    removed_bytes: S.optional(S.Number.pipe(T.Body("removed-bytes"))),
+    removed_chunks: S.optional(S.Number.pipe(T.Body("removed-chunks"))),
+    schedule: S.optional(S.String),
+    still_bad: S.optional(S.Number.pipe(T.Body("still-bad"))),
+    store: S.String,
+    upid: S.optional(S.String),
+  }),
+).annotate({
+  identifier: "GetAdminGcResponseBodyItem",
+}) as any as S.Schema<GetAdminGcResponseBodyItem>;
+
+export type GetAdminGcResponseBodyList = Array<GetAdminGcResponseBodyItem>;
+export const GetAdminGcResponseBodyList = /*@__PURE__*/ S.Array(
+  GetAdminGcResponseBodyItem,
+) as any as S.Schema<GetAdminGcResponseBodyList>;
+
+export type GetAdminGcResponse = GetAdminGcResponseBodyList;
+export const GetAdminGcResponse = /*@__PURE__*/ S.suspend(() =>
+  GetAdminGcResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "GetAdminGcResponse",
+}) as any as S.Schema<GetAdminGcResponse>;
+
+export interface GetAdminPruneRequest {
+  id: string;
+}
+export const GetAdminPruneRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    id: S.String.pipe(T.Label()),
+  }).pipe(T.Http({ method: "GET", uri: "/admin/prune/{id}", code: 200 })),
+).annotate({
+  identifier: "GetAdminPruneRequest",
+}) as any as S.Schema<GetAdminPruneRequest>;
+
+export interface GetAdminPruneResponse {}
+export const GetAdminPruneResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "GetAdminPruneResponse",
+}) as any as S.Schema<GetAdminPruneResponse>;
+
+export interface GetAdminS3Request {
+  s3_endpoint_id: string;
+}
+export const GetAdminS3Request = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    s3_endpoint_id: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({ method: "GET", uri: "/admin/s3/{s3-endpoint-id}", code: 200 }),
+  ),
+).annotate({
+  identifier: "GetAdminS3Request",
+}) as any as S.Schema<GetAdminS3Request>;
+
+export interface GetAdminS3Response {}
+export const GetAdminS3Response = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "GetAdminS3Response",
+}) as any as S.Schema<GetAdminS3Response>;
+
+export interface GetAdminSyncRequest {
+  id: string;
+}
+export const GetAdminSyncRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    id: S.String.pipe(T.Label()),
+  }).pipe(T.Http({ method: "GET", uri: "/admin/sync/{id}", code: 200 })),
+).annotate({
+  identifier: "GetAdminSyncRequest",
+}) as any as S.Schema<GetAdminSyncRequest>;
+
+export interface GetAdminSyncResponse {}
+export const GetAdminSyncResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "GetAdminSyncResponse",
+}) as any as S.Schema<GetAdminSyncResponse>;
+
+export interface GetAdminVerifyRequest {
+  id: string;
+}
+export const GetAdminVerifyRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    id: S.String.pipe(T.Label()),
+  }).pipe(T.Http({ method: "GET", uri: "/admin/verify/{id}", code: 200 })),
+).annotate({
+  identifier: "GetAdminVerifyRequest",
+}) as any as S.Schema<GetAdminVerifyRequest>;
+
+export interface GetAdminVerifyResponse {}
+export const GetAdminVerifyResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "GetAdminVerifyResponse",
+}) as any as S.Schema<GetAdminVerifyResponse>;
+
+export interface ListAdminDatastoreRequest {}
+export const ListAdminDatastoreRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}).pipe(
+    T.Http({ method: "GET", uri: "/admin/datastore", code: 200 }),
+  ),
+).annotate({
+  identifier: "ListAdminDatastoreRequest",
+}) as any as S.Schema<ListAdminDatastoreRequest>;
+
+export type ListAdminDatastoreResponseBodyItemBackendType = "filesystem" | "s3";
+export const ListAdminDatastoreResponseBodyItemBackendType = S.String;
+
+export type ListAdminDatastoreResponseBodyItemMountStatus =
+  | "mounted"
+  | "notmounted"
+  | "nonremovable";
+export const ListAdminDatastoreResponseBodyItemMountStatus = S.String;
+
+export interface ListAdminDatastoreResponseBodyItem {
+  backend_type?: ListAdminDatastoreResponseBodyItemBackendType;
+  comment?: string;
+  maintenance?: string;
+  mount_status?: ListAdminDatastoreResponseBodyItemMountStatus;
+  store: string;
+}
+export const ListAdminDatastoreResponseBodyItem = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    backend_type: S.optional(
+      ListAdminDatastoreResponseBodyItemBackendType.pipe(
+        T.Body("backend-type"),
+      ),
+    ),
+    comment: S.optional(S.String),
+    maintenance: S.optional(S.String),
+    mount_status: S.optional(
+      ListAdminDatastoreResponseBodyItemMountStatus.pipe(
+        T.Body("mount-status"),
+      ),
+    ),
+    store: S.String,
+  }),
+).annotate({
+  identifier: "ListAdminDatastoreResponseBodyItem",
+}) as any as S.Schema<ListAdminDatastoreResponseBodyItem>;
+
+export type ListAdminDatastoreResponseBodyList =
+  Array<ListAdminDatastoreResponseBodyItem>;
+export const ListAdminDatastoreResponseBodyList = /*@__PURE__*/ S.Array(
+  ListAdminDatastoreResponseBodyItem,
+) as any as S.Schema<ListAdminDatastoreResponseBodyList>;
+
+export type ListAdminDatastoreResponse = ListAdminDatastoreResponseBodyList;
+export const ListAdminDatastoreResponse = /*@__PURE__*/ S.suspend(() =>
+  ListAdminDatastoreResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListAdminDatastoreResponse",
+}) as any as S.Schema<ListAdminDatastoreResponse>;
+
+export type ListAdminDatastoreFilesRequestBackupType = "vm" | "ct" | "host";
+export const ListAdminDatastoreFilesRequestBackupType = S.String;
+
+export interface ListAdminDatastoreFilesRequest {
+  store: string;
+  /** Backup ID. */
+  backup_id: string;
+  /** Backup time (Unix epoch.) */
+  backup_time: string;
+  /** Backup types. */
+  backup_type: ListAdminDatastoreFilesRequestBackupType | (string & {});
+  /** Namespace. */
+  ns?: string;
+}
+export const ListAdminDatastoreFilesRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    store: S.String.pipe(T.Label()),
+    backup_id: S.String.pipe(T.Query("backup-id")),
+    backup_time: S.String.pipe(T.Query("backup-time")),
+    backup_type: ListAdminDatastoreFilesRequestBackupType.pipe(
+      T.Query("backup-type"),
+    ),
+    ns: S.optional(S.String.pipe(T.Query())),
+  }).pipe(
+    T.Http({ method: "GET", uri: "/admin/datastore/{store}/files", code: 200 }),
+  ),
+).annotate({
+  identifier: "ListAdminDatastoreFilesRequest",
+}) as any as S.Schema<ListAdminDatastoreFilesRequest>;
+
+export type ListAdminDatastoreFilesResponseBodyItemCryptMode =
+  | "none"
+  | "encrypt"
+  | "sign-only";
+export const ListAdminDatastoreFilesResponseBodyItemCryptMode = S.String;
+
+export interface ListAdminDatastoreFilesResponseBodyItem {
+  crypt_mode?: ListAdminDatastoreFilesResponseBodyItemCryptMode;
+  filename: string;
+  size?: number;
+}
+export const ListAdminDatastoreFilesResponseBodyItem = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      crypt_mode: S.optional(
+        ListAdminDatastoreFilesResponseBodyItemCryptMode.pipe(
+          T.Body("crypt-mode"),
+        ),
+      ),
+      filename: S.String,
+      size: S.optional(S.Number),
+    }),
+).annotate({
+  identifier: "ListAdminDatastoreFilesResponseBodyItem",
+}) as any as S.Schema<ListAdminDatastoreFilesResponseBodyItem>;
+
+export type ListAdminDatastoreFilesResponseBodyList =
+  Array<ListAdminDatastoreFilesResponseBodyItem>;
+export const ListAdminDatastoreFilesResponseBodyList = /*@__PURE__*/ S.Array(
+  ListAdminDatastoreFilesResponseBodyItem,
+) as any as S.Schema<ListAdminDatastoreFilesResponseBodyList>;
+
+export type ListAdminDatastoreFilesResponse =
+  ListAdminDatastoreFilesResponseBodyList;
+export const ListAdminDatastoreFilesResponse = /*@__PURE__*/ S.suspend(() =>
+  ListAdminDatastoreFilesResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListAdminDatastoreFilesResponse",
+}) as any as S.Schema<ListAdminDatastoreFilesResponse>;
+
+export interface ListAdminDatastoreGroupsRequest {
+  store: string;
+  /** Namespace. */
+  ns?: string;
+}
+export const ListAdminDatastoreGroupsRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    store: S.String.pipe(T.Label()),
+    ns: S.optional(S.String.pipe(T.Query())),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/admin/datastore/{store}/groups",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "ListAdminDatastoreGroupsRequest",
+}) as any as S.Schema<ListAdminDatastoreGroupsRequest>;
+
+export type ListAdminDatastoreGroupsResponseBodyItemBackupType =
+  | "vm"
+  | "ct"
+  | "host";
+export const ListAdminDatastoreGroupsResponseBodyItemBackupType = S.String;
+
+export type ListAdminDatastoreGroupsResponseBodyItemFilesList = Array<string>;
+export const ListAdminDatastoreGroupsResponseBodyItemFilesList =
+  /*@__PURE__*/ S.Array(
+    S.String,
+  ) as any as S.Schema<ListAdminDatastoreGroupsResponseBodyItemFilesList>;
+
+export interface ListAdminDatastoreGroupsResponseBodyItem {
+  backup_count?: number;
+  backup_id?: string;
+  backup_type?: ListAdminDatastoreGroupsResponseBodyItemBackupType;
+  comment?: string;
+  files: ListAdminDatastoreGroupsResponseBodyItemFilesList;
+  last_backup?: number;
+  owner?: string;
+}
+export const ListAdminDatastoreGroupsResponseBodyItem = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      backup_count: S.optional(S.Number.pipe(T.Body("backup-count"))),
+      backup_id: S.optional(S.String.pipe(T.Body("backup-id"))),
+      backup_type: S.optional(
+        ListAdminDatastoreGroupsResponseBodyItemBackupType.pipe(
+          T.Body("backup-type"),
+        ),
+      ),
+      comment: S.optional(S.String),
+      files: ListAdminDatastoreGroupsResponseBodyItemFilesList,
+      last_backup: S.optional(S.Number.pipe(T.Body("last-backup"))),
+      owner: S.optional(S.String),
+    }),
+).annotate({
+  identifier: "ListAdminDatastoreGroupsResponseBodyItem",
+}) as any as S.Schema<ListAdminDatastoreGroupsResponseBodyItem>;
+
+export type ListAdminDatastoreGroupsResponseBodyList =
+  Array<ListAdminDatastoreGroupsResponseBodyItem>;
+export const ListAdminDatastoreGroupsResponseBodyList = /*@__PURE__*/ S.Array(
+  ListAdminDatastoreGroupsResponseBodyItem,
+) as any as S.Schema<ListAdminDatastoreGroupsResponseBodyList>;
+
+export type ListAdminDatastoreGroupsResponse =
+  ListAdminDatastoreGroupsResponseBodyList;
+export const ListAdminDatastoreGroupsResponse = /*@__PURE__*/ S.suspend(() =>
+  ListAdminDatastoreGroupsResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListAdminDatastoreGroupsResponse",
+}) as any as S.Schema<ListAdminDatastoreGroupsResponse>;
+
+export interface ListAdminDatastoreNamespaceRequest {
+  store: string;
+  /** How many levels of namespaces should be operated on (0 == no recursion) */
+  max_depth?: string;
+  /** Namespace. */
+  parent?: string;
+}
+export const ListAdminDatastoreNamespaceRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    store: S.String.pipe(T.Label()),
+    max_depth: S.optional(S.String.pipe(T.Query("max-depth"))),
+    parent: S.optional(S.String.pipe(T.Query())),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/admin/datastore/{store}/namespace",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "ListAdminDatastoreNamespaceRequest",
+}) as any as S.Schema<ListAdminDatastoreNamespaceRequest>;
+
+export interface ListAdminDatastoreNamespaceResponseBodyItem {
+  comment?: string;
+  ns: string;
+}
+export const ListAdminDatastoreNamespaceResponseBodyItem =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      comment: S.optional(S.String),
+      ns: S.String,
+    }),
+  ).annotate({
+    identifier: "ListAdminDatastoreNamespaceResponseBodyItem",
+  }) as any as S.Schema<ListAdminDatastoreNamespaceResponseBodyItem>;
+
+export type ListAdminDatastoreNamespaceResponseBodyList =
+  Array<ListAdminDatastoreNamespaceResponseBodyItem>;
+export const ListAdminDatastoreNamespaceResponseBodyList =
+  /*@__PURE__*/ S.Array(
+    ListAdminDatastoreNamespaceResponseBodyItem,
+  ) as any as S.Schema<ListAdminDatastoreNamespaceResponseBodyList>;
+
+export type ListAdminDatastoreNamespaceResponse =
+  ListAdminDatastoreNamespaceResponseBodyList;
+export const ListAdminDatastoreNamespaceResponse = /*@__PURE__*/ S.suspend(() =>
+  ListAdminDatastoreNamespaceResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListAdminDatastoreNamespaceResponse",
+}) as any as S.Schema<ListAdminDatastoreNamespaceResponse>;
+
+export type ListAdminDatastoreSnapshotsRequestBackupType = "vm" | "ct" | "host";
+export const ListAdminDatastoreSnapshotsRequestBackupType = S.String;
+
+export interface ListAdminDatastoreSnapshotsRequest {
+  store: string;
+  /** Backup ID. */
+  backup_id?: string;
+  /** Backup types. */
+  backup_type?: ListAdminDatastoreSnapshotsRequestBackupType | (string & {});
+  /** Namespace. */
+  ns?: string;
+}
+export const ListAdminDatastoreSnapshotsRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    store: S.String.pipe(T.Label()),
+    backup_id: S.optional(S.String.pipe(T.Query("backup-id"))),
+    backup_type: S.optional(
+      ListAdminDatastoreSnapshotsRequestBackupType.pipe(T.Query("backup-type")),
+    ),
+    ns: S.optional(S.String.pipe(T.Query())),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/admin/datastore/{store}/snapshots",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "ListAdminDatastoreSnapshotsRequest",
+}) as any as S.Schema<ListAdminDatastoreSnapshotsRequest>;
+
+export type ListAdminDatastoreSnapshotsResponseBodyItemBackupType =
+  | "vm"
+  | "ct"
+  | "host";
+export const ListAdminDatastoreSnapshotsResponseBodyItemBackupType = S.String;
+
+export type ListAdminDatastoreSnapshotsResponseBodyItemFilesList =
+  Array<string>;
+export const ListAdminDatastoreSnapshotsResponseBodyItemFilesList =
+  /*@__PURE__*/ S.Array(
+    S.String,
+  ) as any as S.Schema<ListAdminDatastoreSnapshotsResponseBodyItemFilesList>;
+
+export type ListAdminDatastoreSnapshotsResponseBodyItemVerificationState =
+  | "ok"
+  | "failed";
+export const ListAdminDatastoreSnapshotsResponseBodyItemVerificationState =
+  S.String;
+
+export interface ListAdminDatastoreSnapshotsResponseBodyItemVerification {
+  state: ListAdminDatastoreSnapshotsResponseBodyItemVerificationState;
+  upid: string;
+}
+export const ListAdminDatastoreSnapshotsResponseBodyItemVerification =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      state: ListAdminDatastoreSnapshotsResponseBodyItemVerificationState,
+      upid: S.String,
+    }),
+  ).annotate({
+    identifier: "ListAdminDatastoreSnapshotsResponseBodyItemVerification",
+  }) as any as S.Schema<ListAdminDatastoreSnapshotsResponseBodyItemVerification>;
+
+export interface ListAdminDatastoreSnapshotsResponseBodyItem {
+  backup_id?: string;
+  backup_time?: number;
+  backup_type?: ListAdminDatastoreSnapshotsResponseBodyItemBackupType;
+  comment?: string;
+  files: ListAdminDatastoreSnapshotsResponseBodyItemFilesList;
+  fingerprint?: string;
+  owner?: string;
+  protected: unknown;
+  size?: number;
+  verification?: ListAdminDatastoreSnapshotsResponseBodyItemVerification;
+}
+export const ListAdminDatastoreSnapshotsResponseBodyItem =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      backup_id: S.optional(S.String.pipe(T.Body("backup-id"))),
+      backup_time: S.optional(S.Number.pipe(T.Body("backup-time"))),
+      backup_type: S.optional(
+        ListAdminDatastoreSnapshotsResponseBodyItemBackupType.pipe(
+          T.Body("backup-type"),
+        ),
+      ),
+      comment: S.optional(S.String),
+      files: ListAdminDatastoreSnapshotsResponseBodyItemFilesList,
+      fingerprint: S.optional(S.String),
+      owner: S.optional(S.String),
+      protected: S.Unknown,
+      size: S.optional(S.Number),
+      verification: S.optional(
+        ListAdminDatastoreSnapshotsResponseBodyItemVerification,
+      ),
+    }),
+  ).annotate({
+    identifier: "ListAdminDatastoreSnapshotsResponseBodyItem",
+  }) as any as S.Schema<ListAdminDatastoreSnapshotsResponseBodyItem>;
+
+export type ListAdminDatastoreSnapshotsResponseBodyList =
+  Array<ListAdminDatastoreSnapshotsResponseBodyItem>;
+export const ListAdminDatastoreSnapshotsResponseBodyList =
+  /*@__PURE__*/ S.Array(
+    ListAdminDatastoreSnapshotsResponseBodyItem,
+  ) as any as S.Schema<ListAdminDatastoreSnapshotsResponseBodyList>;
+
+export type ListAdminDatastoreSnapshotsResponse =
+  ListAdminDatastoreSnapshotsResponseBodyList;
+export const ListAdminDatastoreSnapshotsResponse = /*@__PURE__*/ S.suspend(() =>
+  ListAdminDatastoreSnapshotsResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListAdminDatastoreSnapshotsResponse",
+}) as any as S.Schema<ListAdminDatastoreSnapshotsResponse>;
+
+export interface ListAdminGcRequest {
+  /** Datastore name. */
+  store?: string;
+}
+export const ListAdminGcRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    store: S.optional(S.String.pipe(T.Query())),
+  }).pipe(T.Http({ method: "GET", uri: "/admin/gc", code: 200 })),
+).annotate({
+  identifier: "ListAdminGcRequest",
+}) as any as S.Schema<ListAdminGcRequest>;
+
+export type ListAdminGcResponseBodyItemCacheStats =
+  GetAdminDatastoreGcResponseCacheStats;
+export const ListAdminGcResponseBodyItemCacheStats =
+  GetAdminDatastoreGcResponseCacheStats;
+
+export type ListAdminGcResponseBodyItem = GetAdminGcResponseBodyItem;
+export const ListAdminGcResponseBodyItem = GetAdminGcResponseBodyItem;
+
+export type ListAdminGcResponseBodyList = Array<GetAdminGcResponseBodyItem>;
+export const ListAdminGcResponseBodyList = /*@__PURE__*/ S.Array(
+  GetAdminGcResponseBodyItem,
+) as any as S.Schema<ListAdminGcResponseBodyList>;
+
+export type ListAdminGcResponse = ListAdminGcResponseBodyList;
+export const ListAdminGcResponse = /*@__PURE__*/ S.suspend(() =>
+  ListAdminGcResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListAdminGcResponse",
+}) as any as S.Schema<ListAdminGcResponse>;
+
+export interface ListAdminMetricsRequest {}
+export const ListAdminMetricsRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}).pipe(
+    T.Http({ method: "GET", uri: "/admin/metrics", code: 200 }),
+  ),
+).annotate({
+  identifier: "ListAdminMetricsRequest",
+}) as any as S.Schema<ListAdminMetricsRequest>;
+
+export type ListAdminMetricsResponseBodyItemType =
+  | "influxdb-http"
+  | "influxdb-udp";
+export const ListAdminMetricsResponseBodyItemType = S.String;
+
+export interface ListAdminMetricsResponseBodyItem {
+  comment?: string;
+  enable?: unknown;
+  name: string;
+  server: string;
+  type: ListAdminMetricsResponseBodyItemType;
+}
+export const ListAdminMetricsResponseBodyItem = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    comment: S.optional(S.String),
+    enable: S.optional(S.Unknown),
+    name: S.String,
+    server: S.String,
+    type: ListAdminMetricsResponseBodyItemType,
+  }),
+).annotate({
+  identifier: "ListAdminMetricsResponseBodyItem",
+}) as any as S.Schema<ListAdminMetricsResponseBodyItem>;
+
+export type ListAdminMetricsResponseBodyList =
+  Array<ListAdminMetricsResponseBodyItem>;
+export const ListAdminMetricsResponseBodyList = /*@__PURE__*/ S.Array(
+  ListAdminMetricsResponseBodyItem,
+) as any as S.Schema<ListAdminMetricsResponseBodyList>;
+
+export type ListAdminMetricsResponse = ListAdminMetricsResponseBodyList;
+export const ListAdminMetricsResponse = /*@__PURE__*/ S.suspend(() =>
+  ListAdminMetricsResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListAdminMetricsResponse",
+}) as any as S.Schema<ListAdminMetricsResponse>;
+
+export interface ListAdminPruneRequest {
+  /** Datastore name. */
+  store?: string;
+}
+export const ListAdminPruneRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    store: S.optional(S.String.pipe(T.Query())),
+  }).pipe(T.Http({ method: "GET", uri: "/admin/prune", code: 200 })),
+).annotate({
+  identifier: "ListAdminPruneRequest",
+}) as any as S.Schema<ListAdminPruneRequest>;
+
+export interface ListAdminPruneResponseBodyItem {
+  comment?: string;
+  disable?: unknown;
+  id: string;
+  keep_daily?: number;
+  keep_hourly?: number;
+  keep_last?: number;
+  keep_monthly?: number;
+  keep_weekly?: number;
+  keep_yearly?: number;
+  last_run_endtime?: number;
+  last_run_state?: string;
+  last_run_upid?: string;
+  max_depth?: number;
+  next_run?: number;
+  ns?: string;
+  schedule: string;
+  store: string;
+}
+export const ListAdminPruneResponseBodyItem = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    comment: S.optional(S.String),
+    disable: S.optional(S.Unknown),
+    id: S.String,
+    keep_daily: S.optional(S.Number.pipe(T.Body("keep-daily"))),
+    keep_hourly: S.optional(S.Number.pipe(T.Body("keep-hourly"))),
+    keep_last: S.optional(S.Number.pipe(T.Body("keep-last"))),
+    keep_monthly: S.optional(S.Number.pipe(T.Body("keep-monthly"))),
+    keep_weekly: S.optional(S.Number.pipe(T.Body("keep-weekly"))),
+    keep_yearly: S.optional(S.Number.pipe(T.Body("keep-yearly"))),
+    last_run_endtime: S.optional(S.Number.pipe(T.Body("last-run-endtime"))),
+    last_run_state: S.optional(S.String.pipe(T.Body("last-run-state"))),
+    last_run_upid: S.optional(S.String.pipe(T.Body("last-run-upid"))),
+    max_depth: S.optional(S.Number.pipe(T.Body("max-depth"))),
+    next_run: S.optional(S.Number.pipe(T.Body("next-run"))),
+    ns: S.optional(S.String),
+    schedule: S.String,
+    store: S.String,
+  }),
+).annotate({
+  identifier: "ListAdminPruneResponseBodyItem",
+}) as any as S.Schema<ListAdminPruneResponseBodyItem>;
+
+export type ListAdminPruneResponseBodyList =
+  Array<ListAdminPruneResponseBodyItem>;
+export const ListAdminPruneResponseBodyList = /*@__PURE__*/ S.Array(
+  ListAdminPruneResponseBodyItem,
+) as any as S.Schema<ListAdminPruneResponseBodyList>;
+
+export type ListAdminPruneResponse = ListAdminPruneResponseBodyList;
+export const ListAdminPruneResponse = /*@__PURE__*/ S.suspend(() =>
+  ListAdminPruneResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListAdminPruneResponse",
+}) as any as S.Schema<ListAdminPruneResponse>;
+
+export type ListAdminSyncRequestSyncDirection = "all" | "push" | "pull";
+export const ListAdminSyncRequestSyncDirection = S.String;
+
+export interface ListAdminSyncRequest {
+  /** Datastore name. */
+  store?: string;
+  /** The direction of the listed sync jobs: push, pull or all. */
+  sync_direction?: ListAdminSyncRequestSyncDirection | (string & {});
+}
+export const ListAdminSyncRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    store: S.optional(S.String.pipe(T.Query())),
+    sync_direction: S.optional(
+      ListAdminSyncRequestSyncDirection.pipe(T.Query("sync-direction")),
+    ),
+  }).pipe(T.Http({ method: "GET", uri: "/admin/sync", code: 200 })),
+).annotate({
+  identifier: "ListAdminSyncRequest",
+}) as any as S.Schema<ListAdminSyncRequest>;
+
+export type ListAdminSyncResponseBodyItemAssociatedKeyList = Array<string>;
+export const ListAdminSyncResponseBodyItemAssociatedKeyList =
+  /*@__PURE__*/ S.Array(
+    S.String,
+  ) as any as S.Schema<ListAdminSyncResponseBodyItemAssociatedKeyList>;
+
+export type ListAdminSyncResponseBodyItemGroupFilterList = Array<string>;
+export const ListAdminSyncResponseBodyItemGroupFilterList =
+  /*@__PURE__*/ S.Array(
+    S.String,
+  ) as any as S.Schema<ListAdminSyncResponseBodyItemGroupFilterList>;
+
+export type ListAdminSyncResponseBodyItemSyncDirection = "pull" | "push";
+export const ListAdminSyncResponseBodyItemSyncDirection = S.String;
+
+export interface ListAdminSyncResponseBodyItem {
+  active_encryption_key?: string;
+  associated_key?: ListAdminSyncResponseBodyItemAssociatedKeyList;
+  burst_in?: string;
+  burst_out?: string;
+  comment?: string;
+  encrypted_only?: unknown;
+  group_filter?: ListAdminSyncResponseBodyItemGroupFilterList;
+  id: string;
+  last_run_endtime?: number;
+  last_run_state?: string;
+  last_run_upid?: string;
+  max_depth?: number;
+  next_run?: number;
+  ns?: string;
+  owner?: string;
+  rate_in?: string;
+  rate_out?: string;
+  remote?: string;
+  remote_ns?: string;
+  remote_store?: string;
+  remove_vanished?: unknown;
+  resync_corrupt?: unknown;
+  run_on_mount?: unknown;
+  schedule?: string;
+  store: string;
+  sync_direction?: ListAdminSyncResponseBodyItemSyncDirection;
+  transfer_last?: number;
+  unmount_on_done?: unknown;
+  verified_only?: unknown;
+  worker_threads?: number;
+}
+export const ListAdminSyncResponseBodyItem = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    active_encryption_key: S.optional(
+      S.String.pipe(T.Body("active-encryption-key")),
+    ),
+    associated_key: S.optional(
+      ListAdminSyncResponseBodyItemAssociatedKeyList.pipe(
+        T.Body("associated-key"),
+      ),
+    ),
+    burst_in: S.optional(S.String.pipe(T.Body("burst-in"))),
+    burst_out: S.optional(S.String.pipe(T.Body("burst-out"))),
+    comment: S.optional(S.String),
+    encrypted_only: S.optional(S.Unknown.pipe(T.Body("encrypted-only"))),
+    group_filter: S.optional(
+      ListAdminSyncResponseBodyItemGroupFilterList.pipe(T.Body("group-filter")),
+    ),
+    id: S.String,
+    last_run_endtime: S.optional(S.Number.pipe(T.Body("last-run-endtime"))),
+    last_run_state: S.optional(S.String.pipe(T.Body("last-run-state"))),
+    last_run_upid: S.optional(S.String.pipe(T.Body("last-run-upid"))),
+    max_depth: S.optional(S.Number.pipe(T.Body("max-depth"))),
+    next_run: S.optional(S.Number.pipe(T.Body("next-run"))),
+    ns: S.optional(S.String),
+    owner: S.optional(S.String),
+    rate_in: S.optional(S.String.pipe(T.Body("rate-in"))),
+    rate_out: S.optional(S.String.pipe(T.Body("rate-out"))),
+    remote: S.optional(S.String),
+    remote_ns: S.optional(S.String.pipe(T.Body("remote-ns"))),
+    remote_store: S.optional(S.String.pipe(T.Body("remote-store"))),
+    remove_vanished: S.optional(S.Unknown.pipe(T.Body("remove-vanished"))),
+    resync_corrupt: S.optional(S.Unknown.pipe(T.Body("resync-corrupt"))),
+    run_on_mount: S.optional(S.Unknown.pipe(T.Body("run-on-mount"))),
+    schedule: S.optional(S.String),
+    store: S.String,
+    sync_direction: S.optional(
+      ListAdminSyncResponseBodyItemSyncDirection.pipe(T.Body("sync-direction")),
+    ),
+    transfer_last: S.optional(S.Number.pipe(T.Body("transfer-last"))),
+    unmount_on_done: S.optional(S.Unknown.pipe(T.Body("unmount-on-done"))),
+    verified_only: S.optional(S.Unknown.pipe(T.Body("verified-only"))),
+    worker_threads: S.optional(S.Number.pipe(T.Body("worker-threads"))),
+  }),
+).annotate({
+  identifier: "ListAdminSyncResponseBodyItem",
+}) as any as S.Schema<ListAdminSyncResponseBodyItem>;
+
+export type ListAdminSyncResponseBodyList =
+  Array<ListAdminSyncResponseBodyItem>;
+export const ListAdminSyncResponseBodyList = /*@__PURE__*/ S.Array(
+  ListAdminSyncResponseBodyItem,
+) as any as S.Schema<ListAdminSyncResponseBodyList>;
+
+export type ListAdminSyncResponse = ListAdminSyncResponseBodyList;
+export const ListAdminSyncResponse = /*@__PURE__*/ S.suspend(() =>
+  ListAdminSyncResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListAdminSyncResponse",
+}) as any as S.Schema<ListAdminSyncResponse>;
+
+export interface ListAdminTrafficControlRequest {}
+export const ListAdminTrafficControlRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}).pipe(
+    T.Http({ method: "GET", uri: "/admin/traffic-control", code: 200 }),
+  ),
+).annotate({
+  identifier: "ListAdminTrafficControlRequest",
+}) as any as S.Schema<ListAdminTrafficControlRequest>;
+
+export type ListAdminTrafficControlResponseBodyItemNetworkList = Array<string>;
+export const ListAdminTrafficControlResponseBodyItemNetworkList =
+  /*@__PURE__*/ S.Array(
+    S.String,
+  ) as any as S.Schema<ListAdminTrafficControlResponseBodyItemNetworkList>;
+
+export type ListAdminTrafficControlResponseBodyItemTimeframeList =
+  Array<string>;
+export const ListAdminTrafficControlResponseBodyItemTimeframeList =
+  /*@__PURE__*/ S.Array(
+    S.String,
+  ) as any as S.Schema<ListAdminTrafficControlResponseBodyItemTimeframeList>;
+
+export type ListAdminTrafficControlResponseBodyItemUsersList = Array<string>;
+export const ListAdminTrafficControlResponseBodyItemUsersList =
+  /*@__PURE__*/ S.Array(
+    S.String,
+  ) as any as S.Schema<ListAdminTrafficControlResponseBodyItemUsersList>;
+
+export interface ListAdminTrafficControlResponseBodyItem {
+  burst_in?: string;
+  burst_out?: string;
+  comment?: string;
+  cur_rate_in?: number;
+  cur_rate_out?: number;
+  name: string;
+  network: ListAdminTrafficControlResponseBodyItemNetworkList;
+  rate_in?: string;
+  rate_out?: string;
+  timeframe?: ListAdminTrafficControlResponseBodyItemTimeframeList;
+  users?: ListAdminTrafficControlResponseBodyItemUsersList;
+}
+export const ListAdminTrafficControlResponseBodyItem = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      burst_in: S.optional(S.String.pipe(T.Body("burst-in"))),
+      burst_out: S.optional(S.String.pipe(T.Body("burst-out"))),
+      comment: S.optional(S.String),
+      cur_rate_in: S.optional(S.Number.pipe(T.Body("cur-rate-in"))),
+      cur_rate_out: S.optional(S.Number.pipe(T.Body("cur-rate-out"))),
+      name: S.String,
+      network: ListAdminTrafficControlResponseBodyItemNetworkList,
+      rate_in: S.optional(S.String.pipe(T.Body("rate-in"))),
+      rate_out: S.optional(S.String.pipe(T.Body("rate-out"))),
+      timeframe: S.optional(
+        ListAdminTrafficControlResponseBodyItemTimeframeList,
+      ),
+      users: S.optional(ListAdminTrafficControlResponseBodyItemUsersList),
+    }),
+).annotate({
+  identifier: "ListAdminTrafficControlResponseBodyItem",
+}) as any as S.Schema<ListAdminTrafficControlResponseBodyItem>;
+
+export type ListAdminTrafficControlResponseBodyList =
+  Array<ListAdminTrafficControlResponseBodyItem>;
+export const ListAdminTrafficControlResponseBodyList = /*@__PURE__*/ S.Array(
+  ListAdminTrafficControlResponseBodyItem,
+) as any as S.Schema<ListAdminTrafficControlResponseBodyList>;
+
+export type ListAdminTrafficControlResponse =
+  ListAdminTrafficControlResponseBodyList;
+export const ListAdminTrafficControlResponse = /*@__PURE__*/ S.suspend(() =>
+  ListAdminTrafficControlResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListAdminTrafficControlResponse",
+}) as any as S.Schema<ListAdminTrafficControlResponse>;
+
+export interface ListAdminVerifyRequest {
+  /** Datastore name. */
+  store?: string;
+}
+export const ListAdminVerifyRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    store: S.optional(S.String.pipe(T.Query())),
+  }).pipe(T.Http({ method: "GET", uri: "/admin/verify", code: 200 })),
+).annotate({
+  identifier: "ListAdminVerifyRequest",
+}) as any as S.Schema<ListAdminVerifyRequest>;
+
+export interface ListAdminVerifyResponseBodyItem {
+  comment?: string;
+  id: string;
+  ignore_verified?: unknown;
+  last_run_endtime?: number;
+  last_run_state?: string;
+  last_run_upid?: string;
+  max_depth?: number;
+  next_run?: number;
+  ns?: string;
+  outdated_after?: number;
+  read_threads?: number;
+  schedule?: string;
+  store: string;
+  verify_threads?: number;
+}
+export const ListAdminVerifyResponseBodyItem = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    comment: S.optional(S.String),
+    id: S.String,
+    ignore_verified: S.optional(S.Unknown.pipe(T.Body("ignore-verified"))),
+    last_run_endtime: S.optional(S.Number.pipe(T.Body("last-run-endtime"))),
+    last_run_state: S.optional(S.String.pipe(T.Body("last-run-state"))),
+    last_run_upid: S.optional(S.String.pipe(T.Body("last-run-upid"))),
+    max_depth: S.optional(S.Number.pipe(T.Body("max-depth"))),
+    next_run: S.optional(S.Number.pipe(T.Body("next-run"))),
+    ns: S.optional(S.String),
+    outdated_after: S.optional(S.Number.pipe(T.Body("outdated-after"))),
+    read_threads: S.optional(S.Number.pipe(T.Body("read-threads"))),
+    schedule: S.optional(S.String),
+    store: S.String,
+    verify_threads: S.optional(S.Number.pipe(T.Body("verify-threads"))),
+  }),
+).annotate({
+  identifier: "ListAdminVerifyResponseBodyItem",
+}) as any as S.Schema<ListAdminVerifyResponseBodyItem>;
+
+export type ListAdminVerifyResponseBodyList =
+  Array<ListAdminVerifyResponseBodyItem>;
+export const ListAdminVerifyResponseBodyList = /*@__PURE__*/ S.Array(
+  ListAdminVerifyResponseBodyItem,
+) as any as S.Schema<ListAdminVerifyResponseBodyList>;
+
+export type ListAdminVerifyResponse = ListAdminVerifyResponseBodyList;
+export const ListAdminVerifyResponse = /*@__PURE__*/ S.suspend(() =>
+  ListAdminVerifyResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListAdminVerifyResponse",
+}) as any as S.Schema<ListAdminVerifyResponse>;
+
+export type MoveAdminDatastoreGroupRequestBackupType = "vm" | "ct" | "host";
+export const MoveAdminDatastoreGroupRequestBackupType = S.String;
+
+export interface MoveAdminDatastoreGroupRequest {
+  store: string;
+  /** Backup ID. */
+  backup_id: string;
+  /** Backup types. */
+  backup_type: MoveAdminDatastoreGroupRequestBackupType | (string & {});
+  /** If the group already exists in the target namespace, merge snapshots into it. Requires matching ownership and non-overlapping snapshot times. */
+  merge_group?: string;
+  /** Namespace. */
+  ns?: string;
+  /** Namespace. */
+  target_ns?: string;
+}
+export const MoveAdminDatastoreGroupRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    store: S.String.pipe(T.Label()),
+    backup_id: S.String.pipe(T.Body("backup-id")),
+    backup_type: MoveAdminDatastoreGroupRequestBackupType.pipe(
+      T.Body("backup-type"),
+    ),
+    merge_group: S.optional(S.String.pipe(T.Body("merge-group"))),
+    ns: S.optional(S.String),
+    target_ns: S.optional(S.String.pipe(T.Body("target-ns"))),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/admin/datastore/{store}/move-group",
+      code: 200,
+      contentType: "form-urlencoded",
+    }),
+  ),
+).annotate({
+  identifier: "MoveAdminDatastoreGroupRequest",
+}) as any as S.Schema<MoveAdminDatastoreGroupRequest>;
+
+export type MoveAdminDatastoreGroupResponse = string;
+export const MoveAdminDatastoreGroupResponse = /*@__PURE__*/ S.suspend(() =>
+  S.String.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "MoveAdminDatastoreGroupResponse",
+}) as any as S.Schema<MoveAdminDatastoreGroupResponse>;
+
+export interface MoveAdminDatastoreNamespaceRequest {
+  store: string;
+  /** Remove the source namespace after moving all contents. Defaults to true. */
+  delete_source?: string;
+  /** How many levels of namespaces should be operated on (0 == no recursion) */
+  max_depth?: string;
+  /** If a group with the same name already exists in the target namespace, merge snapshots into it. Requires matching ownership and non-overlapping snapshot times. */
+  merge_groups?: string;
+  /** Namespace. */
+  ns: string;
+  /** Namespace. */
+  target_ns: string;
+}
+export const MoveAdminDatastoreNamespaceRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    store: S.String.pipe(T.Label()),
+    delete_source: S.optional(S.String.pipe(T.Body("delete-source"))),
+    max_depth: S.optional(S.String.pipe(T.Body("max-depth"))),
+    merge_groups: S.optional(S.String.pipe(T.Body("merge-groups"))),
+    ns: S.String,
+    target_ns: S.String.pipe(T.Body("target-ns")),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/admin/datastore/{store}/move-namespace",
+      code: 200,
+      contentType: "form-urlencoded",
+    }),
+  ),
+).annotate({
+  identifier: "MoveAdminDatastoreNamespaceRequest",
+}) as any as S.Schema<MoveAdminDatastoreNamespaceRequest>;
+
+export type MoveAdminDatastoreNamespaceResponse = string;
+export const MoveAdminDatastoreNamespaceResponse = /*@__PURE__*/ S.suspend(() =>
+  S.String.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "MoveAdminDatastoreNamespaceResponse",
+}) as any as S.Schema<MoveAdminDatastoreNamespaceResponse>;
+
+export type PutAdminDatastoreGroupNotesRequestBackupType = "vm" | "ct" | "host";
+export const PutAdminDatastoreGroupNotesRequestBackupType = S.String;
+
+export interface PutAdminDatastoreGroupNotesRequest {
+  store: string;
+  /** Backup ID. */
+  backup_id: string;
+  /** Backup types. */
+  backup_type: PutAdminDatastoreGroupNotesRequestBackupType | (string & {});
+  /** A multiline text. */
+  notes: string;
+  /** Namespace. */
+  ns?: string;
+}
+export const PutAdminDatastoreGroupNotesRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    store: S.String.pipe(T.Label()),
+    backup_id: S.String.pipe(T.Body("backup-id")),
+    backup_type: PutAdminDatastoreGroupNotesRequestBackupType.pipe(
+      T.Body("backup-type"),
+    ),
+    notes: S.String,
+    ns: S.optional(S.String),
+  }).pipe(
+    T.Http({
+      method: "PUT",
+      uri: "/admin/datastore/{store}/group-notes",
+      code: 200,
+      contentType: "form-urlencoded",
+    }),
+  ),
+).annotate({
+  identifier: "PutAdminDatastoreGroupNotesRequest",
+}) as any as S.Schema<PutAdminDatastoreGroupNotesRequest>;
+
+export interface PutAdminDatastoreGroupNotesResponse {}
+export const PutAdminDatastoreGroupNotesResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "PutAdminDatastoreGroupNotesResponse",
+}) as any as S.Schema<PutAdminDatastoreGroupNotesResponse>;
+
+export type PutAdminDatastoreNotesRequestBackupType = "vm" | "ct" | "host";
+export const PutAdminDatastoreNotesRequestBackupType = S.String;
+
+export interface PutAdminDatastoreNotesRequest {
+  store: string;
+  /** Backup ID. */
+  backup_id: string;
+  /** Backup time (Unix epoch.) */
+  backup_time: string;
+  /** Backup types. */
+  backup_type: PutAdminDatastoreNotesRequestBackupType | (string & {});
+  /** A multiline text. */
+  notes: string;
+  /** Namespace. */
+  ns?: string;
+}
+export const PutAdminDatastoreNotesRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    store: S.String.pipe(T.Label()),
+    backup_id: S.String.pipe(T.Body("backup-id")),
+    backup_time: S.String.pipe(T.Body("backup-time")),
+    backup_type: PutAdminDatastoreNotesRequestBackupType.pipe(
+      T.Body("backup-type"),
+    ),
+    notes: S.String,
+    ns: S.optional(S.String),
+  }).pipe(
+    T.Http({
+      method: "PUT",
+      uri: "/admin/datastore/{store}/notes",
+      code: 200,
+      contentType: "form-urlencoded",
+    }),
+  ),
+).annotate({
+  identifier: "PutAdminDatastoreNotesRequest",
+}) as any as S.Schema<PutAdminDatastoreNotesRequest>;
+
+export interface PutAdminDatastoreNotesResponse {}
+export const PutAdminDatastoreNotesResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "PutAdminDatastoreNotesResponse",
+}) as any as S.Schema<PutAdminDatastoreNotesResponse>;
+
+export type PutAdminDatastoreProtectedRequestBackupType = "vm" | "ct" | "host";
+export const PutAdminDatastoreProtectedRequestBackupType = S.String;
+
+export interface PutAdminDatastoreProtectedRequest {
+  store: string;
+  /** Backup ID. */
+  backup_id: string;
+  /** Backup time (Unix epoch.) */
+  backup_time: string;
+  /** Backup types. */
+  backup_type: PutAdminDatastoreProtectedRequestBackupType | (string & {});
+  /** Namespace. */
+  ns?: string;
+  /** Enable/disable protection. */
+  protected: string;
+}
+export const PutAdminDatastoreProtectedRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    store: S.String.pipe(T.Label()),
+    backup_id: S.String.pipe(T.Body("backup-id")),
+    backup_time: S.String.pipe(T.Body("backup-time")),
+    backup_type: PutAdminDatastoreProtectedRequestBackupType.pipe(
+      T.Body("backup-type"),
+    ),
+    ns: S.optional(S.String),
+    protected: S.String,
+  }).pipe(
+    T.Http({
+      method: "PUT",
+      uri: "/admin/datastore/{store}/protected",
+      code: 200,
+      contentType: "form-urlencoded",
+    }),
+  ),
+).annotate({
+  identifier: "PutAdminDatastoreProtectedRequest",
+}) as any as S.Schema<PutAdminDatastoreProtectedRequest>;
+
+export interface PutAdminDatastoreProtectedResponse {}
+export const PutAdminDatastoreProtectedResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "PutAdminDatastoreProtectedResponse",
+}) as any as S.Schema<PutAdminDatastoreProtectedResponse>;
+
+export interface PutAdminDatastoreS3RefreshRequest {
+  store: string;
+}
+export const PutAdminDatastoreS3RefreshRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    store: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "PUT",
+      uri: "/admin/datastore/{store}/s3-refresh",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "PutAdminDatastoreS3RefreshRequest",
+}) as any as S.Schema<PutAdminDatastoreS3RefreshRequest>;
+
+export type PutAdminDatastoreS3RefreshResponse = string;
+export const PutAdminDatastoreS3RefreshResponse = /*@__PURE__*/ S.suspend(() =>
+  S.String.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "PutAdminDatastoreS3RefreshResponse",
+}) as any as S.Schema<PutAdminDatastoreS3RefreshResponse>;
+
+export interface PutAdminS3CheckRequest {
+  s3_endpoint_id: string;
+  /** Bucket name for S3 object store. */
+  bucket: string;
+  /** Store prefix within bucket for S3 object keys (commonly datastore name) */
+  store_prefix?: string;
+}
+export const PutAdminS3CheckRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    s3_endpoint_id: S.String.pipe(T.Label()),
+    bucket: S.String,
+    store_prefix: S.optional(S.String.pipe(T.Body("store-prefix"))),
+  }).pipe(
+    T.Http({
+      method: "PUT",
+      uri: "/admin/s3/{s3-endpoint-id}/check",
+      code: 200,
+      contentType: "form-urlencoded",
+    }),
+  ),
+).annotate({
+  identifier: "PutAdminS3CheckRequest",
+}) as any as S.Schema<PutAdminS3CheckRequest>;
+
+export interface PutAdminS3CheckResponse {}
+export const PutAdminS3CheckResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "PutAdminS3CheckResponse",
+}) as any as S.Schema<PutAdminS3CheckResponse>;
+
+export interface PutAdminS3ResetCountersRequest {
+  s3_endpoint_id: string;
+  /** Bucket name for S3 object store. */
+  bucket: string;
+  /** Store prefix within bucket for S3 object keys (commonly datastore name) */
+  store_prefix?: string;
+}
+export const PutAdminS3ResetCountersRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    s3_endpoint_id: S.String.pipe(T.Label()),
+    bucket: S.String,
+    store_prefix: S.optional(S.String.pipe(T.Body("store-prefix"))),
+  }).pipe(
+    T.Http({
+      method: "PUT",
+      uri: "/admin/s3/{s3-endpoint-id}/reset-counters",
+      code: 200,
+      contentType: "form-urlencoded",
+    }),
+  ),
+).annotate({
+  identifier: "PutAdminS3ResetCountersRequest",
+}) as any as S.Schema<PutAdminS3ResetCountersRequest>;
+
+export interface PutAdminS3ResetCountersResponse {}
+export const PutAdminS3ResetCountersResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "PutAdminS3ResetCountersResponse",
+}) as any as S.Schema<PutAdminS3ResetCountersResponse>;
+
+export interface RunAdminPruneRequest {
+  id: string;
+}
+export const RunAdminPruneRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    id: S.String.pipe(T.Label()),
+  }).pipe(T.Http({ method: "POST", uri: "/admin/prune/{id}/run", code: 200 })),
+).annotate({
+  identifier: "RunAdminPruneRequest",
+}) as any as S.Schema<RunAdminPruneRequest>;
+
+export interface RunAdminPruneResponse {}
+export const RunAdminPruneResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "RunAdminPruneResponse",
+}) as any as S.Schema<RunAdminPruneResponse>;
+
+export interface RunAdminSyncRequest {
+  id: string;
+}
+export const RunAdminSyncRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    id: S.String.pipe(T.Label()),
+  }).pipe(T.Http({ method: "POST", uri: "/admin/sync/{id}/run", code: 200 })),
+).annotate({
+  identifier: "RunAdminSyncRequest",
+}) as any as S.Schema<RunAdminSyncRequest>;
+
+export interface RunAdminSyncResponse {}
+export const RunAdminSyncResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "RunAdminSyncResponse",
+}) as any as S.Schema<RunAdminSyncResponse>;
+
+export type UploadAdminDatastoreBackupLogRequestBackupType =
+  | "vm"
+  | "ct"
+  | "host";
+export const UploadAdminDatastoreBackupLogRequestBackupType = S.String;
+
+export interface UploadAdminDatastoreBackupLogRequest {
+  store: string;
+  /** Backup ID. */
+  backup_id: string;
+  /** Backup time (Unix epoch.) */
+  backup_time: string;
+  /** Backup type. */
+  backup_type: UploadAdminDatastoreBackupLogRequestBackupType | (string & {});
+  /** Namespace. */
+  ns?: string;
+}
+export const UploadAdminDatastoreBackupLogRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      store: S.String.pipe(T.Label()),
+      backup_id: S.String.pipe(T.Body("backup-id")),
+      backup_time: S.String.pipe(T.Body("backup-time")),
+      backup_type: UploadAdminDatastoreBackupLogRequestBackupType.pipe(
+        T.Body("backup-type"),
+      ),
+      ns: S.optional(S.String),
+    }).pipe(
+      T.Http({
+        method: "POST",
+        uri: "/admin/datastore/{store}/upload-backup-log",
+        code: 200,
+        contentType: "form-urlencoded",
+      }),
+    ),
+).annotate({
+  identifier: "UploadAdminDatastoreBackupLogRequest",
+}) as any as S.Schema<UploadAdminDatastoreBackupLogRequest>;
+
+export interface UploadAdminDatastoreBackupLogResponse {}
+export const UploadAdminDatastoreBackupLogResponse = /*@__PURE__*/ S.suspend(
+  () => S.Struct({}),
+).annotate({
+  identifier: "UploadAdminDatastoreBackupLogResponse",
+}) as any as S.Schema<UploadAdminDatastoreBackupLogResponse>;
+
+export type VerifyAdminDatastoreRequestBackupType = "vm" | "ct" | "host";
+export const VerifyAdminDatastoreRequestBackupType = S.String;
+
+export interface VerifyAdminDatastoreRequest {
+  store: string;
+  /** Backup ID. */
+  backup_id?: string;
+  /** Backup time (Unix epoch.) */
+  backup_time?: string;
+  /** Backup types. */
+  backup_type?: VerifyAdminDatastoreRequestBackupType | (string & {});
+  /** Do not verify backups that are already verified if their verification is not outdated. */
+  ignore_verified?: string;
+  /** How many levels of namespaces should be operated on (0 == no recursion) */
+  max_depth?: string;
+  /** Namespace. */
+  ns?: string;
+  /** Days after that a verification becomes outdated. (0 is deprecated)' */
+  outdated_after?: string;
+  /** The number of threads to use for reading chunks in verify job. */
+  read_threads?: string;
+  /** The number of threads to use for verifying chunks in verify job. */
+  verify_threads?: string;
+}
+export const VerifyAdminDatastoreRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    store: S.String.pipe(T.Label()),
+    backup_id: S.optional(S.String.pipe(T.Body("backup-id"))),
+    backup_time: S.optional(S.String.pipe(T.Body("backup-time"))),
+    backup_type: S.optional(
+      VerifyAdminDatastoreRequestBackupType.pipe(T.Body("backup-type")),
+    ),
+    ignore_verified: S.optional(S.String.pipe(T.Body("ignore-verified"))),
+    max_depth: S.optional(S.String.pipe(T.Body("max-depth"))),
+    ns: S.optional(S.String),
+    outdated_after: S.optional(S.String.pipe(T.Body("outdated-after"))),
+    read_threads: S.optional(S.String.pipe(T.Body("read-threads"))),
+    verify_threads: S.optional(S.String.pipe(T.Body("verify-threads"))),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/admin/datastore/{store}/verify",
+      code: 200,
+      contentType: "form-urlencoded",
+    }),
+  ),
+).annotate({
+  identifier: "VerifyAdminDatastoreRequest",
+}) as any as S.Schema<VerifyAdminDatastoreRequest>;
+
+export type VerifyAdminDatastoreResponse = string;
+export const VerifyAdminDatastoreResponse = /*@__PURE__*/ S.suspend(() =>
+  S.String.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "VerifyAdminDatastoreResponse",
+}) as any as S.Schema<VerifyAdminDatastoreResponse>;
+
+export interface VerifyRunAdminRequest {
+  id: string;
+}
+export const VerifyRunAdminRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    id: S.String.pipe(T.Label()),
+  }).pipe(T.Http({ method: "POST", uri: "/admin/verify/{id}/run", code: 200 })),
+).annotate({
+  identifier: "VerifyRunAdminRequest",
+}) as any as S.Schema<VerifyRunAdminRequest>;
+
+export interface VerifyRunAdminResponse {}
+export const VerifyRunAdminResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "VerifyRunAdminResponse",
+}) as any as S.Schema<VerifyRunAdminResponse>;
+
+export type CreateAdminDatastoreChangeOwnerError = ProxmoxBackupOpError;
+/** Change owner of a backup group */
+export const createAdminDatastoreChangeOwner: API.OperationMethod<
+  CreateAdminDatastoreChangeOwnerRequest,
+  CreateAdminDatastoreChangeOwnerResponse,
+  CreateAdminDatastoreChangeOwnerError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateAdminDatastoreChangeOwnerRequest,
+  output: CreateAdminDatastoreChangeOwnerResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateAdminDatastoreGcError = ProxmoxBackupOpError;
+/** Start garbage collection. */
+export const createAdminDatastoreGc: API.OperationMethod<
+  CreateAdminDatastoreGcRequest,
+  CreateAdminDatastoreGcResponse,
+  CreateAdminDatastoreGcError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateAdminDatastoreGcRequest,
+  output: CreateAdminDatastoreGcResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateAdminDatastoreMountError = ProxmoxBackupOpError;
+/** Mount removable datastore. */
+export const createAdminDatastoreMount: API.OperationMethod<
+  CreateAdminDatastoreMountRequest,
+  CreateAdminDatastoreMountResponse,
+  CreateAdminDatastoreMountError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateAdminDatastoreMountRequest,
+  output: CreateAdminDatastoreMountResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateAdminDatastoreNamespaceError = ProxmoxBackupOpError;
+/** Create a new datastore namespace. */
+export const createAdminDatastoreNamespace: API.OperationMethod<
+  CreateAdminDatastoreNamespaceRequest,
+  CreateAdminDatastoreNamespaceResponse,
+  CreateAdminDatastoreNamespaceError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateAdminDatastoreNamespaceRequest,
+  output: CreateAdminDatastoreNamespaceResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateAdminDatastorePruneError = ProxmoxBackupOpError;
+/** Prune a group on the datastore */
+export const createAdminDatastorePrune: API.OperationMethod<
+  CreateAdminDatastorePruneRequest,
+  CreateAdminDatastorePruneResponse,
+  CreateAdminDatastorePruneError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateAdminDatastorePruneRequest,
+  output: CreateAdminDatastorePruneResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateAdminDatastorePruneDatastoreError = ProxmoxBackupOpError;
+/** Prune the datastore */
+export const createAdminDatastorePruneDatastore: API.OperationMethod<
+  CreateAdminDatastorePruneDatastoreRequest,
+  CreateAdminDatastorePruneDatastoreResponse,
+  CreateAdminDatastorePruneDatastoreError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateAdminDatastorePruneDatastoreRequest,
+  output: CreateAdminDatastorePruneDatastoreResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateAdminDatastoreUnmountError = ProxmoxBackupOpError;
+/** Unmount a removable device that is associated with the datastore */
+export const createAdminDatastoreUnmount: API.OperationMethod<
+  CreateAdminDatastoreUnmountRequest,
+  CreateAdminDatastoreUnmountResponse,
+  CreateAdminDatastoreUnmountError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateAdminDatastoreUnmountRequest,
+  output: CreateAdminDatastoreUnmountResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteAdminDatastoreGroupsError = ProxmoxBackupOpError;
+/** Delete backup group including all snapshots. */
+export const deleteAdminDatastoreGroups: API.OperationMethod<
+  DeleteAdminDatastoreGroupsRequest,
+  DeleteAdminDatastoreGroupsResponse,
+  DeleteAdminDatastoreGroupsError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteAdminDatastoreGroupsRequest,
+  output: DeleteAdminDatastoreGroupsResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteAdminDatastoreNamespaceError = ProxmoxBackupOpError;
+/** Delete a backup namespace including all snapshots. */
+export const deleteAdminDatastoreNamespace: API.OperationMethod<
+  DeleteAdminDatastoreNamespaceRequest,
+  DeleteAdminDatastoreNamespaceResponse,
+  DeleteAdminDatastoreNamespaceError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteAdminDatastoreNamespaceRequest,
+  output: DeleteAdminDatastoreNamespaceResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteAdminDatastoreSnapshotsError = ProxmoxBackupOpError;
+/** Delete backup snapshot. */
+export const deleteAdminDatastoreSnapshots: API.OperationMethod<
+  DeleteAdminDatastoreSnapshotsRequest,
+  DeleteAdminDatastoreSnapshotsResponse,
+  DeleteAdminDatastoreSnapshotsError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteAdminDatastoreSnapshotsRequest,
+  output: DeleteAdminDatastoreSnapshotsResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetAdminError = ProxmoxBackupOpError;
+/** Directory index. */
+export const getAdmin: API.OperationMethod<
+  GetAdminRequest,
+  GetAdminResponse,
+  GetAdminError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetAdminRequest,
+  output: GetAdminResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetAdminDatastoreError = ProxmoxBackupOpError;
+/** Directory index. */
+export const getAdminDatastore: API.OperationMethod<
+  GetAdminDatastoreRequest,
+  GetAdminDatastoreResponse,
+  GetAdminDatastoreError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetAdminDatastoreRequest,
+  output: GetAdminDatastoreResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetAdminDatastoreActiveOperationsError = ProxmoxBackupOpError;
+/** Read datastore stats */
+export const getAdminDatastoreActiveOperations: API.OperationMethod<
+  GetAdminDatastoreActiveOperationsRequest,
+  GetAdminDatastoreActiveOperationsResponse,
+  GetAdminDatastoreActiveOperationsError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetAdminDatastoreActiveOperationsRequest,
+  output: GetAdminDatastoreActiveOperationsResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetAdminDatastoreCatalogError = ProxmoxBackupOpError;
+/** Get the entries of the given path of the catalog */
+export const getAdminDatastoreCatalog: API.OperationMethod<
+  GetAdminDatastoreCatalogRequest,
+  GetAdminDatastoreCatalogResponse,
+  GetAdminDatastoreCatalogError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetAdminDatastoreCatalogRequest,
+  output: GetAdminDatastoreCatalogResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetAdminDatastoreDownloadError = ProxmoxBackupOpError;
+/** Download single raw file from backup snapshot. */
+export const getAdminDatastoreDownload: API.OperationMethod<
+  GetAdminDatastoreDownloadRequest,
+  GetAdminDatastoreDownloadResponse,
+  GetAdminDatastoreDownloadError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetAdminDatastoreDownloadRequest,
+  output: GetAdminDatastoreDownloadResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetAdminDatastoreDownloadDecodedError = ProxmoxBackupOpError;
+/** Download single decoded file from backup snapshot. Only works if it's not encrypted. */
+export const getAdminDatastoreDownloadDecoded: API.OperationMethod<
+  GetAdminDatastoreDownloadDecodedRequest,
+  GetAdminDatastoreDownloadDecodedResponse,
+  GetAdminDatastoreDownloadDecodedError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetAdminDatastoreDownloadDecodedRequest,
+  output: GetAdminDatastoreDownloadDecodedResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetAdminDatastoreGcError = ProxmoxBackupOpError;
+/** Garbage collection status. */
+export const getAdminDatastoreGc: API.OperationMethod<
+  GetAdminDatastoreGcRequest,
+  GetAdminDatastoreGcResponse,
+  GetAdminDatastoreGcError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetAdminDatastoreGcRequest,
+  output: GetAdminDatastoreGcResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetAdminDatastoreGroupNotesError = ProxmoxBackupOpError;
+/** Get "notes" for a backup group */
+export const getAdminDatastoreGroupNotes: API.OperationMethod<
+  GetAdminDatastoreGroupNotesRequest,
+  GetAdminDatastoreGroupNotesResponse,
+  GetAdminDatastoreGroupNotesError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetAdminDatastoreGroupNotesRequest,
+  output: GetAdminDatastoreGroupNotesResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetAdminDatastoreNotesError = ProxmoxBackupOpError;
+/** Get "notes" for a specific backup */
+export const getAdminDatastoreNotes: API.OperationMethod<
+  GetAdminDatastoreNotesRequest,
+  GetAdminDatastoreNotesResponse,
+  GetAdminDatastoreNotesError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetAdminDatastoreNotesRequest,
+  output: GetAdminDatastoreNotesResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetAdminDatastoreProtectedError = ProxmoxBackupOpError;
+/** Query protection for a specific backup */
+export const getAdminDatastoreProtected: API.OperationMethod<
+  GetAdminDatastoreProtectedRequest,
+  GetAdminDatastoreProtectedResponse,
+  GetAdminDatastoreProtectedError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetAdminDatastoreProtectedRequest,
+  output: GetAdminDatastoreProtectedResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetAdminDatastorePxarFileDownloadError = ProxmoxBackupOpError;
+/** Download single file from pxar file of a backup snapshot. Only works if it's not encrypted. */
+export const getAdminDatastorePxarFileDownload: API.OperationMethod<
+  GetAdminDatastorePxarFileDownloadRequest,
+  GetAdminDatastorePxarFileDownloadResponse,
+  GetAdminDatastorePxarFileDownloadError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetAdminDatastorePxarFileDownloadRequest,
+  output: GetAdminDatastorePxarFileDownloadResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetAdminDatastoreRrdError = ProxmoxBackupOpError;
+/** Read datastore stats */
+export const getAdminDatastoreRrd: API.OperationMethod<
+  GetAdminDatastoreRrdRequest,
+  GetAdminDatastoreRrdResponse,
+  GetAdminDatastoreRrdError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetAdminDatastoreRrdRequest,
+  output: GetAdminDatastoreRrdResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetAdminDatastoreStatusError = ProxmoxBackupOpError;
+/** Get datastore status. */
+export const getAdminDatastoreStatus: API.OperationMethod<
+  GetAdminDatastoreStatusRequest,
+  GetAdminDatastoreStatusResponse,
+  GetAdminDatastoreStatusError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetAdminDatastoreStatusRequest,
+  output: GetAdminDatastoreStatusResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetAdminGcError = ProxmoxBackupOpError;
+/** List all GC jobs (max one per datastore) */
+export const getAdminGc: API.OperationMethod<
+  GetAdminGcRequest,
+  GetAdminGcResponse,
+  GetAdminGcError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetAdminGcRequest,
+  output: GetAdminGcResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetAdminPruneError = ProxmoxBackupOpError;
+/** Directory index. */
+export const getAdminPrune: API.OperationMethod<
+  GetAdminPruneRequest,
+  GetAdminPruneResponse,
+  GetAdminPruneError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetAdminPruneRequest,
+  output: GetAdminPruneResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetAdminS3Error = ProxmoxBackupOpError;
+/** Directory index. */
+export const getAdminS3: API.OperationMethod<
+  GetAdminS3Request,
+  GetAdminS3Response,
+  GetAdminS3Error,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetAdminS3Request,
+  output: GetAdminS3Response,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetAdminSyncError = ProxmoxBackupOpError;
+/** Directory index. */
+export const getAdminSync: API.OperationMethod<
+  GetAdminSyncRequest,
+  GetAdminSyncResponse,
+  GetAdminSyncError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetAdminSyncRequest,
+  output: GetAdminSyncResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetAdminVerifyError = ProxmoxBackupOpError;
+/** Directory index. */
+export const getAdminVerify: API.OperationMethod<
+  GetAdminVerifyRequest,
+  GetAdminVerifyResponse,
+  GetAdminVerifyError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetAdminVerifyRequest,
+  output: GetAdminVerifyResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListAdminDatastoreError = ProxmoxBackupOpError;
+/** Datastore list */
+export const listAdminDatastore: API.OperationMethod<
+  ListAdminDatastoreRequest,
+  ListAdminDatastoreResponse,
+  ListAdminDatastoreError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListAdminDatastoreRequest,
+  output: ListAdminDatastoreResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListAdminDatastoreFilesError = ProxmoxBackupOpError;
+/** List snapshot files. */
+export const listAdminDatastoreFiles: API.OperationMethod<
+  ListAdminDatastoreFilesRequest,
+  ListAdminDatastoreFilesResponse,
+  ListAdminDatastoreFilesError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListAdminDatastoreFilesRequest,
+  output: ListAdminDatastoreFilesResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListAdminDatastoreGroupsError = ProxmoxBackupOpError;
+/** List backup groups. */
+export const listAdminDatastoreGroups: API.OperationMethod<
+  ListAdminDatastoreGroupsRequest,
+  ListAdminDatastoreGroupsResponse,
+  ListAdminDatastoreGroupsError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListAdminDatastoreGroupsRequest,
+  output: ListAdminDatastoreGroupsResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListAdminDatastoreNamespaceError = ProxmoxBackupOpError;
+/** List the namespaces of a datastore. */
+export const listAdminDatastoreNamespace: API.OperationMethod<
+  ListAdminDatastoreNamespaceRequest,
+  ListAdminDatastoreNamespaceResponse,
+  ListAdminDatastoreNamespaceError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListAdminDatastoreNamespaceRequest,
+  output: ListAdminDatastoreNamespaceResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListAdminDatastoreSnapshotsError = ProxmoxBackupOpError;
+/** List backup snapshots. */
+export const listAdminDatastoreSnapshots: API.OperationMethod<
+  ListAdminDatastoreSnapshotsRequest,
+  ListAdminDatastoreSnapshotsResponse,
+  ListAdminDatastoreSnapshotsError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListAdminDatastoreSnapshotsRequest,
+  output: ListAdminDatastoreSnapshotsResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListAdminGcError = ProxmoxBackupOpError;
+/** List all GC jobs (max one per datastore) */
+export const listAdminGc: API.OperationMethod<
+  ListAdminGcRequest,
+  ListAdminGcResponse,
+  ListAdminGcError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListAdminGcRequest,
+  output: ListAdminGcResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListAdminMetricsError = ProxmoxBackupOpError;
+/** List configured metric servers. */
+export const listAdminMetrics: API.OperationMethod<
+  ListAdminMetricsRequest,
+  ListAdminMetricsResponse,
+  ListAdminMetricsError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListAdminMetricsRequest,
+  output: ListAdminMetricsResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListAdminPruneError = ProxmoxBackupOpError;
+/** List all prune jobs */
+export const listAdminPrune: API.OperationMethod<
+  ListAdminPruneRequest,
+  ListAdminPruneResponse,
+  ListAdminPruneError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListAdminPruneRequest,
+  output: ListAdminPruneResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListAdminSyncError = ProxmoxBackupOpError;
+/** List all configured sync jobs */
+export const listAdminSync: API.OperationMethod<
+  ListAdminSyncRequest,
+  ListAdminSyncResponse,
+  ListAdminSyncError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListAdminSyncRequest,
+  output: ListAdminSyncResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListAdminTrafficControlError = ProxmoxBackupOpError;
+/** Show current traffic for all traffic control rules. */
+export const listAdminTrafficControl: API.OperationMethod<
+  ListAdminTrafficControlRequest,
+  ListAdminTrafficControlResponse,
+  ListAdminTrafficControlError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListAdminTrafficControlRequest,
+  output: ListAdminTrafficControlResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListAdminVerifyError = ProxmoxBackupOpError;
+/** List all verification jobs */
+export const listAdminVerify: API.OperationMethod<
+  ListAdminVerifyRequest,
+  ListAdminVerifyResponse,
+  ListAdminVerifyError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListAdminVerifyRequest,
+  output: ListAdminVerifyResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type MoveAdminDatastoreGroupError = ProxmoxBackupOpError;
+/** Move a backup group to a different namespace within the same datastore. */
+export const moveAdminDatastoreGroup: API.OperationMethod<
+  MoveAdminDatastoreGroupRequest,
+  MoveAdminDatastoreGroupResponse,
+  MoveAdminDatastoreGroupError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: MoveAdminDatastoreGroupRequest,
+  output: MoveAdminDatastoreGroupResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type MoveAdminDatastoreNamespaceError = ProxmoxBackupOpError;
+/** Move a backup namespace (including all child namespaces and groups) to a new location. */
+export const moveAdminDatastoreNamespace: API.OperationMethod<
+  MoveAdminDatastoreNamespaceRequest,
+  MoveAdminDatastoreNamespaceResponse,
+  MoveAdminDatastoreNamespaceError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: MoveAdminDatastoreNamespaceRequest,
+  output: MoveAdminDatastoreNamespaceResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type PutAdminDatastoreGroupNotesError = ProxmoxBackupOpError;
+/** Set "notes" for a backup group */
+export const putAdminDatastoreGroupNotes: API.OperationMethod<
+  PutAdminDatastoreGroupNotesRequest,
+  PutAdminDatastoreGroupNotesResponse,
+  PutAdminDatastoreGroupNotesError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PutAdminDatastoreGroupNotesRequest,
+  output: PutAdminDatastoreGroupNotesResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type PutAdminDatastoreNotesError = ProxmoxBackupOpError;
+/** Set "notes" for a specific backup */
+export const putAdminDatastoreNotes: API.OperationMethod<
+  PutAdminDatastoreNotesRequest,
+  PutAdminDatastoreNotesResponse,
+  PutAdminDatastoreNotesError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PutAdminDatastoreNotesRequest,
+  output: PutAdminDatastoreNotesResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type PutAdminDatastoreProtectedError = ProxmoxBackupOpError;
+/** En- or disable protection for a specific backup */
+export const putAdminDatastoreProtected: API.OperationMethod<
+  PutAdminDatastoreProtectedRequest,
+  PutAdminDatastoreProtectedResponse,
+  PutAdminDatastoreProtectedError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PutAdminDatastoreProtectedRequest,
+  output: PutAdminDatastoreProtectedResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type PutAdminDatastoreS3RefreshError = ProxmoxBackupOpError;
+/** Refresh datastore contents from S3 to local cache store. */
+export const putAdminDatastoreS3Refresh: API.OperationMethod<
+  PutAdminDatastoreS3RefreshRequest,
+  PutAdminDatastoreS3RefreshResponse,
+  PutAdminDatastoreS3RefreshError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PutAdminDatastoreS3RefreshRequest,
+  output: PutAdminDatastoreS3RefreshResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type PutAdminS3CheckError = ProxmoxBackupOpError;
+/** Perform basic sanity check for given s3 client configuration */
+export const putAdminS3Check: API.OperationMethod<
+  PutAdminS3CheckRequest,
+  PutAdminS3CheckResponse,
+  PutAdminS3CheckError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PutAdminS3CheckRequest,
+  output: PutAdminS3CheckResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type PutAdminS3ResetCountersError = ProxmoxBackupOpError;
+/** Reset the S3 request counters for matching endpoint, bucket or datastore (if prefix is given). */
+export const putAdminS3ResetCounters: API.OperationMethod<
+  PutAdminS3ResetCountersRequest,
+  PutAdminS3ResetCountersResponse,
+  PutAdminS3ResetCountersError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PutAdminS3ResetCountersRequest,
+  output: PutAdminS3ResetCountersResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type RunAdminPruneError = ProxmoxBackupOpError;
+/** Runs a prune job manually. */
+export const runAdminPrune: API.OperationMethod<
+  RunAdminPruneRequest,
+  RunAdminPruneResponse,
+  RunAdminPruneError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: RunAdminPruneRequest,
+  output: RunAdminPruneResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type RunAdminSyncError = ProxmoxBackupOpError;
+/** Runs the sync jobs manually. */
+export const runAdminSync: API.OperationMethod<
+  RunAdminSyncRequest,
+  RunAdminSyncResponse,
+  RunAdminSyncError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: RunAdminSyncRequest,
+  output: RunAdminSyncResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type UploadAdminDatastoreBackupLogError = ProxmoxBackupOpError;
+/** Upload the client backup log file into a backup snapshot ('client.log.blob'). */
+export const uploadAdminDatastoreBackupLog: API.OperationMethod<
+  UploadAdminDatastoreBackupLogRequest,
+  UploadAdminDatastoreBackupLogResponse,
+  UploadAdminDatastoreBackupLogError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: UploadAdminDatastoreBackupLogRequest,
+  output: UploadAdminDatastoreBackupLogResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type VerifyAdminDatastoreError = ProxmoxBackupOpError;
+/** Verify backups. This function can verify a single backup snapshot, all backups from a backup group, or all backups in the datastore. */
+export const verifyAdminDatastore: API.OperationMethod<
+  VerifyAdminDatastoreRequest,
+  VerifyAdminDatastoreResponse,
+  VerifyAdminDatastoreError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: VerifyAdminDatastoreRequest,
+  output: VerifyAdminDatastoreResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type VerifyRunAdminError = ProxmoxBackupOpError;
+/** Runs a verification job manually. */
+export const verifyRunAdmin: API.OperationMethod<
+  VerifyRunAdminRequest,
+  VerifyRunAdminResponse,
+  VerifyRunAdminError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: VerifyRunAdminRequest,
+  output: VerifyRunAdminResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));