@homeflare/distilled-proxmox-backup 0.2.0

package/src/services/tape.ts

@@ -0,0 +1,2257 @@
+// 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 CreateTapeBackupRequestGroupFilterList = Array<string>;
+export const CreateTapeBackupRequestGroupFilterList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<CreateTapeBackupRequestGroupFilterList>;
+
+export type CreateTapeBackupRequestNotificationMode =
+  | "legacy-sendmail"
+  | "notification-system";
+export const CreateTapeBackupRequestNotificationMode = S.String;
+
+export interface CreateTapeBackupRequest {
+  /** Drive Identifier. */
+  drive: string;
+  /** Eject media upon job completion. */
+  eject_media?: string;
+  /** Export media set upon job completion. */
+  export_media_set?: string;
+  /** Ignore the allocation policy and start a new media-set. */
+  force_media_set?: string;
+  /** List of group filters. */
+  group_filter?: CreateTapeBackupRequestGroupFilterList;
+  /** Backup latest snapshots only. */
+  latest_only?: string;
+  /** How many levels of namespaces should be operated on (0 == no recursion) */
+  max_depth?: string;
+  /** Configure how notifications for this datastore should be sent. `legacy-sendmail` sends email notifications to the user configured in `notify-user` via the system's `sendmail` executable. `notification-system` emits matchable notification events to the notification system. */
+  notification_mode?: CreateTapeBackupRequestNotificationMode | (string & {});
+  /** User ID */
+  notify_user?: string;
+  /** Namespace. */
+  ns?: string;
+  /** Media pool name. */
+  pool: string;
+  /** Datastore name. */
+  store: string;
+  /** The number of threads to use for the tape backup job. */
+  worker_threads?: string;
+}
+export const CreateTapeBackupRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    drive: S.String,
+    eject_media: S.optional(S.String.pipe(T.Body("eject-media"))),
+    export_media_set: S.optional(S.String.pipe(T.Body("export-media-set"))),
+    force_media_set: S.optional(S.String.pipe(T.Body("force-media-set"))),
+    group_filter: S.optional(
+      CreateTapeBackupRequestGroupFilterList.pipe(T.Body("group-filter")),
+    ),
+    latest_only: S.optional(S.String.pipe(T.Body("latest-only"))),
+    max_depth: S.optional(S.String.pipe(T.Body("max-depth"))),
+    notification_mode: S.optional(
+      CreateTapeBackupRequestNotificationMode.pipe(T.Body("notification-mode")),
+    ),
+    notify_user: S.optional(S.String.pipe(T.Body("notify-user"))),
+    ns: S.optional(S.String),
+    pool: S.String,
+    store: S.String,
+    worker_threads: S.optional(S.String.pipe(T.Body("worker-threads"))),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/tape/backup",
+      code: 200,
+      contentType: "form-urlencoded",
+    }),
+  ),
+).annotate({
+  identifier: "CreateTapeBackupRequest",
+}) as any as S.Schema<CreateTapeBackupRequest>;
+
+export type CreateTapeBackupResponse = string;
+export const CreateTapeBackupResponse = /*@__PURE__*/ S.suspend(() =>
+  S.String.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "CreateTapeBackupResponse",
+}) as any as S.Schema<CreateTapeBackupResponse>;
+
+export interface CreateTapeDriveBarcodeLabelMediaRequest {
+  drive: string;
+  /** Media pool name. */
+  pool?: string;
+}
+export const CreateTapeDriveBarcodeLabelMediaRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      drive: S.String.pipe(T.Label()),
+      pool: S.optional(S.String),
+    }).pipe(
+      T.Http({
+        method: "POST",
+        uri: "/tape/drive/{drive}/barcode-label-media",
+        code: 200,
+        contentType: "form-urlencoded",
+      }),
+    ),
+).annotate({
+  identifier: "CreateTapeDriveBarcodeLabelMediaRequest",
+}) as any as S.Schema<CreateTapeDriveBarcodeLabelMediaRequest>;
+
+export type CreateTapeDriveBarcodeLabelMediaResponse = string;
+export const CreateTapeDriveBarcodeLabelMediaResponse = /*@__PURE__*/ S.suspend(
+  () => S.String.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "CreateTapeDriveBarcodeLabelMediaResponse",
+}) as any as S.Schema<CreateTapeDriveBarcodeLabelMediaResponse>;
+
+export interface CreateTapeDriveCatalogRequest {
+  drive: string;
+  /** Force overriding existing index. */
+  force?: string;
+  /** Re-read the whole tape to reconstruct the catalog instead of restoring saved versions. */
+  scan?: string;
+  /** Verbose mode - log all found chunks. */
+  verbose?: string;
+}
+export const CreateTapeDriveCatalogRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    drive: S.String.pipe(T.Label()),
+    force: S.optional(S.String),
+    scan: S.optional(S.String),
+    verbose: S.optional(S.String),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/tape/drive/{drive}/catalog",
+      code: 200,
+      contentType: "form-urlencoded",
+    }),
+  ),
+).annotate({
+  identifier: "CreateTapeDriveCatalogRequest",
+}) as any as S.Schema<CreateTapeDriveCatalogRequest>;
+
+export type CreateTapeDriveCatalogResponse = string;
+export const CreateTapeDriveCatalogResponse = /*@__PURE__*/ S.suspend(() =>
+  S.String.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "CreateTapeDriveCatalogResponse",
+}) as any as S.Schema<CreateTapeDriveCatalogResponse>;
+
+export interface CreateTapeDriveEjectMediaRequest {
+  drive: string;
+}
+export const CreateTapeDriveEjectMediaRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    drive: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/tape/drive/{drive}/eject-media",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "CreateTapeDriveEjectMediaRequest",
+}) as any as S.Schema<CreateTapeDriveEjectMediaRequest>;
+
+export type CreateTapeDriveEjectMediaResponse = string;
+export const CreateTapeDriveEjectMediaResponse = /*@__PURE__*/ S.suspend(() =>
+  S.String.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "CreateTapeDriveEjectMediaResponse",
+}) as any as S.Schema<CreateTapeDriveEjectMediaResponse>;
+
+export interface CreateTapeDriveFormatMediaRequest {
+  drive: string;
+  /** Use fast erase. */
+  fast?: string;
+  /** Media Label/Barcode. */
+  label_text?: string;
+  /** Media Label/Barcode. */
+  load_barcode?: string;
+}
+export const CreateTapeDriveFormatMediaRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    drive: S.String.pipe(T.Label()),
+    fast: S.optional(S.String),
+    label_text: S.optional(S.String.pipe(T.Body("label-text"))),
+    load_barcode: S.optional(S.String.pipe(T.Body("load-barcode"))),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/tape/drive/{drive}/format-media",
+      code: 200,
+      contentType: "form-urlencoded",
+    }),
+  ),
+).annotate({
+  identifier: "CreateTapeDriveFormatMediaRequest",
+}) as any as S.Schema<CreateTapeDriveFormatMediaRequest>;
+
+export type CreateTapeDriveFormatMediaResponse = string;
+export const CreateTapeDriveFormatMediaResponse = /*@__PURE__*/ S.suspend(() =>
+  S.String.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "CreateTapeDriveFormatMediaResponse",
+}) as any as S.Schema<CreateTapeDriveFormatMediaResponse>;
+
+export interface CreateTapeDriveLabelMediaRequest {
+  drive: string;
+  /** Media Label/Barcode. */
+  label_text: string;
+  /** Media pool name. */
+  pool?: string;
+}
+export const CreateTapeDriveLabelMediaRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    drive: S.String.pipe(T.Label()),
+    label_text: S.String.pipe(T.Body("label-text")),
+    pool: S.optional(S.String),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/tape/drive/{drive}/label-media",
+      code: 200,
+      contentType: "form-urlencoded",
+    }),
+  ),
+).annotate({
+  identifier: "CreateTapeDriveLabelMediaRequest",
+}) as any as S.Schema<CreateTapeDriveLabelMediaRequest>;
+
+export type CreateTapeDriveLabelMediaResponse = string;
+export const CreateTapeDriveLabelMediaResponse = /*@__PURE__*/ S.suspend(() =>
+  S.String.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "CreateTapeDriveLabelMediaResponse",
+}) as any as S.Schema<CreateTapeDriveLabelMediaResponse>;
+
+export interface CreateTapeDriveLoadMediaRequest {
+  drive: string;
+  /** Media Label/Barcode. */
+  label_text: string;
+}
+export const CreateTapeDriveLoadMediaRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    drive: S.String.pipe(T.Label()),
+    label_text: S.String.pipe(T.Body("label-text")),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/tape/drive/{drive}/load-media",
+      code: 200,
+      contentType: "form-urlencoded",
+    }),
+  ),
+).annotate({
+  identifier: "CreateTapeDriveLoadMediaRequest",
+}) as any as S.Schema<CreateTapeDriveLoadMediaRequest>;
+
+export type CreateTapeDriveLoadMediaResponse = string;
+export const CreateTapeDriveLoadMediaResponse = /*@__PURE__*/ S.suspend(() =>
+  S.String.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "CreateTapeDriveLoadMediaResponse",
+}) as any as S.Schema<CreateTapeDriveLoadMediaResponse>;
+
+export interface CreateTapeDriveLoadSlotRequest {
+  drive: string;
+  /** Source slot number. */
+  source_slot: string;
+}
+export const CreateTapeDriveLoadSlotRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    drive: S.String.pipe(T.Label()),
+    source_slot: S.String.pipe(T.Body("source-slot")),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/tape/drive/{drive}/load-slot",
+      code: 200,
+      contentType: "form-urlencoded",
+    }),
+  ),
+).annotate({
+  identifier: "CreateTapeDriveLoadSlotRequest",
+}) as any as S.Schema<CreateTapeDriveLoadSlotRequest>;
+
+export interface CreateTapeDriveLoadSlotResponse {}
+export const CreateTapeDriveLoadSlotResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "CreateTapeDriveLoadSlotResponse",
+}) as any as S.Schema<CreateTapeDriveLoadSlotResponse>;
+
+export interface CreateTapeDriveRewindRequest {
+  drive: string;
+}
+export const CreateTapeDriveRewindRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    drive: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({ method: "POST", uri: "/tape/drive/{drive}/rewind", code: 200 }),
+  ),
+).annotate({
+  identifier: "CreateTapeDriveRewindRequest",
+}) as any as S.Schema<CreateTapeDriveRewindRequest>;
+
+export type CreateTapeDriveRewindResponse = string;
+export const CreateTapeDriveRewindResponse = /*@__PURE__*/ S.suspend(() =>
+  S.String.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "CreateTapeDriveRewindResponse",
+}) as any as S.Schema<CreateTapeDriveRewindResponse>;
+
+export interface CreateTapeDriveUnloadRequest {
+  drive: string;
+  /** Target slot number. If omitted, defaults to the slot that the drive was loaded from. */
+  target_slot?: string;
+}
+export const CreateTapeDriveUnloadRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    drive: S.String.pipe(T.Label()),
+    target_slot: S.optional(S.String.pipe(T.Body("target-slot"))),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/tape/drive/{drive}/unload",
+      code: 200,
+      contentType: "form-urlencoded",
+    }),
+  ),
+).annotate({
+  identifier: "CreateTapeDriveUnloadRequest",
+}) as any as S.Schema<CreateTapeDriveUnloadRequest>;
+
+export type CreateTapeDriveUnloadResponse = string;
+export const CreateTapeDriveUnloadResponse = /*@__PURE__*/ S.suspend(() =>
+  S.String.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "CreateTapeDriveUnloadResponse",
+}) as any as S.Schema<CreateTapeDriveUnloadResponse>;
+
+export type CreateTapeMediaListStatusRequestStatus =
+  | "writable"
+  | "full"
+  | "unknown"
+  | "damaged"
+  | "retired";
+export const CreateTapeMediaListStatusRequestStatus = S.String;
+
+export interface CreateTapeMediaListStatusRequest {
+  uuid: string;
+  /** Media status Media Status */
+  status?: CreateTapeMediaListStatusRequestStatus | (string & {});
+}
+export const CreateTapeMediaListStatusRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    uuid: S.String.pipe(T.Label()),
+    status: S.optional(CreateTapeMediaListStatusRequestStatus),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/tape/media/list/{uuid}/status",
+      code: 200,
+      contentType: "form-urlencoded",
+    }),
+  ),
+).annotate({
+  identifier: "CreateTapeMediaListStatusRequest",
+}) as any as S.Schema<CreateTapeMediaListStatusRequest>;
+
+export interface CreateTapeMediaListStatusResponse {}
+export const CreateTapeMediaListStatusResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "CreateTapeMediaListStatusResponse",
+}) as any as S.Schema<CreateTapeMediaListStatusResponse>;
+
+export interface GetTapeRequest {}
+export const GetTapeRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}).pipe(T.Http({ method: "GET", uri: "/tape", code: 200 })),
+).annotate({ identifier: "GetTapeRequest" }) as any as S.Schema<GetTapeRequest>;
+
+export interface GetTapeResponse {}
+export const GetTapeResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "GetTapeResponse",
+}) as any as S.Schema<GetTapeResponse>;
+
+export interface GetTapeChangerRequest {
+  name: string;
+}
+export const GetTapeChangerRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    name: S.String.pipe(T.Label()),
+  }).pipe(T.Http({ method: "GET", uri: "/tape/changer/{name}", code: 200 })),
+).annotate({
+  identifier: "GetTapeChangerRequest",
+}) as any as S.Schema<GetTapeChangerRequest>;
+
+export interface GetTapeChangerResponse {}
+export const GetTapeChangerResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "GetTapeChangerResponse",
+}) as any as S.Schema<GetTapeChangerResponse>;
+
+export interface GetTapeDriveRequest {
+  drive: string;
+}
+export const GetTapeDriveRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    drive: S.String.pipe(T.Label()),
+  }).pipe(T.Http({ method: "GET", uri: "/tape/drive/{drive}", code: 200 })),
+).annotate({
+  identifier: "GetTapeDriveRequest",
+}) as any as S.Schema<GetTapeDriveRequest>;
+
+export interface GetTapeDriveResponse {}
+export const GetTapeDriveResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "GetTapeDriveResponse",
+}) as any as S.Schema<GetTapeDriveResponse>;
+
+export interface GetTapeDriveReadLabelRequest {
+  drive: string;
+  /** Inventorize media */
+  inventorize?: string;
+}
+export const GetTapeDriveReadLabelRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    drive: S.String.pipe(T.Label()),
+    inventorize: S.optional(S.String.pipe(T.Query())),
+  }).pipe(
+    T.Http({ method: "GET", uri: "/tape/drive/{drive}/read-label", code: 200 }),
+  ),
+).annotate({
+  identifier: "GetTapeDriveReadLabelRequest",
+}) as any as S.Schema<GetTapeDriveReadLabelRequest>;
+
+export interface GetTapeDriveReadLabelResponse {
+  ctime: number;
+  encryption_key_fingerprint?: string;
+  label_text?: string;
+  media_set_ctime?: number;
+  media_set_uuid?: string;
+  pool?: string;
+  seq_nr?: number;
+  uuid: string;
+}
+export const GetTapeDriveReadLabelResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    ctime: S.Number,
+    encryption_key_fingerprint: S.optional(
+      S.String.pipe(T.Body("encryption-key-fingerprint")),
+    ),
+    label_text: S.optional(S.String.pipe(T.Body("label-text"))),
+    media_set_ctime: S.optional(S.Number.pipe(T.Body("media-set-ctime"))),
+    media_set_uuid: S.optional(S.String.pipe(T.Body("media-set-uuid"))),
+    pool: S.optional(S.String),
+    seq_nr: S.optional(S.Number.pipe(T.Body("seq-nr"))),
+    uuid: S.String,
+  }),
+).annotate({
+  identifier: "GetTapeDriveReadLabelResponse",
+}) as any as S.Schema<GetTapeDriveReadLabelResponse>;
+
+export interface GetTapeDriveStatusRequest {
+  drive: string;
+}
+export const GetTapeDriveStatusRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    drive: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({ method: "GET", uri: "/tape/drive/{drive}/status", code: 200 }),
+  ),
+).annotate({
+  identifier: "GetTapeDriveStatusRequest",
+}) as any as S.Schema<GetTapeDriveStatusRequest>;
+
+export type GetTapeDriveStatusResponseDensity =
+  | "Unknown"
+  | "LTO1"
+  | "LTO2"
+  | "LTO3"
+  | "LTO4"
+  | "LTO5"
+  | "LTO6"
+  | "LTO7"
+  | "LTO7M8"
+  | "LTO8"
+  | "LTO9";
+export const GetTapeDriveStatusResponseDensity = S.String;
+
+export type GetTapeDriveStatusResponseDriveActivity =
+  | "no-activity"
+  | "cleaning"
+  | "loading"
+  | "unloading"
+  | "other"
+  | "reading"
+  | "writing"
+  | "locating"
+  | "rewinding"
+  | "erasing"
+  | "formatting"
+  | "calibrating"
+  | "other-d-t"
+  | "microcode-update"
+  | "reading-encrypted"
+  | "writing-encrypted";
+export const GetTapeDriveStatusResponseDriveActivity = S.String;
+
+export interface GetTapeDriveStatusResponse {
+  alert_flags?: string;
+  block_number?: number;
+  blocksize: number;
+  buffer_mode?: number;
+  bytes_read?: number;
+  bytes_written?: number;
+  compression: unknown;
+  density?: GetTapeDriveStatusResponseDensity;
+  drive_activity?: GetTapeDriveStatusResponseDriveActivity;
+  file_number?: number;
+  manufactured?: number;
+  medium_passes?: number;
+  medium_wearout?: number;
+  product: string;
+  revision: string;
+  vendor: string;
+  volume_mounts?: number;
+  write_protect?: unknown;
+}
+export const GetTapeDriveStatusResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    alert_flags: S.optional(S.String.pipe(T.Body("alert-flags"))),
+    block_number: S.optional(S.Number.pipe(T.Body("block-number"))),
+    blocksize: S.Number,
+    buffer_mode: S.optional(S.Number.pipe(T.Body("buffer-mode"))),
+    bytes_read: S.optional(S.Number.pipe(T.Body("bytes-read"))),
+    bytes_written: S.optional(S.Number.pipe(T.Body("bytes-written"))),
+    compression: S.Unknown,
+    density: S.optional(GetTapeDriveStatusResponseDensity),
+    drive_activity: S.optional(
+      GetTapeDriveStatusResponseDriveActivity.pipe(T.Body("drive-activity")),
+    ),
+    file_number: S.optional(S.Number.pipe(T.Body("file-number"))),
+    manufactured: S.optional(S.Number),
+    medium_passes: S.optional(S.Number.pipe(T.Body("medium-passes"))),
+    medium_wearout: S.optional(S.Number.pipe(T.Body("medium-wearout"))),
+    product: S.String,
+    revision: S.String,
+    vendor: S.String,
+    volume_mounts: S.optional(S.Number.pipe(T.Body("volume-mounts"))),
+    write_protect: S.optional(S.Unknown.pipe(T.Body("write-protect"))),
+  }),
+).annotate({
+  identifier: "GetTapeDriveStatusResponse",
+}) as any as S.Schema<GetTapeDriveStatusResponse>;
+
+export interface GetTapeDriveVolumeStatisticsRequest {
+  drive: string;
+}
+export const GetTapeDriveVolumeStatisticsRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    drive: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/tape/drive/{drive}/volume-statistics",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "GetTapeDriveVolumeStatisticsRequest",
+}) as any as S.Schema<GetTapeDriveVolumeStatisticsRequest>;
+
+export interface GetTapeDriveVolumeStatisticsResponse {
+  beginning_of_medium_passes?: number;
+  last_load_read_compression_ratio?: number;
+  last_load_write_compression_ratio?: number;
+  last_mount_bytes_read?: number;
+  last_mount_bytes_written?: number;
+  last_mount_unrecovered_read_errors?: number;
+  last_mount_unrecovered_write_errors?: number;
+  lifetime_bytes_read?: number;
+  lifetime_bytes_written?: number;
+  medium_mount_time?: number;
+  medium_ready_time?: number;
+  middle_of_tape_passes?: number;
+  serial: string;
+  total_native_capacity?: number;
+  total_used_native_capacity?: number;
+  volume_datasets_read?: number;
+  volume_datasets_written?: number;
+  volume_mounts?: number;
+  volume_recovered_read_errors?: number;
+  volume_recovered_write_data_errors?: number;
+  volume_unrecovered_read_errors?: number;
+  volume_unrecovered_write_data_errors?: number;
+  volume_unrecovered_write_servo_errors?: number;
+  volume_write_servo_errors?: number;
+  worm: unknown;
+  write_protect?: unknown;
+}
+export const GetTapeDriveVolumeStatisticsResponse = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      beginning_of_medium_passes: S.optional(
+        S.Number.pipe(T.Body("beginning-of-medium-passes")),
+      ),
+      last_load_read_compression_ratio: S.optional(
+        S.Number.pipe(T.Body("last-load-read-compression-ratio")),
+      ),
+      last_load_write_compression_ratio: S.optional(
+        S.Number.pipe(T.Body("last-load-write-compression-ratio")),
+      ),
+      last_mount_bytes_read: S.optional(
+        S.Number.pipe(T.Body("last-mount-bytes-read")),
+      ),
+      last_mount_bytes_written: S.optional(
+        S.Number.pipe(T.Body("last-mount-bytes-written")),
+      ),
+      last_mount_unrecovered_read_errors: S.optional(
+        S.Number.pipe(T.Body("last-mount-unrecovered-read-errors")),
+      ),
+      last_mount_unrecovered_write_errors: S.optional(
+        S.Number.pipe(T.Body("last-mount-unrecovered-write-errors")),
+      ),
+      lifetime_bytes_read: S.optional(
+        S.Number.pipe(T.Body("lifetime-bytes-read")),
+      ),
+      lifetime_bytes_written: S.optional(
+        S.Number.pipe(T.Body("lifetime-bytes-written")),
+      ),
+      medium_mount_time: S.optional(S.Number.pipe(T.Body("medium-mount-time"))),
+      medium_ready_time: S.optional(S.Number.pipe(T.Body("medium-ready-time"))),
+      middle_of_tape_passes: S.optional(
+        S.Number.pipe(T.Body("middle-of-tape-passes")),
+      ),
+      serial: S.String,
+      total_native_capacity: S.optional(
+        S.Number.pipe(T.Body("total-native-capacity")),
+      ),
+      total_used_native_capacity: S.optional(
+        S.Number.pipe(T.Body("total-used-native-capacity")),
+      ),
+      volume_datasets_read: S.optional(
+        S.Number.pipe(T.Body("volume-datasets-read")),
+      ),
+      volume_datasets_written: S.optional(
+        S.Number.pipe(T.Body("volume-datasets-written")),
+      ),
+      volume_mounts: S.optional(S.Number.pipe(T.Body("volume-mounts"))),
+      volume_recovered_read_errors: S.optional(
+        S.Number.pipe(T.Body("volume-recovered-read-errors")),
+      ),
+      volume_recovered_write_data_errors: S.optional(
+        S.Number.pipe(T.Body("volume-recovered-write-data-errors")),
+      ),
+      volume_unrecovered_read_errors: S.optional(
+        S.Number.pipe(T.Body("volume-unrecovered-read-errors")),
+      ),
+      volume_unrecovered_write_data_errors: S.optional(
+        S.Number.pipe(T.Body("volume-unrecovered-write-data-errors")),
+      ),
+      volume_unrecovered_write_servo_errors: S.optional(
+        S.Number.pipe(T.Body("volume-unrecovered-write-servo-errors")),
+      ),
+      volume_write_servo_errors: S.optional(
+        S.Number.pipe(T.Body("volume-write-servo-errors")),
+      ),
+      worm: S.Unknown,
+      write_protect: S.optional(S.Unknown.pipe(T.Body("write-protect"))),
+    }),
+).annotate({
+  identifier: "GetTapeDriveVolumeStatisticsResponse",
+}) as any as S.Schema<GetTapeDriveVolumeStatisticsResponse>;
+
+export interface GetTapeMediaRequest {}
+export const GetTapeMediaRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}).pipe(T.Http({ method: "GET", uri: "/tape/media", code: 200 })),
+).annotate({
+  identifier: "GetTapeMediaRequest",
+}) as any as S.Schema<GetTapeMediaRequest>;
+
+export interface GetTapeMediaResponse {}
+export const GetTapeMediaResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "GetTapeMediaResponse",
+}) as any as S.Schema<GetTapeMediaResponse>;
+
+export interface GetTapeMediaDestroyRequest {
+  /** Force removal (even if media is used in a media set). */
+  force?: string;
+  /** Media Label/Barcode. */
+  label_text?: string;
+  /** Media Uuid. */
+  uuid?: string;
+}
+export const GetTapeMediaDestroyRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    force: S.optional(S.String.pipe(T.Query())),
+    label_text: S.optional(S.String.pipe(T.Query("label-text"))),
+    uuid: S.optional(S.String.pipe(T.Query())),
+  }).pipe(T.Http({ method: "GET", uri: "/tape/media/destroy", code: 200 })),
+).annotate({
+  identifier: "GetTapeMediaDestroyRequest",
+}) as any as S.Schema<GetTapeMediaDestroyRequest>;
+
+export interface GetTapeMediaDestroyResponse {}
+export const GetTapeMediaDestroyResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "GetTapeMediaDestroyResponse",
+}) as any as S.Schema<GetTapeMediaDestroyResponse>;
+
+export interface GetTapeMediaListRequest {
+  uuid: string;
+}
+export const GetTapeMediaListRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    uuid: S.String.pipe(T.Label()),
+  }).pipe(T.Http({ method: "GET", uri: "/tape/media/list/{uuid}", code: 200 })),
+).annotate({
+  identifier: "GetTapeMediaListRequest",
+}) as any as S.Schema<GetTapeMediaListRequest>;
+
+export interface GetTapeMediaListResponse {}
+export const GetTapeMediaListResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "GetTapeMediaListResponse",
+}) as any as S.Schema<GetTapeMediaListResponse>;
+
+export interface GetTapeMediaListStatusRequest {
+  uuid: string;
+}
+export const GetTapeMediaListStatusRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    uuid: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({ method: "GET", uri: "/tape/media/list/{uuid}/status", code: 200 }),
+  ),
+).annotate({
+  identifier: "GetTapeMediaListStatusRequest",
+}) as any as S.Schema<GetTapeMediaListStatusRequest>;
+
+export interface GetTapeMediaListStatusResponse {}
+export const GetTapeMediaListStatusResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "GetTapeMediaListStatusResponse",
+}) as any as S.Schema<GetTapeMediaListStatusResponse>;
+
+export interface ListTapeBackupRequest {}
+export const ListTapeBackupRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}).pipe(T.Http({ method: "GET", uri: "/tape/backup", code: 200 })),
+).annotate({
+  identifier: "ListTapeBackupRequest",
+}) as any as S.Schema<ListTapeBackupRequest>;
+
+export type ListTapeBackupResponseBodyItemGroupFilterList = Array<string>;
+export const ListTapeBackupResponseBodyItemGroupFilterList =
+  /*@__PURE__*/ S.Array(
+    S.String,
+  ) as any as S.Schema<ListTapeBackupResponseBodyItemGroupFilterList>;
+
+export type ListTapeBackupResponseBodyItemNotificationMode =
+  | "legacy-sendmail"
+  | "notification-system";
+export const ListTapeBackupResponseBodyItemNotificationMode = S.String;
+
+export interface ListTapeBackupResponseBodyItem {
+  comment?: string;
+  drive: string;
+  eject_media?: unknown;
+  export_media_set?: unknown;
+  group_filter?: ListTapeBackupResponseBodyItemGroupFilterList;
+  id: string;
+  last_run_endtime?: number;
+  last_run_state?: string;
+  last_run_upid?: string;
+  latest_only?: unknown;
+  max_depth?: number;
+  next_media_label?: string;
+  next_run?: number;
+  notification_mode?: ListTapeBackupResponseBodyItemNotificationMode;
+  notify_user?: string;
+  ns?: string;
+  pool: string;
+  schedule?: string;
+  store: string;
+  worker_threads?: number;
+}
+export const ListTapeBackupResponseBodyItem = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    comment: S.optional(S.String),
+    drive: S.String,
+    eject_media: S.optional(S.Unknown.pipe(T.Body("eject-media"))),
+    export_media_set: S.optional(S.Unknown.pipe(T.Body("export-media-set"))),
+    group_filter: S.optional(
+      ListTapeBackupResponseBodyItemGroupFilterList.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"))),
+    latest_only: S.optional(S.Unknown.pipe(T.Body("latest-only"))),
+    max_depth: S.optional(S.Number.pipe(T.Body("max-depth"))),
+    next_media_label: S.optional(S.String.pipe(T.Body("next-media-label"))),
+    next_run: S.optional(S.Number.pipe(T.Body("next-run"))),
+    notification_mode: S.optional(
+      ListTapeBackupResponseBodyItemNotificationMode.pipe(
+        T.Body("notification-mode"),
+      ),
+    ),
+    notify_user: S.optional(S.String.pipe(T.Body("notify-user"))),
+    ns: S.optional(S.String),
+    pool: S.String,
+    schedule: S.optional(S.String),
+    store: S.String,
+    worker_threads: S.optional(S.Number.pipe(T.Body("worker-threads"))),
+  }),
+).annotate({
+  identifier: "ListTapeBackupResponseBodyItem",
+}) as any as S.Schema<ListTapeBackupResponseBodyItem>;
+
+export type ListTapeBackupResponseBodyList =
+  Array<ListTapeBackupResponseBodyItem>;
+export const ListTapeBackupResponseBodyList = /*@__PURE__*/ S.Array(
+  ListTapeBackupResponseBodyItem,
+) as any as S.Schema<ListTapeBackupResponseBodyList>;
+
+export type ListTapeBackupResponse = ListTapeBackupResponseBodyList;
+export const ListTapeBackupResponse = /*@__PURE__*/ S.suspend(() =>
+  ListTapeBackupResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListTapeBackupResponse",
+}) as any as S.Schema<ListTapeBackupResponse>;
+
+export interface ListTapeChangerRequest {}
+export const ListTapeChangerRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}).pipe(T.Http({ method: "GET", uri: "/tape/changer", code: 200 })),
+).annotate({
+  identifier: "ListTapeChangerRequest",
+}) as any as S.Schema<ListTapeChangerRequest>;
+
+export interface ListTapeChangerResponseBodyItem {
+  eject_before_unload?: unknown;
+  export_slots?: string;
+  model?: string;
+  name: string;
+  path: string;
+  serial?: string;
+  vendor?: string;
+}
+export const ListTapeChangerResponseBodyItem = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    eject_before_unload: S.optional(
+      S.Unknown.pipe(T.Body("eject-before-unload")),
+    ),
+    export_slots: S.optional(S.String.pipe(T.Body("export-slots"))),
+    model: S.optional(S.String),
+    name: S.String,
+    path: S.String,
+    serial: S.optional(S.String),
+    vendor: S.optional(S.String),
+  }),
+).annotate({
+  identifier: "ListTapeChangerResponseBodyItem",
+}) as any as S.Schema<ListTapeChangerResponseBodyItem>;
+
+export type ListTapeChangerResponseBodyList =
+  Array<ListTapeChangerResponseBodyItem>;
+export const ListTapeChangerResponseBodyList = /*@__PURE__*/ S.Array(
+  ListTapeChangerResponseBodyItem,
+) as any as S.Schema<ListTapeChangerResponseBodyList>;
+
+export type ListTapeChangerResponse = ListTapeChangerResponseBodyList;
+export const ListTapeChangerResponse = /*@__PURE__*/ S.suspend(() =>
+  ListTapeChangerResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListTapeChangerResponse",
+}) as any as S.Schema<ListTapeChangerResponse>;
+
+export interface ListTapeChangerStatusRequest {
+  name: string;
+  /** Use cached value. */
+  cache?: string;
+}
+export const ListTapeChangerStatusRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    name: S.String.pipe(T.Label()),
+    cache: S.optional(S.String.pipe(T.Query())),
+  }).pipe(
+    T.Http({ method: "GET", uri: "/tape/changer/{name}/status", code: 200 }),
+  ),
+).annotate({
+  identifier: "ListTapeChangerStatusRequest",
+}) as any as S.Schema<ListTapeChangerStatusRequest>;
+
+export type ListTapeChangerStatusResponseBodyItemEntryKind =
+  | "drive"
+  | "slot"
+  | "import-export";
+export const ListTapeChangerStatusResponseBodyItemEntryKind = S.String;
+
+export interface ListTapeChangerStatusResponseBodyItem {
+  entry_id?: number;
+  entry_kind?: ListTapeChangerStatusResponseBodyItemEntryKind;
+  label_text?: string;
+  loaded_slot?: number;
+  state?: string;
+}
+export const ListTapeChangerStatusResponseBodyItem = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      entry_id: S.optional(S.Number.pipe(T.Body("entry-id"))),
+      entry_kind: S.optional(
+        ListTapeChangerStatusResponseBodyItemEntryKind.pipe(
+          T.Body("entry-kind"),
+        ),
+      ),
+      label_text: S.optional(S.String.pipe(T.Body("label-text"))),
+      loaded_slot: S.optional(S.Number.pipe(T.Body("loaded-slot"))),
+      state: S.optional(S.String),
+    }),
+).annotate({
+  identifier: "ListTapeChangerStatusResponseBodyItem",
+}) as any as S.Schema<ListTapeChangerStatusResponseBodyItem>;
+
+export type ListTapeChangerStatusResponseBodyList =
+  Array<ListTapeChangerStatusResponseBodyItem>;
+export const ListTapeChangerStatusResponseBodyList = /*@__PURE__*/ S.Array(
+  ListTapeChangerStatusResponseBodyItem,
+) as any as S.Schema<ListTapeChangerStatusResponseBodyList>;
+
+export type ListTapeChangerStatusResponse =
+  ListTapeChangerStatusResponseBodyList;
+export const ListTapeChangerStatusResponse = /*@__PURE__*/ S.suspend(() =>
+  ListTapeChangerStatusResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListTapeChangerStatusResponse",
+}) as any as S.Schema<ListTapeChangerStatusResponse>;
+
+export interface ListTapeDriveRequest {
+  /** Tape Changer Identifier. */
+  changer?: string;
+  /** If true, queries and returns the drive activity for each drive. */
+  query_activity?: string;
+}
+export const ListTapeDriveRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    changer: S.optional(S.String.pipe(T.Query())),
+    query_activity: S.optional(S.String.pipe(T.Query("query-activity"))),
+  }).pipe(T.Http({ method: "GET", uri: "/tape/drive", code: 200 })),
+).annotate({
+  identifier: "ListTapeDriveRequest",
+}) as any as S.Schema<ListTapeDriveRequest>;
+
+export type ListTapeDriveResponseBodyItemActivity =
+  | "no-activity"
+  | "cleaning"
+  | "loading"
+  | "unloading"
+  | "other"
+  | "reading"
+  | "writing"
+  | "locating"
+  | "rewinding"
+  | "erasing"
+  | "formatting"
+  | "calibrating"
+  | "other-d-t"
+  | "microcode-update"
+  | "reading-encrypted"
+  | "writing-encrypted";
+export const ListTapeDriveResponseBodyItemActivity = S.String;
+
+export interface ListTapeDriveResponseBodyItem {
+  activity?: ListTapeDriveResponseBodyItemActivity;
+  changer?: string;
+  changer_drivenum?: number;
+  model?: string;
+  name: string;
+  path: string;
+  serial?: string;
+  state?: string;
+  vendor?: string;
+}
+export const ListTapeDriveResponseBodyItem = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    activity: S.optional(ListTapeDriveResponseBodyItemActivity),
+    changer: S.optional(S.String),
+    changer_drivenum: S.optional(S.Number.pipe(T.Body("changer-drivenum"))),
+    model: S.optional(S.String),
+    name: S.String,
+    path: S.String,
+    serial: S.optional(S.String),
+    state: S.optional(S.String),
+    vendor: S.optional(S.String),
+  }),
+).annotate({
+  identifier: "ListTapeDriveResponseBodyItem",
+}) as any as S.Schema<ListTapeDriveResponseBodyItem>;
+
+export type ListTapeDriveResponseBodyList =
+  Array<ListTapeDriveResponseBodyItem>;
+export const ListTapeDriveResponseBodyList = /*@__PURE__*/ S.Array(
+  ListTapeDriveResponseBodyItem,
+) as any as S.Schema<ListTapeDriveResponseBodyList>;
+
+export type ListTapeDriveResponse = ListTapeDriveResponseBodyList;
+export const ListTapeDriveResponse = /*@__PURE__*/ S.suspend(() =>
+  ListTapeDriveResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListTapeDriveResponse",
+}) as any as S.Schema<ListTapeDriveResponse>;
+
+export interface ListTapeDriveCartridgeMemoryRequest {
+  drive: string;
+}
+export const ListTapeDriveCartridgeMemoryRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    drive: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/tape/drive/{drive}/cartridge-memory",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "ListTapeDriveCartridgeMemoryRequest",
+}) as any as S.Schema<ListTapeDriveCartridgeMemoryRequest>;
+
+export interface ListTapeDriveCartridgeMemoryResponseBodyItem {
+  id: number;
+  name: string;
+  value: string;
+}
+export const ListTapeDriveCartridgeMemoryResponseBodyItem =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      id: S.Number,
+      name: S.String,
+      value: S.String,
+    }),
+  ).annotate({
+    identifier: "ListTapeDriveCartridgeMemoryResponseBodyItem",
+  }) as any as S.Schema<ListTapeDriveCartridgeMemoryResponseBodyItem>;
+
+export type ListTapeDriveCartridgeMemoryResponseBodyList =
+  Array<ListTapeDriveCartridgeMemoryResponseBodyItem>;
+export const ListTapeDriveCartridgeMemoryResponseBodyList =
+  /*@__PURE__*/ S.Array(
+    ListTapeDriveCartridgeMemoryResponseBodyItem,
+  ) as any as S.Schema<ListTapeDriveCartridgeMemoryResponseBodyList>;
+
+export type ListTapeDriveCartridgeMemoryResponse =
+  ListTapeDriveCartridgeMemoryResponseBodyList;
+export const ListTapeDriveCartridgeMemoryResponse = /*@__PURE__*/ S.suspend(
+  () => ListTapeDriveCartridgeMemoryResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListTapeDriveCartridgeMemoryResponse",
+}) as any as S.Schema<ListTapeDriveCartridgeMemoryResponse>;
+
+export interface ListTapeDriveInventoryRequest {
+  drive: string;
+}
+export const ListTapeDriveInventoryRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    drive: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({ method: "GET", uri: "/tape/drive/{drive}/inventory", code: 200 }),
+  ),
+).annotate({
+  identifier: "ListTapeDriveInventoryRequest",
+}) as any as S.Schema<ListTapeDriveInventoryRequest>;
+
+export interface ListTapeDriveInventoryResponseBodyItem {
+  label_text?: string;
+  uuid?: string;
+}
+export const ListTapeDriveInventoryResponseBodyItem = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      label_text: S.optional(S.String.pipe(T.Body("label-text"))),
+      uuid: S.optional(S.String),
+    }),
+).annotate({
+  identifier: "ListTapeDriveInventoryResponseBodyItem",
+}) as any as S.Schema<ListTapeDriveInventoryResponseBodyItem>;
+
+export type ListTapeDriveInventoryResponseBodyList =
+  Array<ListTapeDriveInventoryResponseBodyItem>;
+export const ListTapeDriveInventoryResponseBodyList = /*@__PURE__*/ S.Array(
+  ListTapeDriveInventoryResponseBodyItem,
+) as any as S.Schema<ListTapeDriveInventoryResponseBodyList>;
+
+export type ListTapeDriveInventoryResponse =
+  ListTapeDriveInventoryResponseBodyList;
+export const ListTapeDriveInventoryResponse = /*@__PURE__*/ S.suspend(() =>
+  ListTapeDriveInventoryResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListTapeDriveInventoryResponse",
+}) as any as S.Schema<ListTapeDriveInventoryResponse>;
+
+export type ListTapeMediaContentRequestBackupType = "vm" | "ct" | "host";
+export const ListTapeMediaContentRequestBackupType = S.String;
+
+export interface ListTapeMediaContentRequest {
+  /** Backup ID. */
+  backup_id?: string;
+  /** Backup types. */
+  backup_type?: ListTapeMediaContentRequestBackupType | (string & {});
+  /** Media Label/Barcode. */
+  label_text?: string;
+  /** Media Uuid. */
+  media?: string;
+  /** MediaSet Uuid (We use the all-zero Uuid to reserve an empty media for a specific pool). */
+  media_set?: string;
+  /** Media pool name. */
+  pool?: string;
+}
+export const ListTapeMediaContentRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    backup_id: S.optional(S.String.pipe(T.Query("backup-id"))),
+    backup_type: S.optional(
+      ListTapeMediaContentRequestBackupType.pipe(T.Query("backup-type")),
+    ),
+    label_text: S.optional(S.String.pipe(T.Query("label-text"))),
+    media: S.optional(S.String.pipe(T.Query())),
+    media_set: S.optional(S.String.pipe(T.Query("media-set"))),
+    pool: S.optional(S.String.pipe(T.Query())),
+  }).pipe(T.Http({ method: "GET", uri: "/tape/media/content", code: 200 })),
+).annotate({
+  identifier: "ListTapeMediaContentRequest",
+}) as any as S.Schema<ListTapeMediaContentRequest>;
+
+export interface ListTapeMediaContentResponseBodyItem {
+  backup_time?: number;
+  label_text?: string;
+  media_set_ctime?: number;
+  media_set_name?: string;
+  media_set_uuid?: string;
+  pool: string;
+  seq_nr?: number;
+  snapshot: string;
+  store: string;
+  uuid: string;
+}
+export const ListTapeMediaContentResponseBodyItem = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      backup_time: S.optional(S.Number.pipe(T.Body("backup-time"))),
+      label_text: S.optional(S.String.pipe(T.Body("label-text"))),
+      media_set_ctime: S.optional(S.Number.pipe(T.Body("media-set-ctime"))),
+      media_set_name: S.optional(S.String.pipe(T.Body("media-set-name"))),
+      media_set_uuid: S.optional(S.String.pipe(T.Body("media-set-uuid"))),
+      pool: S.String,
+      seq_nr: S.optional(S.Number.pipe(T.Body("seq-nr"))),
+      snapshot: S.String,
+      store: S.String,
+      uuid: S.String,
+    }),
+).annotate({
+  identifier: "ListTapeMediaContentResponseBodyItem",
+}) as any as S.Schema<ListTapeMediaContentResponseBodyItem>;
+
+export type ListTapeMediaContentResponseBodyList =
+  Array<ListTapeMediaContentResponseBodyItem>;
+export const ListTapeMediaContentResponseBodyList = /*@__PURE__*/ S.Array(
+  ListTapeMediaContentResponseBodyItem,
+) as any as S.Schema<ListTapeMediaContentResponseBodyList>;
+
+export type ListTapeMediaContentResponse = ListTapeMediaContentResponseBodyList;
+export const ListTapeMediaContentResponse = /*@__PURE__*/ S.suspend(() =>
+  ListTapeMediaContentResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListTapeMediaContentResponse",
+}) as any as S.Schema<ListTapeMediaContentResponse>;
+
+export interface ListTapeMediaListRequest {
+  /** Media pool name. */
+  pool?: string;
+  /** Try to update tape library status (check what tapes are online). */
+  update_status?: string;
+  /** Tape Changer Identifier. */
+  update_status_changer?: string;
+}
+export const ListTapeMediaListRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    pool: S.optional(S.String.pipe(T.Query())),
+    update_status: S.optional(S.String.pipe(T.Query("update-status"))),
+    update_status_changer: S.optional(
+      S.String.pipe(T.Query("update-status-changer")),
+    ),
+  }).pipe(T.Http({ method: "GET", uri: "/tape/media/list", code: 200 })),
+).annotate({
+  identifier: "ListTapeMediaListRequest",
+}) as any as S.Schema<ListTapeMediaListRequest>;
+
+export type ListTapeMediaListResponseBodyItemStatus =
+  | "writable"
+  | "full"
+  | "unknown"
+  | "damaged"
+  | "retired";
+export const ListTapeMediaListResponseBodyItemStatus = S.String;
+
+export interface ListTapeMediaListResponseBodyItem {
+  bytes_used?: number;
+  catalog: unknown;
+  ctime: number;
+  expired: unknown;
+  label_text?: string;
+  location: string;
+  media_set_ctime?: number;
+  media_set_name?: string;
+  media_set_uuid?: string;
+  pool?: string;
+  seq_nr?: number;
+  status: ListTapeMediaListResponseBodyItemStatus;
+  uuid: string;
+}
+export const ListTapeMediaListResponseBodyItem = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    bytes_used: S.optional(S.Number.pipe(T.Body("bytes-used"))),
+    catalog: S.Unknown,
+    ctime: S.Number,
+    expired: S.Unknown,
+    label_text: S.optional(S.String.pipe(T.Body("label-text"))),
+    location: S.String,
+    media_set_ctime: S.optional(S.Number.pipe(T.Body("media-set-ctime"))),
+    media_set_name: S.optional(S.String.pipe(T.Body("media-set-name"))),
+    media_set_uuid: S.optional(S.String.pipe(T.Body("media-set-uuid"))),
+    pool: S.optional(S.String),
+    seq_nr: S.optional(S.Number.pipe(T.Body("seq-nr"))),
+    status: ListTapeMediaListResponseBodyItemStatus,
+    uuid: S.String,
+  }),
+).annotate({
+  identifier: "ListTapeMediaListResponseBodyItem",
+}) as any as S.Schema<ListTapeMediaListResponseBodyItem>;
+
+export type ListTapeMediaListResponseBodyList =
+  Array<ListTapeMediaListResponseBodyItem>;
+export const ListTapeMediaListResponseBodyList = /*@__PURE__*/ S.Array(
+  ListTapeMediaListResponseBodyItem,
+) as any as S.Schema<ListTapeMediaListResponseBodyList>;
+
+export type ListTapeMediaListResponse = ListTapeMediaListResponseBodyList;
+export const ListTapeMediaListResponse = /*@__PURE__*/ S.suspend(() =>
+  ListTapeMediaListResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListTapeMediaListResponse",
+}) as any as S.Schema<ListTapeMediaListResponse>;
+
+export interface ListTapeMediaMediaSetsRequest {}
+export const ListTapeMediaMediaSetsRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}).pipe(
+    T.Http({ method: "GET", uri: "/tape/media/media-sets", code: 200 }),
+  ),
+).annotate({
+  identifier: "ListTapeMediaMediaSetsRequest",
+}) as any as S.Schema<ListTapeMediaMediaSetsRequest>;
+
+export interface ListTapeMediaMediaSetsResponseBodyItem {
+  media_set_ctime?: number;
+  media_set_name?: string;
+  media_set_uuid?: string;
+  pool: string;
+}
+export const ListTapeMediaMediaSetsResponseBodyItem = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      media_set_ctime: S.optional(S.Number.pipe(T.Body("media-set-ctime"))),
+      media_set_name: S.optional(S.String.pipe(T.Body("media-set-name"))),
+      media_set_uuid: S.optional(S.String.pipe(T.Body("media-set-uuid"))),
+      pool: S.String,
+    }),
+).annotate({
+  identifier: "ListTapeMediaMediaSetsResponseBodyItem",
+}) as any as S.Schema<ListTapeMediaMediaSetsResponseBodyItem>;
+
+export type ListTapeMediaMediaSetsResponseBodyList =
+  Array<ListTapeMediaMediaSetsResponseBodyItem>;
+export const ListTapeMediaMediaSetsResponseBodyList = /*@__PURE__*/ S.Array(
+  ListTapeMediaMediaSetsResponseBodyItem,
+) as any as S.Schema<ListTapeMediaMediaSetsResponseBodyList>;
+
+export type ListTapeMediaMediaSetsResponse =
+  ListTapeMediaMediaSetsResponseBodyList;
+export const ListTapeMediaMediaSetsResponse = /*@__PURE__*/ S.suspend(() =>
+  ListTapeMediaMediaSetsResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListTapeMediaMediaSetsResponse",
+}) as any as S.Schema<ListTapeMediaMediaSetsResponse>;
+
+export interface ListTapeScanChangersRequest {}
+export const ListTapeScanChangersRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}).pipe(
+    T.Http({ method: "GET", uri: "/tape/scan-changers", code: 200 }),
+  ),
+).annotate({
+  identifier: "ListTapeScanChangersRequest",
+}) as any as S.Schema<ListTapeScanChangersRequest>;
+
+export type ListTapeScanChangersResponseBodyItemKind = "changer" | "tape";
+export const ListTapeScanChangersResponseBodyItemKind = S.String;
+
+export interface ListTapeScanChangersResponseBodyItem {
+  kind: ListTapeScanChangersResponseBodyItemKind;
+  major: number;
+  minor: number;
+  model: string;
+  path: string;
+  serial: string;
+  vendor: string;
+}
+export const ListTapeScanChangersResponseBodyItem = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      kind: ListTapeScanChangersResponseBodyItemKind,
+      major: S.Number,
+      minor: S.Number,
+      model: S.String,
+      path: S.String,
+      serial: S.String,
+      vendor: S.String,
+    }),
+).annotate({
+  identifier: "ListTapeScanChangersResponseBodyItem",
+}) as any as S.Schema<ListTapeScanChangersResponseBodyItem>;
+
+export type ListTapeScanChangersResponseBodyList =
+  Array<ListTapeScanChangersResponseBodyItem>;
+export const ListTapeScanChangersResponseBodyList = /*@__PURE__*/ S.Array(
+  ListTapeScanChangersResponseBodyItem,
+) as any as S.Schema<ListTapeScanChangersResponseBodyList>;
+
+export type ListTapeScanChangersResponse = ListTapeScanChangersResponseBodyList;
+export const ListTapeScanChangersResponse = /*@__PURE__*/ S.suspend(() =>
+  ListTapeScanChangersResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListTapeScanChangersResponse",
+}) as any as S.Schema<ListTapeScanChangersResponse>;
+
+export interface ListTapeScanDrivesRequest {}
+export const ListTapeScanDrivesRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}).pipe(
+    T.Http({ method: "GET", uri: "/tape/scan-drives", code: 200 }),
+  ),
+).annotate({
+  identifier: "ListTapeScanDrivesRequest",
+}) as any as S.Schema<ListTapeScanDrivesRequest>;
+
+export type ListTapeScanDrivesResponseBodyItemKind = "changer" | "tape";
+export const ListTapeScanDrivesResponseBodyItemKind = S.String;
+
+export interface ListTapeScanDrivesResponseBodyItem {
+  kind: ListTapeScanDrivesResponseBodyItemKind;
+  major: number;
+  minor: number;
+  model: string;
+  path: string;
+  serial: string;
+  vendor: string;
+}
+export const ListTapeScanDrivesResponseBodyItem = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    kind: ListTapeScanDrivesResponseBodyItemKind,
+    major: S.Number,
+    minor: S.Number,
+    model: S.String,
+    path: S.String,
+    serial: S.String,
+    vendor: S.String,
+  }),
+).annotate({
+  identifier: "ListTapeScanDrivesResponseBodyItem",
+}) as any as S.Schema<ListTapeScanDrivesResponseBodyItem>;
+
+export type ListTapeScanDrivesResponseBodyList =
+  Array<ListTapeScanDrivesResponseBodyItem>;
+export const ListTapeScanDrivesResponseBodyList = /*@__PURE__*/ S.Array(
+  ListTapeScanDrivesResponseBodyItem,
+) as any as S.Schema<ListTapeScanDrivesResponseBodyList>;
+
+export type ListTapeScanDrivesResponse = ListTapeScanDrivesResponseBodyList;
+export const ListTapeScanDrivesResponse = /*@__PURE__*/ S.suspend(() =>
+  ListTapeScanDrivesResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListTapeScanDrivesResponse",
+}) as any as S.Schema<ListTapeScanDrivesResponse>;
+
+export interface MoveTapeMediaRequest {
+  /** Media Label/Barcode. */
+  label_text?: string;
+  /** Media Uuid. */
+  uuid?: string;
+  /** Vault name. */
+  vault_name?: string;
+}
+export const MoveTapeMediaRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    label_text: S.optional(S.String.pipe(T.Body("label-text"))),
+    uuid: S.optional(S.String),
+    vault_name: S.optional(S.String.pipe(T.Body("vault-name"))),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/tape/media/move",
+      code: 200,
+      contentType: "form-urlencoded",
+    }),
+  ),
+).annotate({
+  identifier: "MoveTapeMediaRequest",
+}) as any as S.Schema<MoveTapeMediaRequest>;
+
+export interface MoveTapeMediaResponse {}
+export const MoveTapeMediaResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "MoveTapeMediaResponse",
+}) as any as S.Schema<MoveTapeMediaResponse>;
+
+export interface PutTapeDriveCleanRequest {
+  drive: string;
+}
+export const PutTapeDriveCleanRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    drive: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({ method: "PUT", uri: "/tape/drive/{drive}/clean", code: 200 }),
+  ),
+).annotate({
+  identifier: "PutTapeDriveCleanRequest",
+}) as any as S.Schema<PutTapeDriveCleanRequest>;
+
+export type PutTapeDriveCleanResponse = string;
+export const PutTapeDriveCleanResponse = /*@__PURE__*/ S.suspend(() =>
+  S.String.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "PutTapeDriveCleanResponse",
+}) as any as S.Schema<PutTapeDriveCleanResponse>;
+
+export interface PutTapeDriveExportMediaRequest {
+  drive: string;
+  /** Media Label/Barcode. */
+  label_text: string;
+}
+export const PutTapeDriveExportMediaRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    drive: S.String.pipe(T.Label()),
+    label_text: S.String.pipe(T.Body("label-text")),
+  }).pipe(
+    T.Http({
+      method: "PUT",
+      uri: "/tape/drive/{drive}/export-media",
+      code: 200,
+      contentType: "form-urlencoded",
+    }),
+  ),
+).annotate({
+  identifier: "PutTapeDriveExportMediaRequest",
+}) as any as S.Schema<PutTapeDriveExportMediaRequest>;
+
+export type PutTapeDriveExportMediaResponse = number;
+export const PutTapeDriveExportMediaResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Number.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "PutTapeDriveExportMediaResponse",
+}) as any as S.Schema<PutTapeDriveExportMediaResponse>;
+
+export interface PutTapeDriveInventoryRequest {
+  drive: string;
+  /** Restore the catalog from tape. */
+  catalog?: string;
+  /** Load all tapes and try read labels (even if already inventoried) */
+  read_all_labels?: string;
+}
+export const PutTapeDriveInventoryRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    drive: S.String.pipe(T.Label()),
+    catalog: S.optional(S.String),
+    read_all_labels: S.optional(S.String.pipe(T.Body("read-all-labels"))),
+  }).pipe(
+    T.Http({
+      method: "PUT",
+      uri: "/tape/drive/{drive}/inventory",
+      code: 200,
+      contentType: "form-urlencoded",
+    }),
+  ),
+).annotate({
+  identifier: "PutTapeDriveInventoryRequest",
+}) as any as S.Schema<PutTapeDriveInventoryRequest>;
+
+export type PutTapeDriveInventoryResponse = string;
+export const PutTapeDriveInventoryResponse = /*@__PURE__*/ S.suspend(() =>
+  S.String.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "PutTapeDriveInventoryResponse",
+}) as any as S.Schema<PutTapeDriveInventoryResponse>;
+
+export type RestoreTapeRequestNamespacesList = Array<string>;
+export const RestoreTapeRequestNamespacesList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<RestoreTapeRequestNamespacesList>;
+
+export type RestoreTapeRequestNotificationMode =
+  | "legacy-sendmail"
+  | "notification-system";
+export const RestoreTapeRequestNotificationMode = S.String;
+
+export type RestoreTapeRequestSnapshotsList = Array<string>;
+export const RestoreTapeRequestSnapshotsList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<RestoreTapeRequestSnapshotsList>;
+
+export interface RestoreTapeRequest {
+  /** Drive Identifier. */
+  drive: string;
+  /** Media set UUID. */
+  media_set: string;
+  /** List of namespace to restore. */
+  namespaces?: RestoreTapeRequestNamespacesList;
+  /** Configure how notifications for this datastore should be sent. `legacy-sendmail` sends email notifications to the user configured in `notify-user` via the system's `sendmail` executable. `notification-system` emits matchable notification events to the notification system. */
+  notification_mode?: RestoreTapeRequestNotificationMode | (string & {});
+  /** User ID */
+  notify_user?: string;
+  /** Authentication ID */
+  owner?: string;
+  /** List of snapshots. */
+  snapshots?: RestoreTapeRequestSnapshotsList;
+  /** A list of Datastore mappings (or single datastore), comma separated. For example 'a=b,e' maps the source datastore 'a' to target 'b and all other sources to the default 'e'. If no default is given, only the specified sources are mapped. */
+  store: string;
+}
+export const RestoreTapeRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    drive: S.String,
+    media_set: S.String.pipe(T.Body("media-set")),
+    namespaces: S.optional(RestoreTapeRequestNamespacesList),
+    notification_mode: S.optional(
+      RestoreTapeRequestNotificationMode.pipe(T.Body("notification-mode")),
+    ),
+    notify_user: S.optional(S.String.pipe(T.Body("notify-user"))),
+    owner: S.optional(S.String),
+    snapshots: S.optional(RestoreTapeRequestSnapshotsList),
+    store: S.String,
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/tape/restore",
+      code: 200,
+      contentType: "form-urlencoded",
+    }),
+  ),
+).annotate({
+  identifier: "RestoreTapeRequest",
+}) as any as S.Schema<RestoreTapeRequest>;
+
+export type RestoreTapeResponse = string;
+export const RestoreTapeResponse = /*@__PURE__*/ S.suspend(() =>
+  S.String.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "RestoreTapeResponse",
+}) as any as S.Schema<RestoreTapeResponse>;
+
+export interface RestoreTapeDriveKeyRequest {
+  drive: string;
+  /** The password the key was encrypted with. */
+  password: string;
+}
+export const RestoreTapeDriveKeyRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    drive: S.String.pipe(T.Label()),
+    password: S.String,
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/tape/drive/{drive}/restore-key",
+      code: 200,
+      contentType: "form-urlencoded",
+    }),
+  ),
+).annotate({
+  identifier: "RestoreTapeDriveKeyRequest",
+}) as any as S.Schema<RestoreTapeDriveKeyRequest>;
+
+export interface RestoreTapeDriveKeyResponse {}
+export const RestoreTapeDriveKeyResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "RestoreTapeDriveKeyResponse",
+}) as any as S.Schema<RestoreTapeDriveKeyResponse>;
+
+export interface TransferTapeChangerRequest {
+  name: string;
+  /** Source slot number */
+  from: string;
+  /** Destination slot number */
+  to: string;
+}
+export const TransferTapeChangerRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    name: S.String.pipe(T.Label()),
+    from: S.String,
+    to: S.String,
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/tape/changer/{name}/transfer",
+      code: 200,
+      contentType: "form-urlencoded",
+    }),
+  ),
+).annotate({
+  identifier: "TransferTapeChangerRequest",
+}) as any as S.Schema<TransferTapeChangerRequest>;
+
+export interface TransferTapeChangerResponse {}
+export const TransferTapeChangerResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "TransferTapeChangerResponse",
+}) as any as S.Schema<TransferTapeChangerResponse>;
+
+export interface UpdateTapeBackupRequest {
+  id: string;
+}
+export const UpdateTapeBackupRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    id: S.String.pipe(T.Label()),
+  }).pipe(T.Http({ method: "POST", uri: "/tape/backup/{id}", code: 200 })),
+).annotate({
+  identifier: "UpdateTapeBackupRequest",
+}) as any as S.Schema<UpdateTapeBackupRequest>;
+
+export interface UpdateTapeBackupResponse {}
+export const UpdateTapeBackupResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "UpdateTapeBackupResponse",
+}) as any as S.Schema<UpdateTapeBackupResponse>;
+
+export type CreateTapeBackupError = ProxmoxBackupOpError;
+/** Backup datastore to tape media pool */
+export const createTapeBackup: API.OperationMethod<
+  CreateTapeBackupRequest,
+  CreateTapeBackupResponse,
+  CreateTapeBackupError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateTapeBackupRequest,
+  output: CreateTapeBackupResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateTapeDriveBarcodeLabelMediaError = ProxmoxBackupOpError;
+/** Label media with barcodes from changer device */
+export const createTapeDriveBarcodeLabelMedia: API.OperationMethod<
+  CreateTapeDriveBarcodeLabelMediaRequest,
+  CreateTapeDriveBarcodeLabelMediaResponse,
+  CreateTapeDriveBarcodeLabelMediaError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateTapeDriveBarcodeLabelMediaRequest,
+  output: CreateTapeDriveBarcodeLabelMediaResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateTapeDriveCatalogError = ProxmoxBackupOpError;
+/** Scan media and record content */
+export const createTapeDriveCatalog: API.OperationMethod<
+  CreateTapeDriveCatalogRequest,
+  CreateTapeDriveCatalogResponse,
+  CreateTapeDriveCatalogError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateTapeDriveCatalogRequest,
+  output: CreateTapeDriveCatalogResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateTapeDriveEjectMediaError = ProxmoxBackupOpError;
+/** Eject/Unload drive media */
+export const createTapeDriveEjectMedia: API.OperationMethod<
+  CreateTapeDriveEjectMediaRequest,
+  CreateTapeDriveEjectMediaResponse,
+  CreateTapeDriveEjectMediaError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateTapeDriveEjectMediaRequest,
+  output: CreateTapeDriveEjectMediaResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateTapeDriveFormatMediaError = ProxmoxBackupOpError;
+/** Format media. Check for label-text if given (cancels if wrong media). */
+export const createTapeDriveFormatMedia: API.OperationMethod<
+  CreateTapeDriveFormatMediaRequest,
+  CreateTapeDriveFormatMediaResponse,
+  CreateTapeDriveFormatMediaError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateTapeDriveFormatMediaRequest,
+  output: CreateTapeDriveFormatMediaResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateTapeDriveLabelMediaError = ProxmoxBackupOpError;
+/** Label media Write a new media label to the media in 'drive'. The media is assigned to the specified 'pool', or else to the free media pool. Note: The media need to be empty (you may want to format it first). */
+export const createTapeDriveLabelMedia: API.OperationMethod<
+  CreateTapeDriveLabelMediaRequest,
+  CreateTapeDriveLabelMediaResponse,
+  CreateTapeDriveLabelMediaError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateTapeDriveLabelMediaRequest,
+  output: CreateTapeDriveLabelMediaResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateTapeDriveLoadMediaError = ProxmoxBackupOpError;
+/** Load media with specified label Issue a media load request to the associated changer device. */
+export const createTapeDriveLoadMedia: API.OperationMethod<
+  CreateTapeDriveLoadMediaRequest,
+  CreateTapeDriveLoadMediaResponse,
+  CreateTapeDriveLoadMediaError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateTapeDriveLoadMediaRequest,
+  output: CreateTapeDriveLoadMediaResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateTapeDriveLoadSlotError = ProxmoxBackupOpError;
+/** Load media from the specified slot Issue a media load request to the associated changer device. */
+export const createTapeDriveLoadSlot: API.OperationMethod<
+  CreateTapeDriveLoadSlotRequest,
+  CreateTapeDriveLoadSlotResponse,
+  CreateTapeDriveLoadSlotError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateTapeDriveLoadSlotRequest,
+  output: CreateTapeDriveLoadSlotResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateTapeDriveRewindError = ProxmoxBackupOpError;
+/** Rewind tape */
+export const createTapeDriveRewind: API.OperationMethod<
+  CreateTapeDriveRewindRequest,
+  CreateTapeDriveRewindResponse,
+  CreateTapeDriveRewindError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateTapeDriveRewindRequest,
+  output: CreateTapeDriveRewindResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateTapeDriveUnloadError = ProxmoxBackupOpError;
+/** Unload media via changer */
+export const createTapeDriveUnload: API.OperationMethod<
+  CreateTapeDriveUnloadRequest,
+  CreateTapeDriveUnloadResponse,
+  CreateTapeDriveUnloadError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateTapeDriveUnloadRequest,
+  output: CreateTapeDriveUnloadResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateTapeMediaListStatusError = ProxmoxBackupOpError;
+/** Update media status (None, 'full', 'damaged' or 'retired') It is not allowed to set status to 'writable' or 'unknown' (those are internally managed states). */
+export const createTapeMediaListStatus: API.OperationMethod<
+  CreateTapeMediaListStatusRequest,
+  CreateTapeMediaListStatusResponse,
+  CreateTapeMediaListStatusError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateTapeMediaListStatusRequest,
+  output: CreateTapeMediaListStatusResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetTapeError = ProxmoxBackupOpError;
+/** Directory index. */
+export const getTape: API.OperationMethod<
+  GetTapeRequest,
+  GetTapeResponse,
+  GetTapeError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetTapeRequest,
+  output: GetTapeResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetTapeChangerError = ProxmoxBackupOpError;
+/** Directory index. */
+export const getTapeChanger: API.OperationMethod<
+  GetTapeChangerRequest,
+  GetTapeChangerResponse,
+  GetTapeChangerError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetTapeChangerRequest,
+  output: GetTapeChangerResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetTapeDriveError = ProxmoxBackupOpError;
+/** Directory index. */
+export const getTapeDrive: API.OperationMethod<
+  GetTapeDriveRequest,
+  GetTapeDriveResponse,
+  GetTapeDriveError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetTapeDriveRequest,
+  output: GetTapeDriveResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetTapeDriveReadLabelError = ProxmoxBackupOpError;
+/** Read media label (optionally inventorize media) */
+export const getTapeDriveReadLabel: API.OperationMethod<
+  GetTapeDriveReadLabelRequest,
+  GetTapeDriveReadLabelResponse,
+  GetTapeDriveReadLabelError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetTapeDriveReadLabelRequest,
+  output: GetTapeDriveReadLabelResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetTapeDriveStatusError = ProxmoxBackupOpError;
+/** Get drive/media status */
+export const getTapeDriveStatus: API.OperationMethod<
+  GetTapeDriveStatusRequest,
+  GetTapeDriveStatusResponse,
+  GetTapeDriveStatusError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetTapeDriveStatusRequest,
+  output: GetTapeDriveStatusResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetTapeDriveVolumeStatisticsError = ProxmoxBackupOpError;
+/** Read Volume Statistics (SCSI log page 17h) */
+export const getTapeDriveVolumeStatistics: API.OperationMethod<
+  GetTapeDriveVolumeStatisticsRequest,
+  GetTapeDriveVolumeStatisticsResponse,
+  GetTapeDriveVolumeStatisticsError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetTapeDriveVolumeStatisticsRequest,
+  output: GetTapeDriveVolumeStatisticsResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetTapeMediaError = ProxmoxBackupOpError;
+/** Directory index. */
+export const getTapeMedia: API.OperationMethod<
+  GetTapeMediaRequest,
+  GetTapeMediaResponse,
+  GetTapeMediaError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetTapeMediaRequest,
+  output: GetTapeMediaResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetTapeMediaDestroyError = ProxmoxBackupOpError;
+/** Destroy media (completely remove from database) */
+export const getTapeMediaDestroy: API.OperationMethod<
+  GetTapeMediaDestroyRequest,
+  GetTapeMediaDestroyResponse,
+  GetTapeMediaDestroyError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetTapeMediaDestroyRequest,
+  output: GetTapeMediaDestroyResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetTapeMediaListError = ProxmoxBackupOpError;
+/** Directory index. */
+export const getTapeMediaList: API.OperationMethod<
+  GetTapeMediaListRequest,
+  GetTapeMediaListResponse,
+  GetTapeMediaListError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetTapeMediaListRequest,
+  output: GetTapeMediaListResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetTapeMediaListStatusError = ProxmoxBackupOpError;
+/** Get current media status */
+export const getTapeMediaListStatus: API.OperationMethod<
+  GetTapeMediaListStatusRequest,
+  GetTapeMediaListStatusResponse,
+  GetTapeMediaListStatusError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetTapeMediaListStatusRequest,
+  output: GetTapeMediaListStatusResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListTapeBackupError = ProxmoxBackupOpError;
+/** List all tape backup jobs */
+export const listTapeBackup: API.OperationMethod<
+  ListTapeBackupRequest,
+  ListTapeBackupResponse,
+  ListTapeBackupError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListTapeBackupRequest,
+  output: ListTapeBackupResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListTapeChangerError = ProxmoxBackupOpError;
+/** List changers */
+export const listTapeChanger: API.OperationMethod<
+  ListTapeChangerRequest,
+  ListTapeChangerResponse,
+  ListTapeChangerError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListTapeChangerRequest,
+  output: ListTapeChangerResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListTapeChangerStatusError = ProxmoxBackupOpError;
+/** Get tape changer status */
+export const listTapeChangerStatus: API.OperationMethod<
+  ListTapeChangerStatusRequest,
+  ListTapeChangerStatusResponse,
+  ListTapeChangerStatusError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListTapeChangerStatusRequest,
+  output: ListTapeChangerStatusResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListTapeDriveError = ProxmoxBackupOpError;
+/** List drives */
+export const listTapeDrive: API.OperationMethod<
+  ListTapeDriveRequest,
+  ListTapeDriveResponse,
+  ListTapeDriveError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListTapeDriveRequest,
+  output: ListTapeDriveResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListTapeDriveCartridgeMemoryError = ProxmoxBackupOpError;
+/** Read Cartridge Memory (Medium auxiliary memory attributes) */
+export const listTapeDriveCartridgeMemory: API.OperationMethod<
+  ListTapeDriveCartridgeMemoryRequest,
+  ListTapeDriveCartridgeMemoryResponse,
+  ListTapeDriveCartridgeMemoryError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListTapeDriveCartridgeMemoryRequest,
+  output: ListTapeDriveCartridgeMemoryResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListTapeDriveInventoryError = ProxmoxBackupOpError;
+/** List known media labels (Changer Inventory) Note: Only useful for drives with associated changer device. This method queries the changer to get a list of media labels. Note: This updates the media online status. */
+export const listTapeDriveInventory: API.OperationMethod<
+  ListTapeDriveInventoryRequest,
+  ListTapeDriveInventoryResponse,
+  ListTapeDriveInventoryError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListTapeDriveInventoryRequest,
+  output: ListTapeDriveInventoryResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListTapeMediaContentError = ProxmoxBackupOpError;
+/** List media content */
+export const listTapeMediaContent: API.OperationMethod<
+  ListTapeMediaContentRequest,
+  ListTapeMediaContentResponse,
+  ListTapeMediaContentError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListTapeMediaContentRequest,
+  output: ListTapeMediaContentResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListTapeMediaListError = ProxmoxBackupOpError;
+/** List pool media */
+export const listTapeMediaList: API.OperationMethod<
+  ListTapeMediaListRequest,
+  ListTapeMediaListResponse,
+  ListTapeMediaListError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListTapeMediaListRequest,
+  output: ListTapeMediaListResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListTapeMediaMediaSetsError = ProxmoxBackupOpError;
+/** List Media sets */
+export const listTapeMediaMediaSets: API.OperationMethod<
+  ListTapeMediaMediaSetsRequest,
+  ListTapeMediaMediaSetsResponse,
+  ListTapeMediaMediaSetsError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListTapeMediaMediaSetsRequest,
+  output: ListTapeMediaMediaSetsResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListTapeScanChangersError = ProxmoxBackupOpError;
+/** Scan for SCSI tape changers */
+export const listTapeScanChangers: API.OperationMethod<
+  ListTapeScanChangersRequest,
+  ListTapeScanChangersResponse,
+  ListTapeScanChangersError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListTapeScanChangersRequest,
+  output: ListTapeScanChangersResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListTapeScanDrivesError = ProxmoxBackupOpError;
+/** Scan tape drives */
+export const listTapeScanDrives: API.OperationMethod<
+  ListTapeScanDrivesRequest,
+  ListTapeScanDrivesResponse,
+  ListTapeScanDrivesError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListTapeScanDrivesRequest,
+  output: ListTapeScanDrivesResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type MoveTapeMediaError = ProxmoxBackupOpError;
+/** Change Tape location to vault (if given), or offline. */
+export const moveTapeMedia: API.OperationMethod<
+  MoveTapeMediaRequest,
+  MoveTapeMediaResponse,
+  MoveTapeMediaError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: MoveTapeMediaRequest,
+  output: MoveTapeMediaResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type PutTapeDriveCleanError = ProxmoxBackupOpError;
+/** Clean drive */
+export const putTapeDriveClean: API.OperationMethod<
+  PutTapeDriveCleanRequest,
+  PutTapeDriveCleanResponse,
+  PutTapeDriveCleanError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PutTapeDriveCleanRequest,
+  output: PutTapeDriveCleanResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type PutTapeDriveExportMediaError = ProxmoxBackupOpError;
+/** Export media with specified label */
+export const putTapeDriveExportMedia: API.OperationMethod<
+  PutTapeDriveExportMediaRequest,
+  PutTapeDriveExportMediaResponse,
+  PutTapeDriveExportMediaError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PutTapeDriveExportMediaRequest,
+  output: PutTapeDriveExportMediaResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type PutTapeDriveInventoryError = ProxmoxBackupOpError;
+/** Update inventory Note: Only useful for drives with associated changer device. This method queries the changer to get a list of media labels. It then loads any unknown media into the drive, reads the label, and store the result to the media database. If `catalog` is true, also tries to restore the catalog from tape. Note: This updates the media online status. */
+export const putTapeDriveInventory: API.OperationMethod<
+  PutTapeDriveInventoryRequest,
+  PutTapeDriveInventoryResponse,
+  PutTapeDriveInventoryError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PutTapeDriveInventoryRequest,
+  output: PutTapeDriveInventoryResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type RestoreTapeError = ProxmoxBackupOpError;
+/** Restore data from media-set. Namespaces will be automatically created if necessary. */
+export const restoreTape: API.OperationMethod<
+  RestoreTapeRequest,
+  RestoreTapeResponse,
+  RestoreTapeError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: RestoreTapeRequest,
+  output: RestoreTapeResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type RestoreTapeDriveKeyError = ProxmoxBackupOpError;
+/** Try to restore a tape encryption key */
+export const restoreTapeDriveKey: API.OperationMethod<
+  RestoreTapeDriveKeyRequest,
+  RestoreTapeDriveKeyResponse,
+  RestoreTapeDriveKeyError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: RestoreTapeDriveKeyRequest,
+  output: RestoreTapeDriveKeyResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type TransferTapeChangerError = ProxmoxBackupOpError;
+/** Transfers media from one slot to another */
+export const transferTapeChanger: API.OperationMethod<
+  TransferTapeChangerRequest,
+  TransferTapeChangerResponse,
+  TransferTapeChangerError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: TransferTapeChangerRequest,
+  output: TransferTapeChangerResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type UpdateTapeBackupError = ProxmoxBackupOpError;
+/** Runs a tape backup job manually. */
+export const updateTapeBackup: API.OperationMethod<
+  UpdateTapeBackupRequest,
+  UpdateTapeBackupResponse,
+  UpdateTapeBackupError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: UpdateTapeBackupRequest,
+  output: UpdateTapeBackupResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));