@homeflare/distilled-proxmox-backup 0.2.0

package/src/services/nodes.ts

@@ -0,0 +1,4313 @@
+// 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 interface CreateNodeAptRepositoryRequest {
+  node: string;
+  /** Prevent changes if current configuration file has different SHA256 digest. This can be used to prevent concurrent modifications. */
+  digest?: string;
+  /** Whether the repository should be enabled or not. */
+  enabled?: string;
+  /** Index within the file (starting from 0). */
+  index: string;
+  /** Path to the containing file. */
+  path: string;
+}
+export const CreateNodeAptRepositoryRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    node: S.String.pipe(T.Label()),
+    digest: S.optional(S.String),
+    enabled: S.optional(S.String),
+    index: S.String,
+    path: S.String,
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/nodes/{node}/apt/repositories",
+      code: 200,
+      contentType: "form-urlencoded",
+    }),
+  ),
+).annotate({
+  identifier: "CreateNodeAptRepositoryRequest",
+}) as any as S.Schema<CreateNodeAptRepositoryRequest>;
+
+export interface CreateNodeAptRepositoryResponse {}
+export const CreateNodeAptRepositoryResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "CreateNodeAptRepositoryResponse",
+}) as any as S.Schema<CreateNodeAptRepositoryResponse>;
+
+export interface CreateNodeCertificateAcmeCertificateRequest {
+  node: string;
+  /** Force replacement of existing files. */
+  force?: string;
+}
+export const CreateNodeCertificateAcmeCertificateRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      node: S.String.pipe(T.Label()),
+      force: S.optional(S.String),
+    }).pipe(
+      T.Http({
+        method: "POST",
+        uri: "/nodes/{node}/certificates/acme/certificate",
+        code: 200,
+        contentType: "form-urlencoded",
+      }),
+    ),
+  ).annotate({
+    identifier: "CreateNodeCertificateAcmeCertificateRequest",
+  }) as any as S.Schema<CreateNodeCertificateAcmeCertificateRequest>;
+
+export interface CreateNodeCertificateAcmeCertificateResponse {}
+export const CreateNodeCertificateAcmeCertificateResponse =
+  /*@__PURE__*/ S.suspend(() => S.Struct({})).annotate({
+    identifier: "CreateNodeCertificateAcmeCertificateResponse",
+  }) as any as S.Schema<CreateNodeCertificateAcmeCertificateResponse>;
+
+export interface CreateNodeCertificateCustomRequest {
+  node: string;
+  /** PEM encoded certificate (chain). */
+  certificates: string;
+  /** Force replacement of existing files. */
+  force?: string;
+  /** PEM encoded private key. */
+  key?: string;
+  /** UI compatibility parameter, ignored */
+  restart?: string;
+}
+export const CreateNodeCertificateCustomRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    node: S.String.pipe(T.Label()),
+    certificates: S.String,
+    force: S.optional(S.String),
+    key: S.optional(S.String),
+    restart: S.optional(S.String),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/nodes/{node}/certificates/custom",
+      code: 200,
+      contentType: "form-urlencoded",
+    }),
+  ),
+).annotate({
+  identifier: "CreateNodeCertificateCustomRequest",
+}) as any as S.Schema<CreateNodeCertificateCustomRequest>;
+
+export type CreateNodeCertificateCustomResponseBodyItemSanList = Array<string>;
+export const CreateNodeCertificateCustomResponseBodyItemSanList =
+  /*@__PURE__*/ S.Array(
+    S.String,
+  ) as any as S.Schema<CreateNodeCertificateCustomResponseBodyItemSanList>;
+
+export interface CreateNodeCertificateCustomResponseBodyItem {
+  filename: string;
+  fingerprint?: string;
+  issuer: string;
+  notafter?: number;
+  notbefore?: number;
+  pem?: string;
+  public_key_bits?: number;
+  public_key_type?: string;
+  san: CreateNodeCertificateCustomResponseBodyItemSanList;
+  subject: string;
+}
+export const CreateNodeCertificateCustomResponseBodyItem =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      filename: S.String,
+      fingerprint: S.optional(S.String),
+      issuer: S.String,
+      notafter: S.optional(S.Number),
+      notbefore: S.optional(S.Number),
+      pem: S.optional(S.String),
+      public_key_bits: S.optional(S.Number.pipe(T.Body("public-key-bits"))),
+      public_key_type: S.optional(S.String.pipe(T.Body("public-key-type"))),
+      san: CreateNodeCertificateCustomResponseBodyItemSanList,
+      subject: S.String,
+    }),
+  ).annotate({
+    identifier: "CreateNodeCertificateCustomResponseBodyItem",
+  }) as any as S.Schema<CreateNodeCertificateCustomResponseBodyItem>;
+
+export type CreateNodeCertificateCustomResponseBodyList =
+  Array<CreateNodeCertificateCustomResponseBodyItem>;
+export const CreateNodeCertificateCustomResponseBodyList =
+  /*@__PURE__*/ S.Array(
+    CreateNodeCertificateCustomResponseBodyItem,
+  ) as any as S.Schema<CreateNodeCertificateCustomResponseBodyList>;
+
+export type CreateNodeCertificateCustomResponse =
+  CreateNodeCertificateCustomResponseBodyList;
+export const CreateNodeCertificateCustomResponse = /*@__PURE__*/ S.suspend(() =>
+  CreateNodeCertificateCustomResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "CreateNodeCertificateCustomResponse",
+}) as any as S.Schema<CreateNodeCertificateCustomResponse>;
+
+export type CreateNodeDiskDirectoryRequestFilesystem = "ext4" | "xfs";
+export const CreateNodeDiskDirectoryRequestFilesystem = S.String;
+
+export interface CreateNodeDiskDirectoryRequest {
+  node: string;
+  /** Configure a datastore using the directory. */
+  add_datastore?: string;
+  /** Block device name (/sys/block/<name>). */
+  disk: string;
+  /** A file system type supported by our tooling. */
+  filesystem?: CreateNodeDiskDirectoryRequestFilesystem | (string & {});
+  /** Datastore name. */
+  name: string;
+  /** The added datastore is removable. */
+  removable_datastore?: string;
+}
+export const CreateNodeDiskDirectoryRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    node: S.String.pipe(T.Label()),
+    add_datastore: S.optional(S.String.pipe(T.Body("add-datastore"))),
+    disk: S.String,
+    filesystem: S.optional(CreateNodeDiskDirectoryRequestFilesystem),
+    name: S.String,
+    removable_datastore: S.optional(
+      S.String.pipe(T.Body("removable-datastore")),
+    ),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/nodes/{node}/disks/directory",
+      code: 200,
+      contentType: "form-urlencoded",
+    }),
+  ),
+).annotate({
+  identifier: "CreateNodeDiskDirectoryRequest",
+}) as any as S.Schema<CreateNodeDiskDirectoryRequest>;
+
+export type CreateNodeDiskDirectoryResponse = string;
+export const CreateNodeDiskDirectoryResponse = /*@__PURE__*/ S.suspend(() =>
+  S.String.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "CreateNodeDiskDirectoryResponse",
+}) as any as S.Schema<CreateNodeDiskDirectoryResponse>;
+
+export interface CreateNodeDiskInitgptRequest {
+  node: string;
+  /** Block device name (/sys/block/<name>). */
+  disk: string;
+  /** UUID for the GPT table. */
+  uuid?: string;
+}
+export const CreateNodeDiskInitgptRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    node: S.String.pipe(T.Label()),
+    disk: S.String,
+    uuid: S.optional(S.String),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/nodes/{node}/disks/initgpt",
+      code: 200,
+      contentType: "form-urlencoded",
+    }),
+  ),
+).annotate({
+  identifier: "CreateNodeDiskInitgptRequest",
+}) as any as S.Schema<CreateNodeDiskInitgptRequest>;
+
+export type CreateNodeDiskInitgptResponse = string;
+export const CreateNodeDiskInitgptResponse = /*@__PURE__*/ S.suspend(() =>
+  S.String.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "CreateNodeDiskInitgptResponse",
+}) as any as S.Schema<CreateNodeDiskInitgptResponse>;
+
+export type CreateNodeDiskZfsRequestCompression =
+  | "gzip"
+  | "lz4"
+  | "lzjb"
+  | "zle"
+  | "zstd"
+  | "on"
+  | "off";
+export const CreateNodeDiskZfsRequestCompression = S.String;
+
+export type CreateNodeDiskZfsRequestRaidlevel =
+  | "single"
+  | "mirror"
+  | "raid10"
+  | "raidz"
+  | "raidz2"
+  | "raidz3";
+export const CreateNodeDiskZfsRequestRaidlevel = S.String;
+
+export interface CreateNodeDiskZfsRequest {
+  node: string;
+  /** Configure a datastore using the zpool. */
+  add_datastore?: string;
+  /** Pool sector size exponent. */
+  ashift?: string;
+  /** The ZFS compression algorithm to use. */
+  compression?: CreateNodeDiskZfsRequestCompression | (string & {});
+  /** A list of disk names, comma separated. */
+  devices: string;
+  /** Datastore name. */
+  name: string;
+  /** The ZFS RAID level to use. */
+  raidlevel: CreateNodeDiskZfsRequestRaidlevel | (string & {});
+}
+export const CreateNodeDiskZfsRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    node: S.String.pipe(T.Label()),
+    add_datastore: S.optional(S.String.pipe(T.Body("add-datastore"))),
+    ashift: S.optional(S.String),
+    compression: S.optional(CreateNodeDiskZfsRequestCompression),
+    devices: S.String,
+    name: S.String,
+    raidlevel: CreateNodeDiskZfsRequestRaidlevel,
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/nodes/{node}/disks/zfs",
+      code: 200,
+      contentType: "form-urlencoded",
+    }),
+  ),
+).annotate({
+  identifier: "CreateNodeDiskZfsRequest",
+}) as any as S.Schema<CreateNodeDiskZfsRequest>;
+
+export type CreateNodeDiskZfsResponse = string;
+export const CreateNodeDiskZfsResponse = /*@__PURE__*/ S.suspend(() =>
+  S.String.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "CreateNodeDiskZfsResponse",
+}) as any as S.Schema<CreateNodeDiskZfsResponse>;
+
+export type CreateNodeNetworkRequestBondMode =
+  | "balance-rr"
+  | "active-backup"
+  | "balance-xor"
+  | "broadcast"
+  | "802.3ad"
+  | "balance-tlb"
+  | "balance-alb";
+export const CreateNodeNetworkRequestBondMode = S.String;
+
+export type CreateNodeNetworkRequestBondXmitHashPolicy =
+  | "layer2"
+  | "layer2+3"
+  | "layer3+4";
+export const CreateNodeNetworkRequestBondXmitHashPolicy = S.String;
+
+export type CreateNodeNetworkRequestMethod =
+  | "manual"
+  | "static"
+  | "dhcp"
+  | "loopback";
+export const CreateNodeNetworkRequestMethod = S.String;
+
+export type CreateNodeNetworkRequestMethod6 =
+  | "manual"
+  | "static"
+  | "dhcp"
+  | "loopback";
+export const CreateNodeNetworkRequestMethod6 = S.String;
+
+export type CreateNodeNetworkRequestType =
+  | "loopback"
+  | "eth"
+  | "bridge"
+  | "bond"
+  | "vlan"
+  | "alias"
+  | "unknown";
+export const CreateNodeNetworkRequestType = S.String;
+
+export interface CreateNodeNetworkRequest {
+  node: string;
+  /** Autostart interface. */
+  autostart?: string;
+  /** Network interface name. */
+  bond_primary?: string;
+  /** Linux Bond Mode */
+  bond_mode?: CreateNodeNetworkRequestBondMode | (string & {});
+  /** Bond Transmit Hash Policy for LACP (802.3ad) */
+  bond_xmit_hash_policy?:
+    | CreateNodeNetworkRequestBondXmitHashPolicy
+    | (string & {});
+  /** A list of network devices, comma separated. */
+  bridge_ports?: string;
+  /** Enable bridge vlan support. */
+  bridge_vlan_aware?: string;
+  /** IPv4 address with netmask (CIDR notation). */
+  cidr?: string;
+  /** IPv6 address with netmask (CIDR notation). */
+  cidr6?: string;
+  /** Comments (inet, may span multiple lines) */
+  comments?: string;
+  /** Comments (inet5, may span multiple lines) */
+  comments6?: string;
+  /** IPv4 address. */
+  gateway?: string;
+  /** IPv6 address. */
+  gateway6?: string;
+  /** Network interface name. */
+  iface: string;
+  /** Interface configuration method */
+  method?: CreateNodeNetworkRequestMethod | (string & {});
+  /** Interface configuration method */
+  method6?: CreateNodeNetworkRequestMethod6 | (string & {});
+  /** Maximum Transmission Unit. */
+  mtu?: string;
+  /** A list of network devices, comma separated. */
+  slaves?: string;
+  /** Network interface type */
+  type?: CreateNodeNetworkRequestType | (string & {});
+  /** VLAN ID. */
+  vlan_id?: string;
+  /** Network interface name. */
+  vlan_raw_device?: string;
+}
+export const CreateNodeNetworkRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    node: S.String.pipe(T.Label()),
+    autostart: S.optional(S.String),
+    bond_primary: S.optional(S.String.pipe(T.Body("bond-primary"))),
+    bond_mode: S.optional(CreateNodeNetworkRequestBondMode),
+    bond_xmit_hash_policy: S.optional(
+      CreateNodeNetworkRequestBondXmitHashPolicy,
+    ),
+    bridge_ports: S.optional(S.String),
+    bridge_vlan_aware: S.optional(S.String),
+    cidr: S.optional(S.String),
+    cidr6: S.optional(S.String),
+    comments: S.optional(S.String),
+    comments6: S.optional(S.String),
+    gateway: S.optional(S.String),
+    gateway6: S.optional(S.String),
+    iface: S.String,
+    method: S.optional(CreateNodeNetworkRequestMethod),
+    method6: S.optional(CreateNodeNetworkRequestMethod6),
+    mtu: S.optional(S.String),
+    slaves: S.optional(S.String),
+    type: S.optional(CreateNodeNetworkRequestType),
+    vlan_id: S.optional(S.String.pipe(T.Body("vlan-id"))),
+    vlan_raw_device: S.optional(S.String.pipe(T.Body("vlan-raw-device"))),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/nodes/{node}/network",
+      code: 200,
+      contentType: "form-urlencoded",
+    }),
+  ),
+).annotate({
+  identifier: "CreateNodeNetworkRequest",
+}) as any as S.Schema<CreateNodeNetworkRequest>;
+
+export interface CreateNodeNetworkResponse {}
+export const CreateNodeNetworkResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "CreateNodeNetworkResponse",
+}) as any as S.Schema<CreateNodeNetworkResponse>;
+
+export interface CreateNodeServiceReloadRequest {
+  node: string;
+  service: string;
+}
+export const CreateNodeServiceReloadRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    node: S.String.pipe(T.Label()),
+    service: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/nodes/{node}/services/{service}/reload",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "CreateNodeServiceReloadRequest",
+}) as any as S.Schema<CreateNodeServiceReloadRequest>;
+
+export interface CreateNodeServiceReloadResponse {}
+export const CreateNodeServiceReloadResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "CreateNodeServiceReloadResponse",
+}) as any as S.Schema<CreateNodeServiceReloadResponse>;
+
+export type CreateNodeStatusRequestCommand = "reboot" | "shutdown";
+export const CreateNodeStatusRequestCommand = S.String;
+
+export interface CreateNodeStatusRequest {
+  node: string;
+  /** Node Power command type. */
+  command: CreateNodeStatusRequestCommand | (string & {});
+}
+export const CreateNodeStatusRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    node: S.String.pipe(T.Label()),
+    command: CreateNodeStatusRequestCommand,
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/nodes/{node}/status",
+      code: 200,
+      contentType: "form-urlencoded",
+    }),
+  ),
+).annotate({
+  identifier: "CreateNodeStatusRequest",
+}) as any as S.Schema<CreateNodeStatusRequest>;
+
+export interface CreateNodeStatusResponse {}
+export const CreateNodeStatusResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "CreateNodeStatusResponse",
+}) as any as S.Schema<CreateNodeStatusResponse>;
+
+export interface CreateNodeSubscriptionRequest {
+  node: string;
+  /** Always connect to server, even if information in cache is up to date. */
+  force?: string;
+}
+export const CreateNodeSubscriptionRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    node: S.String.pipe(T.Label()),
+    force: S.optional(S.String),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/nodes/{node}/subscription",
+      code: 200,
+      contentType: "form-urlencoded",
+    }),
+  ),
+).annotate({
+  identifier: "CreateNodeSubscriptionRequest",
+}) as any as S.Schema<CreateNodeSubscriptionRequest>;
+
+export interface CreateNodeSubscriptionResponse {}
+export const CreateNodeSubscriptionResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "CreateNodeSubscriptionResponse",
+}) as any as S.Schema<CreateNodeSubscriptionResponse>;
+
+export type CreateNodeTermproxyRequestCmd = "login" | "upgrade";
+export const CreateNodeTermproxyRequestCmd = S.String;
+
+export interface CreateNodeTermproxyRequest {
+  node: string;
+  /** The command to run. */
+  cmd?: CreateNodeTermproxyRequestCmd | (string & {});
+}
+export const CreateNodeTermproxyRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    node: S.String.pipe(T.Label()),
+    cmd: S.optional(CreateNodeTermproxyRequestCmd),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/nodes/{node}/termproxy",
+      code: 200,
+      contentType: "form-urlencoded",
+    }),
+  ),
+).annotate({
+  identifier: "CreateNodeTermproxyRequest",
+}) as any as S.Schema<CreateNodeTermproxyRequest>;
+
+export interface CreateNodeTermproxyResponse {
+  port: number;
+  ticket: string;
+  upid: string;
+  user: string;
+}
+export const CreateNodeTermproxyResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    port: S.Number,
+    ticket: S.String,
+    upid: S.String,
+    user: S.String,
+  }),
+).annotate({
+  identifier: "CreateNodeTermproxyResponse",
+}) as any as S.Schema<CreateNodeTermproxyResponse>;
+
+export interface DeleteNodeCertificateCustomRequest {
+  node: string;
+  /** UI compatibility parameter, ignored */
+  restart?: string;
+}
+export const DeleteNodeCertificateCustomRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    node: S.String.pipe(T.Label()),
+    restart: S.optional(S.String),
+  }).pipe(
+    T.Http({
+      method: "DELETE",
+      uri: "/nodes/{node}/certificates/custom",
+      code: 200,
+      contentType: "form-urlencoded",
+    }),
+  ),
+).annotate({
+  identifier: "DeleteNodeCertificateCustomRequest",
+}) as any as S.Schema<DeleteNodeCertificateCustomRequest>;
+
+export interface DeleteNodeCertificateCustomResponse {}
+export const DeleteNodeCertificateCustomResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "DeleteNodeCertificateCustomResponse",
+}) as any as S.Schema<DeleteNodeCertificateCustomResponse>;
+
+export interface DeleteNodeDiskDirectoryRequest {
+  node: string;
+  name: string;
+}
+export const DeleteNodeDiskDirectoryRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    node: S.String.pipe(T.Label()),
+    name: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "DELETE",
+      uri: "/nodes/{node}/disks/directory/{name}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "DeleteNodeDiskDirectoryRequest",
+}) as any as S.Schema<DeleteNodeDiskDirectoryRequest>;
+
+export interface DeleteNodeDiskDirectoryResponse {}
+export const DeleteNodeDiskDirectoryResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "DeleteNodeDiskDirectoryResponse",
+}) as any as S.Schema<DeleteNodeDiskDirectoryResponse>;
+
+export interface DeleteNodeNetworkRequest {
+  node: string;
+}
+export const DeleteNodeNetworkRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    node: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({ method: "DELETE", uri: "/nodes/{node}/network", code: 200 }),
+  ),
+).annotate({
+  identifier: "DeleteNodeNetworkRequest",
+}) as any as S.Schema<DeleteNodeNetworkRequest>;
+
+export interface DeleteNodeNetworkResponse {}
+export const DeleteNodeNetworkResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "DeleteNodeNetworkResponse",
+}) as any as S.Schema<DeleteNodeNetworkResponse>;
+
+export interface DeleteNodeNetwork2Request {
+  node: string;
+  iface: string;
+  /** Prevent changes if current configuration file has different SHA256 digest. This can be used to prevent concurrent modifications. */
+  digest?: string;
+}
+export const DeleteNodeNetwork2Request = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    node: S.String.pipe(T.Label()),
+    iface: S.String.pipe(T.Label()),
+    digest: S.optional(S.String),
+  }).pipe(
+    T.Http({
+      method: "DELETE",
+      uri: "/nodes/{node}/network/{iface}",
+      code: 200,
+      contentType: "form-urlencoded",
+    }),
+  ),
+).annotate({
+  identifier: "DeleteNodeNetwork2Request",
+}) as any as S.Schema<DeleteNodeNetwork2Request>;
+
+export interface DeleteNodeNetwork2Response {}
+export const DeleteNodeNetwork2Response = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "DeleteNodeNetwork2Response",
+}) as any as S.Schema<DeleteNodeNetwork2Response>;
+
+export interface DeleteNodeSubscriptionRequest {
+  node: string;
+}
+export const DeleteNodeSubscriptionRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    node: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({ method: "DELETE", uri: "/nodes/{node}/subscription", code: 200 }),
+  ),
+).annotate({
+  identifier: "DeleteNodeSubscriptionRequest",
+}) as any as S.Schema<DeleteNodeSubscriptionRequest>;
+
+export interface DeleteNodeSubscriptionResponse {}
+export const DeleteNodeSubscriptionResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "DeleteNodeSubscriptionResponse",
+}) as any as S.Schema<DeleteNodeSubscriptionResponse>;
+
+export interface DeleteNodeTaskRequest {
+  node: string;
+  upid: string;
+}
+export const DeleteNodeTaskRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    node: S.String.pipe(T.Label()),
+    upid: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({ method: "DELETE", uri: "/nodes/{node}/tasks/{upid}", code: 200 }),
+  ),
+).annotate({
+  identifier: "DeleteNodeTaskRequest",
+}) as any as S.Schema<DeleteNodeTaskRequest>;
+
+export interface DeleteNodeTaskResponse {}
+export const DeleteNodeTaskResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "DeleteNodeTaskResponse",
+}) as any as S.Schema<DeleteNodeTaskResponse>;
+
+export interface GetNodeRequest {
+  node: string;
+}
+export const GetNodeRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    node: S.String.pipe(T.Label()),
+  }).pipe(T.Http({ method: "GET", uri: "/nodes/{node}", code: 200 })),
+).annotate({ identifier: "GetNodeRequest" }) as any as S.Schema<GetNodeRequest>;
+
+export interface GetNodeResponse {}
+export const GetNodeResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "GetNodeResponse",
+}) as any as S.Schema<GetNodeResponse>;
+
+export interface GetNodeAptRequest {
+  node: string;
+}
+export const GetNodeAptRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    node: S.String.pipe(T.Label()),
+  }).pipe(T.Http({ method: "GET", uri: "/nodes/{node}/apt", code: 200 })),
+).annotate({
+  identifier: "GetNodeAptRequest",
+}) as any as S.Schema<GetNodeAptRequest>;
+
+export interface GetNodeAptResponse {}
+export const GetNodeAptResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "GetNodeAptResponse",
+}) as any as S.Schema<GetNodeAptResponse>;
+
+export interface GetNodeAptChangelogRequest {
+  node: string;
+  /** Package name to get changelog of. */
+  name: string;
+  /** Package version to get changelog of. Omit to use candidate version. */
+  version?: string;
+}
+export const GetNodeAptChangelogRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    node: S.String.pipe(T.Label()),
+    name: S.String.pipe(T.Query()),
+    version: S.optional(S.String.pipe(T.Query())),
+  }).pipe(
+    T.Http({ method: "GET", uri: "/nodes/{node}/apt/changelog", code: 200 }),
+  ),
+).annotate({
+  identifier: "GetNodeAptChangelogRequest",
+}) as any as S.Schema<GetNodeAptChangelogRequest>;
+
+export type GetNodeAptChangelogResponse = string;
+export const GetNodeAptChangelogResponse = /*@__PURE__*/ S.suspend(() =>
+  S.String.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "GetNodeAptChangelogResponse",
+}) as any as S.Schema<GetNodeAptChangelogResponse>;
+
+export interface GetNodeAptRepositoriesRequest {
+  node: string;
+}
+export const GetNodeAptRepositoriesRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    node: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({ method: "GET", uri: "/nodes/{node}/apt/repositories", code: 200 }),
+  ),
+).annotate({
+  identifier: "GetNodeAptRepositoriesRequest",
+}) as any as S.Schema<GetNodeAptRepositoriesRequest>;
+
+export interface GetNodeAptRepositoriesResponseErrorsItem {
+  error: string;
+  path: string;
+}
+export const GetNodeAptRepositoriesResponseErrorsItem = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      error: S.String,
+      path: S.String,
+    }),
+).annotate({
+  identifier: "GetNodeAptRepositoriesResponseErrorsItem",
+}) as any as S.Schema<GetNodeAptRepositoriesResponseErrorsItem>;
+
+export type GetNodeAptRepositoriesResponseErrorsList =
+  Array<GetNodeAptRepositoriesResponseErrorsItem>;
+export const GetNodeAptRepositoriesResponseErrorsList = /*@__PURE__*/ S.Array(
+  GetNodeAptRepositoriesResponseErrorsItem,
+) as any as S.Schema<GetNodeAptRepositoriesResponseErrorsList>;
+
+export type GetNodeAptRepositoriesResponseFilesItemFileType =
+  | "list"
+  | "sources";
+export const GetNodeAptRepositoriesResponseFilesItemFileType = S.String;
+
+export type GetNodeAptRepositoriesResponseFilesItemRepositoriesItemComponentsList =
+  Array<string>;
+export const GetNodeAptRepositoriesResponseFilesItemRepositoriesItemComponentsList =
+  /*@__PURE__*/ S.Array(
+    S.String,
+  ) as any as S.Schema<GetNodeAptRepositoriesResponseFilesItemRepositoriesItemComponentsList>;
+
+export type GetNodeAptRepositoriesResponseFilesItemRepositoriesItemFileType =
+  | "list"
+  | "sources";
+export const GetNodeAptRepositoriesResponseFilesItemRepositoriesItemFileType =
+  S.String;
+
+export type GetNodeAptRepositoriesResponseFilesItemRepositoriesItemOptionsItemValuesList =
+  Array<string>;
+export const GetNodeAptRepositoriesResponseFilesItemRepositoriesItemOptionsItemValuesList =
+  /*@__PURE__*/ S.Array(
+    S.String,
+  ) as any as S.Schema<GetNodeAptRepositoriesResponseFilesItemRepositoriesItemOptionsItemValuesList>;
+
+export interface GetNodeAptRepositoriesResponseFilesItemRepositoriesItemOptionsItem {
+  Key: string;
+  Values: GetNodeAptRepositoriesResponseFilesItemRepositoriesItemOptionsItemValuesList;
+}
+export const GetNodeAptRepositoriesResponseFilesItemRepositoriesItemOptionsItem =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      Key: S.String,
+      Values:
+        GetNodeAptRepositoriesResponseFilesItemRepositoriesItemOptionsItemValuesList,
+    }),
+  ).annotate({
+    identifier:
+      "GetNodeAptRepositoriesResponseFilesItemRepositoriesItemOptionsItem",
+  }) as any as S.Schema<GetNodeAptRepositoriesResponseFilesItemRepositoriesItemOptionsItem>;
+
+export type GetNodeAptRepositoriesResponseFilesItemRepositoriesItemOptionsList =
+  Array<GetNodeAptRepositoriesResponseFilesItemRepositoriesItemOptionsItem>;
+export const GetNodeAptRepositoriesResponseFilesItemRepositoriesItemOptionsList =
+  /*@__PURE__*/ S.Array(
+    GetNodeAptRepositoriesResponseFilesItemRepositoriesItemOptionsItem,
+  ) as any as S.Schema<GetNodeAptRepositoriesResponseFilesItemRepositoriesItemOptionsList>;
+
+export type GetNodeAptRepositoriesResponseFilesItemRepositoriesItemSuitesList =
+  Array<string>;
+export const GetNodeAptRepositoriesResponseFilesItemRepositoriesItemSuitesList =
+  /*@__PURE__*/ S.Array(
+    S.String,
+  ) as any as S.Schema<GetNodeAptRepositoriesResponseFilesItemRepositoriesItemSuitesList>;
+
+export type GetNodeAptRepositoriesResponseFilesItemRepositoriesItemTypesItem =
+  | "deb"
+  | "deb-src";
+export const GetNodeAptRepositoriesResponseFilesItemRepositoriesItemTypesItem =
+  S.String;
+
+export type GetNodeAptRepositoriesResponseFilesItemRepositoriesItemTypesList =
+  Array<GetNodeAptRepositoriesResponseFilesItemRepositoriesItemTypesItem>;
+export const GetNodeAptRepositoriesResponseFilesItemRepositoriesItemTypesList =
+  /*@__PURE__*/ S.Array(
+    GetNodeAptRepositoriesResponseFilesItemRepositoriesItemTypesItem,
+  ) as any as S.Schema<GetNodeAptRepositoriesResponseFilesItemRepositoriesItemTypesList>;
+
+export type GetNodeAptRepositoriesResponseFilesItemRepositoriesItemURIsList =
+  Array<string>;
+export const GetNodeAptRepositoriesResponseFilesItemRepositoriesItemURIsList =
+  /*@__PURE__*/ S.Array(
+    S.String,
+  ) as any as S.Schema<GetNodeAptRepositoriesResponseFilesItemRepositoriesItemURIsList>;
+
+export interface GetNodeAptRepositoriesResponseFilesItemRepositoriesItem {
+  Comment?: string;
+  Components: GetNodeAptRepositoriesResponseFilesItemRepositoriesItemComponentsList;
+  Enabled: unknown;
+  FileType: GetNodeAptRepositoriesResponseFilesItemRepositoriesItemFileType;
+  Options?: GetNodeAptRepositoriesResponseFilesItemRepositoriesItemOptionsList;
+  Suites: GetNodeAptRepositoriesResponseFilesItemRepositoriesItemSuitesList;
+  Types: GetNodeAptRepositoriesResponseFilesItemRepositoriesItemTypesList;
+  URIs: GetNodeAptRepositoriesResponseFilesItemRepositoriesItemURIsList;
+}
+export const GetNodeAptRepositoriesResponseFilesItemRepositoriesItem =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      Comment: S.optional(S.String),
+      Components:
+        GetNodeAptRepositoriesResponseFilesItemRepositoriesItemComponentsList,
+      Enabled: S.Unknown,
+      FileType: GetNodeAptRepositoriesResponseFilesItemRepositoriesItemFileType,
+      Options: S.optional(
+        GetNodeAptRepositoriesResponseFilesItemRepositoriesItemOptionsList,
+      ),
+      Suites: GetNodeAptRepositoriesResponseFilesItemRepositoriesItemSuitesList,
+      Types: GetNodeAptRepositoriesResponseFilesItemRepositoriesItemTypesList,
+      URIs: GetNodeAptRepositoriesResponseFilesItemRepositoriesItemURIsList,
+    }),
+  ).annotate({
+    identifier: "GetNodeAptRepositoriesResponseFilesItemRepositoriesItem",
+  }) as any as S.Schema<GetNodeAptRepositoriesResponseFilesItemRepositoriesItem>;
+
+export type GetNodeAptRepositoriesResponseFilesItemRepositoriesList =
+  Array<GetNodeAptRepositoriesResponseFilesItemRepositoriesItem>;
+export const GetNodeAptRepositoriesResponseFilesItemRepositoriesList =
+  /*@__PURE__*/ S.Array(
+    GetNodeAptRepositoriesResponseFilesItemRepositoriesItem,
+  ) as any as S.Schema<GetNodeAptRepositoriesResponseFilesItemRepositoriesList>;
+
+export interface GetNodeAptRepositoriesResponseFilesItem {
+  content?: string;
+  digest?: string;
+  file_type?: GetNodeAptRepositoriesResponseFilesItemFileType;
+  path?: string;
+  repositories: GetNodeAptRepositoriesResponseFilesItemRepositoriesList;
+}
+export const GetNodeAptRepositoriesResponseFilesItem = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      content: S.optional(S.String),
+      digest: S.optional(S.String),
+      file_type: S.optional(
+        GetNodeAptRepositoriesResponseFilesItemFileType.pipe(
+          T.Body("file-type"),
+        ),
+      ),
+      path: S.optional(S.String),
+      repositories: GetNodeAptRepositoriesResponseFilesItemRepositoriesList,
+    }),
+).annotate({
+  identifier: "GetNodeAptRepositoriesResponseFilesItem",
+}) as any as S.Schema<GetNodeAptRepositoriesResponseFilesItem>;
+
+export type GetNodeAptRepositoriesResponseFilesList =
+  Array<GetNodeAptRepositoriesResponseFilesItem>;
+export const GetNodeAptRepositoriesResponseFilesList = /*@__PURE__*/ S.Array(
+  GetNodeAptRepositoriesResponseFilesItem,
+) as any as S.Schema<GetNodeAptRepositoriesResponseFilesList>;
+
+export interface GetNodeAptRepositoriesResponseInfosItem {
+  index: number;
+  kind: string;
+  message: string;
+  path: string;
+  property?: string;
+}
+export const GetNodeAptRepositoriesResponseInfosItem = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      index: S.Number,
+      kind: S.String,
+      message: S.String,
+      path: S.String,
+      property: S.optional(S.String),
+    }),
+).annotate({
+  identifier: "GetNodeAptRepositoriesResponseInfosItem",
+}) as any as S.Schema<GetNodeAptRepositoriesResponseInfosItem>;
+
+export type GetNodeAptRepositoriesResponseInfosList =
+  Array<GetNodeAptRepositoriesResponseInfosItem>;
+export const GetNodeAptRepositoriesResponseInfosList = /*@__PURE__*/ S.Array(
+  GetNodeAptRepositoriesResponseInfosItem,
+) as any as S.Schema<GetNodeAptRepositoriesResponseInfosList>;
+
+export interface GetNodeAptRepositoriesResponseStandardReposItem {
+  description: string;
+  handle: string;
+  name: string;
+  status?: unknown;
+}
+export const GetNodeAptRepositoriesResponseStandardReposItem =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      description: S.String,
+      handle: S.String,
+      name: S.String,
+      status: S.optional(S.Unknown),
+    }),
+  ).annotate({
+    identifier: "GetNodeAptRepositoriesResponseStandardReposItem",
+  }) as any as S.Schema<GetNodeAptRepositoriesResponseStandardReposItem>;
+
+export type GetNodeAptRepositoriesResponseStandardReposList =
+  Array<GetNodeAptRepositoriesResponseStandardReposItem>;
+export const GetNodeAptRepositoriesResponseStandardReposList =
+  /*@__PURE__*/ S.Array(
+    GetNodeAptRepositoriesResponseStandardReposItem,
+  ) as any as S.Schema<GetNodeAptRepositoriesResponseStandardReposList>;
+
+export interface GetNodeAptRepositoriesResponse {
+  digest: string;
+  errors: GetNodeAptRepositoriesResponseErrorsList;
+  files: GetNodeAptRepositoriesResponseFilesList;
+  infos: GetNodeAptRepositoriesResponseInfosList;
+  standard_repos?: GetNodeAptRepositoriesResponseStandardReposList;
+}
+export const GetNodeAptRepositoriesResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    digest: S.String,
+    errors: GetNodeAptRepositoriesResponseErrorsList,
+    files: GetNodeAptRepositoriesResponseFilesList,
+    infos: GetNodeAptRepositoriesResponseInfosList,
+    standard_repos: S.optional(
+      GetNodeAptRepositoriesResponseStandardReposList.pipe(
+        T.Body("standard-repos"),
+      ),
+    ),
+  }),
+).annotate({
+  identifier: "GetNodeAptRepositoriesResponse",
+}) as any as S.Schema<GetNodeAptRepositoriesResponse>;
+
+export interface GetNodeCertificateAcmeRequest {
+  node: string;
+}
+export const GetNodeCertificateAcmeRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    node: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/nodes/{node}/certificates/acme",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "GetNodeCertificateAcmeRequest",
+}) as any as S.Schema<GetNodeCertificateAcmeRequest>;
+
+export interface GetNodeCertificateAcmeResponse {}
+export const GetNodeCertificateAcmeResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "GetNodeCertificateAcmeResponse",
+}) as any as S.Schema<GetNodeCertificateAcmeResponse>;
+
+export interface GetNodeCertificatesRequest {
+  node: string;
+}
+export const GetNodeCertificatesRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    node: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({ method: "GET", uri: "/nodes/{node}/certificates", code: 200 }),
+  ),
+).annotate({
+  identifier: "GetNodeCertificatesRequest",
+}) as any as S.Schema<GetNodeCertificatesRequest>;
+
+export interface GetNodeCertificatesResponse {}
+export const GetNodeCertificatesResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "GetNodeCertificatesResponse",
+}) as any as S.Schema<GetNodeCertificatesResponse>;
+
+export interface GetNodeConfigRequest {
+  node: string;
+}
+export const GetNodeConfigRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    node: S.String.pipe(T.Label()),
+  }).pipe(T.Http({ method: "GET", uri: "/nodes/{node}/config", code: 200 })),
+).annotate({
+  identifier: "GetNodeConfigRequest",
+}) as any as S.Schema<GetNodeConfigRequest>;
+
+export type GetNodeConfigResponseDefaultLang =
+  | "ar"
+  | "ca"
+  | "da"
+  | "de"
+  | "en"
+  | "es"
+  | "eu"
+  | "fa"
+  | "fr"
+  | "gl"
+  | "he"
+  | "hu"
+  | "it"
+  | "ja"
+  | "kr"
+  | "nb"
+  | "nl"
+  | "nn"
+  | "pl"
+  | "pt_BR"
+  | "ru"
+  | "sl"
+  | "sv"
+  | "tr"
+  | "zh_CN"
+  | "zh_TW";
+export const GetNodeConfigResponseDefaultLang = S.String;
+
+export interface GetNodeConfigResponse {
+  acme?: string;
+  acmedomain0?: string;
+  acmedomain1?: string;
+  acmedomain2?: string;
+  acmedomain3?: string;
+  acmedomain4?: string;
+  ciphers_tls_1_2?: string;
+  ciphers_tls_1_3?: string;
+  consent_text?: string;
+  default_lang?: GetNodeConfigResponseDefaultLang;
+  description?: string;
+  email_from?: string;
+  http_proxy?: string;
+  location?: string;
+  task_log_max_days?: number;
+}
+export const GetNodeConfigResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    acme: S.optional(S.String),
+    acmedomain0: S.optional(S.String),
+    acmedomain1: S.optional(S.String),
+    acmedomain2: S.optional(S.String),
+    acmedomain3: S.optional(S.String),
+    acmedomain4: S.optional(S.String),
+    ciphers_tls_1_2: S.optional(S.String.pipe(T.Body("ciphers-tls-1.2"))),
+    ciphers_tls_1_3: S.optional(S.String.pipe(T.Body("ciphers-tls-1.3"))),
+    consent_text: S.optional(S.String.pipe(T.Body("consent-text"))),
+    default_lang: S.optional(
+      GetNodeConfigResponseDefaultLang.pipe(T.Body("default-lang")),
+    ),
+    description: S.optional(S.String),
+    email_from: S.optional(S.String.pipe(T.Body("email-from"))),
+    http_proxy: S.optional(S.String.pipe(T.Body("http-proxy"))),
+    location: S.optional(S.String),
+    task_log_max_days: S.optional(S.Number.pipe(T.Body("task-log-max-days"))),
+  }),
+).annotate({
+  identifier: "GetNodeConfigResponse",
+}) as any as S.Schema<GetNodeConfigResponse>;
+
+export interface GetNodeDisksRequest {
+  node: string;
+}
+export const GetNodeDisksRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    node: S.String.pipe(T.Label()),
+  }).pipe(T.Http({ method: "GET", uri: "/nodes/{node}/disks", code: 200 })),
+).annotate({
+  identifier: "GetNodeDisksRequest",
+}) as any as S.Schema<GetNodeDisksRequest>;
+
+export interface GetNodeDisksResponse {}
+export const GetNodeDisksResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "GetNodeDisksResponse",
+}) as any as S.Schema<GetNodeDisksResponse>;
+
+export interface GetNodeDiskSmartRequest {
+  node: string;
+  /** Block device name (/sys/block/<name>). */
+  disk: string;
+  /** If true returns only the health status. */
+  healthonly?: string;
+}
+export const GetNodeDiskSmartRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    node: S.String.pipe(T.Label()),
+    disk: S.String.pipe(T.Query()),
+    healthonly: S.optional(S.String.pipe(T.Query())),
+  }).pipe(
+    T.Http({ method: "GET", uri: "/nodes/{node}/disks/smart", code: 200 }),
+  ),
+).annotate({
+  identifier: "GetNodeDiskSmartRequest",
+}) as any as S.Schema<GetNodeDiskSmartRequest>;
+
+export interface GetNodeDiskSmartResponseAttributesItem {
+  flags?: string;
+  id?: number;
+  name: string;
+  normalized?: number;
+  raw: string;
+  threshold?: number;
+  value: string;
+  worst?: number;
+}
+export const GetNodeDiskSmartResponseAttributesItem = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      flags: S.optional(S.String),
+      id: S.optional(S.Number),
+      name: S.String,
+      normalized: S.optional(S.Number),
+      raw: S.String,
+      threshold: S.optional(S.Number),
+      value: S.String,
+      worst: S.optional(S.Number),
+    }),
+).annotate({
+  identifier: "GetNodeDiskSmartResponseAttributesItem",
+}) as any as S.Schema<GetNodeDiskSmartResponseAttributesItem>;
+
+export type GetNodeDiskSmartResponseAttributesList =
+  Array<GetNodeDiskSmartResponseAttributesItem>;
+export const GetNodeDiskSmartResponseAttributesList = /*@__PURE__*/ S.Array(
+  GetNodeDiskSmartResponseAttributesItem,
+) as any as S.Schema<GetNodeDiskSmartResponseAttributesList>;
+
+export type GetNodeDiskSmartResponseStatus = "passed" | "failed" | "unknown";
+export const GetNodeDiskSmartResponseStatus = S.String;
+
+export interface GetNodeDiskSmartResponse {
+  attributes: GetNodeDiskSmartResponseAttributesList;
+  status: GetNodeDiskSmartResponseStatus;
+  wearout?: number;
+}
+export const GetNodeDiskSmartResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    attributes: GetNodeDiskSmartResponseAttributesList,
+    status: GetNodeDiskSmartResponseStatus,
+    wearout: S.optional(S.Number),
+  }),
+).annotate({
+  identifier: "GetNodeDiskSmartResponse",
+}) as any as S.Schema<GetNodeDiskSmartResponse>;
+
+export interface GetNodeDiskZfsRequest {
+  node: string;
+  name: string;
+}
+export const GetNodeDiskZfsRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    node: S.String.pipe(T.Label()),
+    name: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({ method: "GET", uri: "/nodes/{node}/disks/zfs/{name}", code: 200 }),
+  ),
+).annotate({
+  identifier: "GetNodeDiskZfsRequest",
+}) as any as S.Schema<GetNodeDiskZfsRequest>;
+
+export type GetNodeDiskZfsResponse = unknown;
+export const GetNodeDiskZfsResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Unknown.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "GetNodeDiskZfsResponse",
+}) as any as S.Schema<GetNodeDiskZfsResponse>;
+
+export interface GetNodeDnsRequest {
+  node: string;
+}
+export const GetNodeDnsRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    node: S.String.pipe(T.Label()),
+  }).pipe(T.Http({ method: "GET", uri: "/nodes/{node}/dns", code: 200 })),
+).annotate({
+  identifier: "GetNodeDnsRequest",
+}) as any as S.Schema<GetNodeDnsRequest>;
+
+export interface GetNodeDnsResponse {
+  digest: string;
+  dns1?: string;
+  dns2?: string;
+  dns3?: string;
+  search?: string;
+}
+export const GetNodeDnsResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    digest: S.String,
+    dns1: S.optional(S.String),
+    dns2: S.optional(S.String),
+    dns3: S.optional(S.String),
+    search: S.optional(S.String),
+  }),
+).annotate({
+  identifier: "GetNodeDnsResponse",
+}) as any as S.Schema<GetNodeDnsResponse>;
+
+export interface GetNodeIdentityRequest {
+  node: string;
+}
+export const GetNodeIdentityRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    node: S.String.pipe(T.Label()),
+  }).pipe(T.Http({ method: "GET", uri: "/nodes/{node}/identity", code: 200 })),
+).annotate({
+  identifier: "GetNodeIdentityRequest",
+}) as any as S.Schema<GetNodeIdentityRequest>;
+
+export interface GetNodeIdentityResponse {
+  pbs_instance_id?: string;
+}
+export const GetNodeIdentityResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    pbs_instance_id: S.optional(S.String.pipe(T.Body("pbs-instance-id"))),
+  }),
+).annotate({
+  identifier: "GetNodeIdentityResponse",
+}) as any as S.Schema<GetNodeIdentityResponse>;
+
+export interface GetNodeJournalRequest {
+  node: string;
+  /** End before the given Cursor. Conflicts with 'until' */
+  endcursor?: string;
+  /** Also list the distinct syslog identifiers present. Requires 'structured'. */
+  identifiers?: string;
+  /** Only print kernel messages. */
+  kernel?: string;
+  /** Limit to the last X lines. Conflicts with a range. */
+  lastentries?: string;
+  /** Only print messages of this syslog priority: a single level from 0 (emerg) to 7 (debug), selecting that level and everything more severe, or a 'LOW..HIGH' range. Empty means no filter. */
+  priority?: string;
+  /** Only print messages whose syslog identifier matches this glob. */
+  service?: string;
+  /** Display all log since this UNIX epoch. Conflicts with 'startcursor'. */
+  since?: string;
+  /** Start after the given Cursor. Conflicts with 'since'. */
+  startcursor?: string;
+  /** Emit structured JSON with separate entry fields instead of plain text. */
+  structured?: string;
+  /** Only print messages of this systemd unit (the .service suffix is implied). */
+  unit?: string;
+  /** Also list the distinct systemd units present. Requires 'structured'. */
+  units?: string;
+  /** Display all log until this UNIX epoch. Conflicts with 'endcursor'. */
+  until?: string;
+}
+export const GetNodeJournalRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    node: S.String.pipe(T.Label()),
+    endcursor: S.optional(S.String.pipe(T.Query())),
+    identifiers: S.optional(S.String.pipe(T.Query())),
+    kernel: S.optional(S.String.pipe(T.Query())),
+    lastentries: S.optional(S.String.pipe(T.Query())),
+    priority: S.optional(S.String.pipe(T.Query())),
+    service: S.optional(S.String.pipe(T.Query())),
+    since: S.optional(S.String.pipe(T.Query())),
+    startcursor: S.optional(S.String.pipe(T.Query())),
+    structured: S.optional(S.String.pipe(T.Query())),
+    unit: S.optional(S.String.pipe(T.Query())),
+    units: S.optional(S.String.pipe(T.Query())),
+    until: S.optional(S.String.pipe(T.Query())),
+  }).pipe(T.Http({ method: "GET", uri: "/nodes/{node}/journal", code: 200 })),
+).annotate({
+  identifier: "GetNodeJournalRequest",
+}) as any as S.Schema<GetNodeJournalRequest>;
+
+export interface GetNodeJournalResponse {}
+export const GetNodeJournalResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "GetNodeJournalResponse",
+}) as any as S.Schema<GetNodeJournalResponse>;
+
+export interface GetNodeNetworkRequest {
+  node: string;
+  iface: string;
+}
+export const GetNodeNetworkRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    node: S.String.pipe(T.Label()),
+    iface: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({ method: "GET", uri: "/nodes/{node}/network/{iface}", code: 200 }),
+  ),
+).annotate({
+  identifier: "GetNodeNetworkRequest",
+}) as any as S.Schema<GetNodeNetworkRequest>;
+
+export type GetNodeNetworkResponseAltnamesList = Array<string>;
+export const GetNodeNetworkResponseAltnamesList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<GetNodeNetworkResponseAltnamesList>;
+
+export type GetNodeNetworkResponseBondMode =
+  | "balance-rr"
+  | "active-backup"
+  | "balance-xor"
+  | "broadcast"
+  | "802.3ad"
+  | "balance-tlb"
+  | "balance-alb";
+export const GetNodeNetworkResponseBondMode = S.String;
+
+export type GetNodeNetworkResponseBondXmitHashPolicy =
+  | "layer2"
+  | "layer2+3"
+  | "layer3+4";
+export const GetNodeNetworkResponseBondXmitHashPolicy = S.String;
+
+export type GetNodeNetworkResponseBridgePortsList = Array<string>;
+export const GetNodeNetworkResponseBridgePortsList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<GetNodeNetworkResponseBridgePortsList>;
+
+export type GetNodeNetworkResponseMethod =
+  | "manual"
+  | "static"
+  | "dhcp"
+  | "loopback";
+export const GetNodeNetworkResponseMethod = S.String;
+
+export type GetNodeNetworkResponseMethod6 =
+  | "manual"
+  | "static"
+  | "dhcp"
+  | "loopback";
+export const GetNodeNetworkResponseMethod6 = S.String;
+
+export type GetNodeNetworkResponseOptionsList = Array<string>;
+export const GetNodeNetworkResponseOptionsList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<GetNodeNetworkResponseOptionsList>;
+
+export type GetNodeNetworkResponseOptions6List = Array<string>;
+export const GetNodeNetworkResponseOptions6List = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<GetNodeNetworkResponseOptions6List>;
+
+export type GetNodeNetworkResponseSlavesList = Array<string>;
+export const GetNodeNetworkResponseSlavesList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<GetNodeNetworkResponseSlavesList>;
+
+export type GetNodeNetworkResponseType =
+  | "loopback"
+  | "eth"
+  | "bridge"
+  | "bond"
+  | "vlan"
+  | "alias"
+  | "unknown";
+export const GetNodeNetworkResponseType = S.String;
+
+export interface GetNodeNetworkResponse {
+  active: unknown;
+  altnames: GetNodeNetworkResponseAltnamesList;
+  autostart: unknown;
+  bond_primary?: string;
+  bond_mode?: GetNodeNetworkResponseBondMode;
+  bond_xmit_hash_policy?: GetNodeNetworkResponseBondXmitHashPolicy;
+  bridge_ports?: GetNodeNetworkResponseBridgePortsList;
+  bridge_vlan_aware?: unknown;
+  cidr?: string;
+  cidr6?: string;
+  comments?: string;
+  comments6?: string;
+  gateway?: string;
+  gateway6?: string;
+  method?: GetNodeNetworkResponseMethod;
+  method6?: GetNodeNetworkResponseMethod6;
+  mtu?: number;
+  name: string;
+  options: GetNodeNetworkResponseOptionsList;
+  options6: GetNodeNetworkResponseOptions6List;
+  slaves?: GetNodeNetworkResponseSlavesList;
+  type: GetNodeNetworkResponseType;
+  vlan_id?: number;
+  vlan_raw_device?: string;
+}
+export const GetNodeNetworkResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    active: S.Unknown,
+    altnames: GetNodeNetworkResponseAltnamesList,
+    autostart: S.Unknown,
+    bond_primary: S.optional(S.String.pipe(T.Body("bond-primary"))),
+    bond_mode: S.optional(GetNodeNetworkResponseBondMode),
+    bond_xmit_hash_policy: S.optional(GetNodeNetworkResponseBondXmitHashPolicy),
+    bridge_ports: S.optional(GetNodeNetworkResponseBridgePortsList),
+    bridge_vlan_aware: S.optional(S.Unknown),
+    cidr: S.optional(S.String),
+    cidr6: S.optional(S.String),
+    comments: S.optional(S.String),
+    comments6: S.optional(S.String),
+    gateway: S.optional(S.String),
+    gateway6: S.optional(S.String),
+    method: S.optional(GetNodeNetworkResponseMethod),
+    method6: S.optional(GetNodeNetworkResponseMethod6),
+    mtu: S.optional(S.Number),
+    name: S.String,
+    options: GetNodeNetworkResponseOptionsList,
+    options6: GetNodeNetworkResponseOptions6List,
+    slaves: S.optional(GetNodeNetworkResponseSlavesList),
+    type: GetNodeNetworkResponseType,
+    vlan_id: S.optional(S.Number.pipe(T.Body("vlan-id"))),
+    vlan_raw_device: S.optional(S.String.pipe(T.Body("vlan-raw-device"))),
+  }),
+).annotate({
+  identifier: "GetNodeNetworkResponse",
+}) as any as S.Schema<GetNodeNetworkResponse>;
+
+export interface GetNodeReportRequest {
+  node: string;
+}
+export const GetNodeReportRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    node: S.String.pipe(T.Label()),
+  }).pipe(T.Http({ method: "GET", uri: "/nodes/{node}/report", code: 200 })),
+).annotate({
+  identifier: "GetNodeReportRequest",
+}) as any as S.Schema<GetNodeReportRequest>;
+
+export type GetNodeReportResponse = string;
+export const GetNodeReportResponse = /*@__PURE__*/ S.suspend(() =>
+  S.String.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "GetNodeReportResponse",
+}) as any as S.Schema<GetNodeReportResponse>;
+
+export type GetNodeRrdRequestCf = "MAX" | "AVERAGE";
+export const GetNodeRrdRequestCf = S.String;
+
+export type GetNodeRrdRequestTimeframe =
+  | "hour"
+  | "day"
+  | "week"
+  | "month"
+  | "year"
+  | "decade";
+export const GetNodeRrdRequestTimeframe = S.String;
+
+export interface GetNodeRrdRequest {
+  node: string;
+  /** RRD consolidation mode */
+  cf: GetNodeRrdRequestCf | (string & {});
+  /** RRD time frame */
+  timeframe: GetNodeRrdRequestTimeframe | (string & {});
+}
+export const GetNodeRrdRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    node: S.String.pipe(T.Label()),
+    cf: GetNodeRrdRequestCf.pipe(T.Query()),
+    timeframe: GetNodeRrdRequestTimeframe.pipe(T.Query()),
+  }).pipe(T.Http({ method: "GET", uri: "/nodes/{node}/rrd", code: 200 })),
+).annotate({
+  identifier: "GetNodeRrdRequest",
+}) as any as S.Schema<GetNodeRrdRequest>;
+
+export interface GetNodeRrdResponse {}
+export const GetNodeRrdResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "GetNodeRrdResponse",
+}) as any as S.Schema<GetNodeRrdResponse>;
+
+export interface GetNodesRequest {}
+export const GetNodesRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}).pipe(T.Http({ method: "GET", uri: "/nodes", code: 200 })),
+).annotate({
+  identifier: "GetNodesRequest",
+}) as any as S.Schema<GetNodesRequest>;
+
+export interface GetNodesResponse {}
+export const GetNodesResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "GetNodesResponse",
+}) as any as S.Schema<GetNodesResponse>;
+
+export interface GetNodeServiceRequest {
+  node: string;
+  service: string;
+}
+export const GetNodeServiceRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    node: S.String.pipe(T.Label()),
+    service: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/nodes/{node}/services/{service}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "GetNodeServiceRequest",
+}) as any as S.Schema<GetNodeServiceRequest>;
+
+export interface GetNodeServiceResponse {}
+export const GetNodeServiceResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "GetNodeServiceResponse",
+}) as any as S.Schema<GetNodeServiceResponse>;
+
+export interface GetNodeServiceStateRequest {
+  node: string;
+  service: string;
+}
+export const GetNodeServiceStateRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    node: S.String.pipe(T.Label()),
+    service: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/nodes/{node}/services/{service}/state",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "GetNodeServiceStateRequest",
+}) as any as S.Schema<GetNodeServiceStateRequest>;
+
+export interface GetNodeServiceStateResponse {}
+export const GetNodeServiceStateResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "GetNodeServiceStateResponse",
+}) as any as S.Schema<GetNodeServiceStateResponse>;
+
+export interface GetNodeStatusRequest {
+  node: string;
+}
+export const GetNodeStatusRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    node: S.String.pipe(T.Label()),
+  }).pipe(T.Http({ method: "GET", uri: "/nodes/{node}/status", code: 200 })),
+).annotate({
+  identifier: "GetNodeStatusRequest",
+}) as any as S.Schema<GetNodeStatusRequest>;
+
+export type GetNodeStatusResponseBootInfoMode = "efi" | "legacy-bios";
+export const GetNodeStatusResponseBootInfoMode = S.String;
+
+export interface GetNodeStatusResponseBootInfo {
+  mode: GetNodeStatusResponseBootInfoMode;
+  secureboot: unknown;
+}
+export const GetNodeStatusResponseBootInfo = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    mode: GetNodeStatusResponseBootInfoMode,
+    secureboot: S.Unknown,
+  }),
+).annotate({
+  identifier: "GetNodeStatusResponseBootInfo",
+}) as any as S.Schema<GetNodeStatusResponseBootInfo>;
+
+export interface GetNodeStatusResponseCpuinfo {
+  cpus: number;
+  model: string;
+  sockets: number;
+}
+export const GetNodeStatusResponseCpuinfo = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    cpus: S.Number,
+    model: S.String,
+    sockets: S.Number,
+  }),
+).annotate({
+  identifier: "GetNodeStatusResponseCpuinfo",
+}) as any as S.Schema<GetNodeStatusResponseCpuinfo>;
+
+export interface GetNodeStatusResponseCurrentKernel {
+  machine: string;
+  release: string;
+  sysname: string;
+  version: string;
+}
+export const GetNodeStatusResponseCurrentKernel = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    machine: S.String,
+    release: S.String,
+    sysname: S.String,
+    version: S.String,
+  }),
+).annotate({
+  identifier: "GetNodeStatusResponseCurrentKernel",
+}) as any as S.Schema<GetNodeStatusResponseCurrentKernel>;
+
+export interface GetNodeStatusResponseInfo {
+  fingerprint: string;
+}
+export const GetNodeStatusResponseInfo = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    fingerprint: S.String,
+  }),
+).annotate({
+  identifier: "GetNodeStatusResponseInfo",
+}) as any as S.Schema<GetNodeStatusResponseInfo>;
+
+export type GetNodeStatusResponseLoadavgList = Array<number>;
+export const GetNodeStatusResponseLoadavgList = /*@__PURE__*/ S.Array(
+  S.Number,
+) as any as S.Schema<GetNodeStatusResponseLoadavgList>;
+
+export interface GetNodeStatusResponseMemory {
+  free: number;
+  total: number;
+  used: number;
+}
+export const GetNodeStatusResponseMemory = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    free: S.Number,
+    total: S.Number,
+    used: S.Number,
+  }),
+).annotate({
+  identifier: "GetNodeStatusResponseMemory",
+}) as any as S.Schema<GetNodeStatusResponseMemory>;
+
+export interface GetNodeStatusResponseRoot {
+  avail: number;
+  total: number;
+  used: number;
+}
+export const GetNodeStatusResponseRoot = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    avail: S.Number,
+    total: S.Number,
+    used: S.Number,
+  }),
+).annotate({
+  identifier: "GetNodeStatusResponseRoot",
+}) as any as S.Schema<GetNodeStatusResponseRoot>;
+
+export type GetNodeStatusResponseSwap = GetNodeStatusResponseMemory;
+export const GetNodeStatusResponseSwap = GetNodeStatusResponseMemory;
+
+export interface GetNodeStatusResponse {
+  boot_info?: GetNodeStatusResponseBootInfo;
+  cpu: number;
+  cpuinfo: GetNodeStatusResponseCpuinfo;
+  current_kernel?: GetNodeStatusResponseCurrentKernel;
+  info: GetNodeStatusResponseInfo;
+  kversion: string;
+  loadavg: GetNodeStatusResponseLoadavgList;
+  memory: GetNodeStatusResponseMemory;
+  root: GetNodeStatusResponseRoot;
+  swap: GetNodeStatusResponseMemory;
+  uptime: number;
+  wait: number;
+}
+export const GetNodeStatusResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    boot_info: S.optional(
+      GetNodeStatusResponseBootInfo.pipe(T.Body("boot-info")),
+    ),
+    cpu: S.Number,
+    cpuinfo: GetNodeStatusResponseCpuinfo,
+    current_kernel: S.optional(
+      GetNodeStatusResponseCurrentKernel.pipe(T.Body("current-kernel")),
+    ),
+    info: GetNodeStatusResponseInfo,
+    kversion: S.String,
+    loadavg: GetNodeStatusResponseLoadavgList,
+    memory: GetNodeStatusResponseMemory,
+    root: GetNodeStatusResponseRoot,
+    swap: GetNodeStatusResponseMemory,
+    uptime: S.Number,
+    wait: S.Number,
+  }),
+).annotate({
+  identifier: "GetNodeStatusResponse",
+}) as any as S.Schema<GetNodeStatusResponse>;
+
+export interface GetNodeSubscriptionRequest {
+  node: string;
+}
+export const GetNodeSubscriptionRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    node: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({ method: "GET", uri: "/nodes/{node}/subscription", code: 200 }),
+  ),
+).annotate({
+  identifier: "GetNodeSubscriptionRequest",
+}) as any as S.Schema<GetNodeSubscriptionRequest>;
+
+export type GetNodeSubscriptionResponseStatus =
+  | "new"
+  | "notfound"
+  | "active"
+  | "invalid"
+  | "expired"
+  | "suspended";
+export const GetNodeSubscriptionResponseStatus = S.String;
+
+export interface GetNodeSubscriptionResponse {
+  checktime?: number;
+  key?: string;
+  message?: string;
+  nextduedate?: string;
+  productname?: string;
+  regdate?: string;
+  serverid?: string;
+  signature?: string;
+  status: GetNodeSubscriptionResponseStatus;
+  url?: string;
+}
+export const GetNodeSubscriptionResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    checktime: S.optional(S.Number),
+    key: S.optional(S.String),
+    message: S.optional(S.String),
+    nextduedate: S.optional(S.String),
+    productname: S.optional(S.String),
+    regdate: S.optional(S.String),
+    serverid: S.optional(S.String),
+    signature: S.optional(S.String),
+    status: GetNodeSubscriptionResponseStatus,
+    url: S.optional(S.String),
+  }),
+).annotate({
+  identifier: "GetNodeSubscriptionResponse",
+}) as any as S.Schema<GetNodeSubscriptionResponse>;
+
+export interface GetNodeTaskRequest {
+  node: string;
+  upid: string;
+}
+export const GetNodeTaskRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    node: S.String.pipe(T.Label()),
+    upid: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({ method: "GET", uri: "/nodes/{node}/tasks/{upid}", code: 200 }),
+  ),
+).annotate({
+  identifier: "GetNodeTaskRequest",
+}) as any as S.Schema<GetNodeTaskRequest>;
+
+export interface GetNodeTaskResponse {}
+export const GetNodeTaskResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "GetNodeTaskResponse",
+}) as any as S.Schema<GetNodeTaskResponse>;
+
+export interface GetNodeTaskLogRequest {
+  node: string;
+  upid: string;
+  /** Whether the tasklog file should be downloaded. This parameter can't be used in conjunction with other parameters */
+  download?: string;
+  /** The amount of lines to read from the tasklog. Setting this parameter to 0 will return all lines until the end of the file. */
+  limit?: string;
+  /** Start at this line when reading the tasklog */
+  start?: string;
+  /** Test task status, and set result attribute "active" accordingly. */
+  test_status?: string;
+}
+export const GetNodeTaskLogRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    node: S.String.pipe(T.Label()),
+    upid: S.String.pipe(T.Label()),
+    download: S.optional(S.String.pipe(T.Query())),
+    limit: S.optional(S.String.pipe(T.Query())),
+    start: S.optional(S.String.pipe(T.Query())),
+    test_status: S.optional(S.String.pipe(T.Query("test-status"))),
+  }).pipe(
+    T.Http({ method: "GET", uri: "/nodes/{node}/tasks/{upid}/log", code: 200 }),
+  ),
+).annotate({
+  identifier: "GetNodeTaskLogRequest",
+}) as any as S.Schema<GetNodeTaskLogRequest>;
+
+export interface GetNodeTaskLogResponse {}
+export const GetNodeTaskLogResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "GetNodeTaskLogResponse",
+}) as any as S.Schema<GetNodeTaskLogResponse>;
+
+export interface GetNodeTaskStatusRequest {
+  node: string;
+  upid: string;
+}
+export const GetNodeTaskStatusRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    node: S.String.pipe(T.Label()),
+    upid: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/nodes/{node}/tasks/{upid}/status",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "GetNodeTaskStatusRequest",
+}) as any as S.Schema<GetNodeTaskStatusRequest>;
+
+export interface GetNodeTaskStatusResponse {
+  endtime?: number;
+  exitstatus?: string;
+  id?: string;
+  node: string;
+  pid: number;
+  pstart: number;
+  starttime: number;
+  status: string;
+  tokenid?: string;
+  type: string;
+  upid: string;
+  user: string;
+}
+export const GetNodeTaskStatusResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    endtime: S.optional(S.Number),
+    exitstatus: S.optional(S.String),
+    id: S.optional(S.String),
+    node: S.String,
+    pid: S.Number,
+    pstart: S.Number,
+    starttime: S.Number,
+    status: S.String,
+    tokenid: S.optional(S.String),
+    type: S.String,
+    upid: S.String,
+    user: S.String,
+  }),
+).annotate({
+  identifier: "GetNodeTaskStatusResponse",
+}) as any as S.Schema<GetNodeTaskStatusResponse>;
+
+export interface GetNodeTimeRequest {
+  node: string;
+}
+export const GetNodeTimeRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    node: S.String.pipe(T.Label()),
+  }).pipe(T.Http({ method: "GET", uri: "/nodes/{node}/time", code: 200 })),
+).annotate({
+  identifier: "GetNodeTimeRequest",
+}) as any as S.Schema<GetNodeTimeRequest>;
+
+export interface GetNodeTimeResponse {
+  localtime: number;
+  time: number;
+  timezone: string;
+}
+export const GetNodeTimeResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    localtime: S.Number,
+    time: S.Number,
+    timezone: S.String,
+  }),
+).annotate({
+  identifier: "GetNodeTimeResponse",
+}) as any as S.Schema<GetNodeTimeResponse>;
+
+export interface GetNodeVncwebsocketRequest {
+  node: string;
+  /** Terminal port */
+  port: string;
+  /** Terminal ticket */
+  vncticket: string;
+}
+export const GetNodeVncwebsocketRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    node: S.String.pipe(T.Label()),
+    port: S.String.pipe(T.Query()),
+    vncticket: S.String.pipe(T.Query()),
+  }).pipe(
+    T.Http({ method: "GET", uri: "/nodes/{node}/vncwebsocket", code: 200 }),
+  ),
+).annotate({
+  identifier: "GetNodeVncwebsocketRequest",
+}) as any as S.Schema<GetNodeVncwebsocketRequest>;
+
+export interface GetNodeVncwebsocketResponse {}
+export const GetNodeVncwebsocketResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "GetNodeVncwebsocketResponse",
+}) as any as S.Schema<GetNodeVncwebsocketResponse>;
+
+export interface ListNodeAptUpdateRequest {
+  node: string;
+}
+export const ListNodeAptUpdateRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    node: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({ method: "GET", uri: "/nodes/{node}/apt/update", code: 200 }),
+  ),
+).annotate({
+  identifier: "ListNodeAptUpdateRequest",
+}) as any as S.Schema<ListNodeAptUpdateRequest>;
+
+export interface ListNodeAptUpdateResponseBodyItem {
+  Arch: string;
+  Description: string;
+  ExtraInfo?: string;
+  OldVersion?: string;
+  Origin: string;
+  Package: string;
+  Priority: string;
+  Section: string;
+  Title: string;
+  Version: string;
+}
+export const ListNodeAptUpdateResponseBodyItem = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    Arch: S.String,
+    Description: S.String,
+    ExtraInfo: S.optional(S.String),
+    OldVersion: S.optional(S.String),
+    Origin: S.String,
+    Package: S.String,
+    Priority: S.String,
+    Section: S.String,
+    Title: S.String,
+    Version: S.String,
+  }),
+).annotate({
+  identifier: "ListNodeAptUpdateResponseBodyItem",
+}) as any as S.Schema<ListNodeAptUpdateResponseBodyItem>;
+
+export type ListNodeAptUpdateResponseBodyList =
+  Array<ListNodeAptUpdateResponseBodyItem>;
+export const ListNodeAptUpdateResponseBodyList = /*@__PURE__*/ S.Array(
+  ListNodeAptUpdateResponseBodyItem,
+) as any as S.Schema<ListNodeAptUpdateResponseBodyList>;
+
+export type ListNodeAptUpdateResponse = ListNodeAptUpdateResponseBodyList;
+export const ListNodeAptUpdateResponse = /*@__PURE__*/ S.suspend(() =>
+  ListNodeAptUpdateResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListNodeAptUpdateResponse",
+}) as any as S.Schema<ListNodeAptUpdateResponse>;
+
+export interface ListNodeAptVersionsRequest {
+  node: string;
+}
+export const ListNodeAptVersionsRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    node: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({ method: "GET", uri: "/nodes/{node}/apt/versions", code: 200 }),
+  ),
+).annotate({
+  identifier: "ListNodeAptVersionsRequest",
+}) as any as S.Schema<ListNodeAptVersionsRequest>;
+
+export type ListNodeAptVersionsResponseBodyItem =
+  ListNodeAptUpdateResponseBodyItem;
+export const ListNodeAptVersionsResponseBodyItem =
+  ListNodeAptUpdateResponseBodyItem;
+
+export type ListNodeAptVersionsResponseBodyList =
+  Array<ListNodeAptUpdateResponseBodyItem>;
+export const ListNodeAptVersionsResponseBodyList = /*@__PURE__*/ S.Array(
+  ListNodeAptUpdateResponseBodyItem,
+) as any as S.Schema<ListNodeAptVersionsResponseBodyList>;
+
+export type ListNodeAptVersionsResponse = ListNodeAptVersionsResponseBodyList;
+export const ListNodeAptVersionsResponse = /*@__PURE__*/ S.suspend(() =>
+  ListNodeAptVersionsResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListNodeAptVersionsResponse",
+}) as any as S.Schema<ListNodeAptVersionsResponse>;
+
+export interface ListNodeCertificateInfoRequest {
+  node: string;
+}
+export const ListNodeCertificateInfoRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    node: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/nodes/{node}/certificates/info",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "ListNodeCertificateInfoRequest",
+}) as any as S.Schema<ListNodeCertificateInfoRequest>;
+
+export type ListNodeCertificateInfoResponseBodyItemSanList = Array<string>;
+export const ListNodeCertificateInfoResponseBodyItemSanList =
+  /*@__PURE__*/ S.Array(
+    S.String,
+  ) as any as S.Schema<ListNodeCertificateInfoResponseBodyItemSanList>;
+
+export interface ListNodeCertificateInfoResponseBodyItem {
+  filename: string;
+  fingerprint?: string;
+  issuer: string;
+  notafter?: number;
+  notbefore?: number;
+  pem?: string;
+  public_key_bits?: number;
+  public_key_type?: string;
+  san: ListNodeCertificateInfoResponseBodyItemSanList;
+  subject: string;
+}
+export const ListNodeCertificateInfoResponseBodyItem = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      filename: S.String,
+      fingerprint: S.optional(S.String),
+      issuer: S.String,
+      notafter: S.optional(S.Number),
+      notbefore: S.optional(S.Number),
+      pem: S.optional(S.String),
+      public_key_bits: S.optional(S.Number.pipe(T.Body("public-key-bits"))),
+      public_key_type: S.optional(S.String.pipe(T.Body("public-key-type"))),
+      san: ListNodeCertificateInfoResponseBodyItemSanList,
+      subject: S.String,
+    }),
+).annotate({
+  identifier: "ListNodeCertificateInfoResponseBodyItem",
+}) as any as S.Schema<ListNodeCertificateInfoResponseBodyItem>;
+
+export type ListNodeCertificateInfoResponseBodyList =
+  Array<ListNodeCertificateInfoResponseBodyItem>;
+export const ListNodeCertificateInfoResponseBodyList = /*@__PURE__*/ S.Array(
+  ListNodeCertificateInfoResponseBodyItem,
+) as any as S.Schema<ListNodeCertificateInfoResponseBodyList>;
+
+export type ListNodeCertificateInfoResponse =
+  ListNodeCertificateInfoResponseBodyList;
+export const ListNodeCertificateInfoResponse = /*@__PURE__*/ S.suspend(() =>
+  ListNodeCertificateInfoResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListNodeCertificateInfoResponse",
+}) as any as S.Schema<ListNodeCertificateInfoResponse>;
+
+export interface ListNodeDiskDirectoryRequest {
+  node: string;
+}
+export const ListNodeDiskDirectoryRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    node: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({ method: "GET", uri: "/nodes/{node}/disks/directory", code: 200 }),
+  ),
+).annotate({
+  identifier: "ListNodeDiskDirectoryRequest",
+}) as any as S.Schema<ListNodeDiskDirectoryRequest>;
+
+export type ListNodeDiskDirectoryResponseBodyItemFilesystem = "ext4" | "xfs";
+export const ListNodeDiskDirectoryResponseBodyItemFilesystem = S.String;
+
+export interface ListNodeDiskDirectoryResponseBodyItem {
+  device: string;
+  filesystem?: ListNodeDiskDirectoryResponseBodyItemFilesystem;
+  name: string;
+  options?: string;
+  path: string;
+  removable: unknown;
+  unitfile: string;
+}
+export const ListNodeDiskDirectoryResponseBodyItem = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      device: S.String,
+      filesystem: S.optional(ListNodeDiskDirectoryResponseBodyItemFilesystem),
+      name: S.String,
+      options: S.optional(S.String),
+      path: S.String,
+      removable: S.Unknown,
+      unitfile: S.String,
+    }),
+).annotate({
+  identifier: "ListNodeDiskDirectoryResponseBodyItem",
+}) as any as S.Schema<ListNodeDiskDirectoryResponseBodyItem>;
+
+export type ListNodeDiskDirectoryResponseBodyList =
+  Array<ListNodeDiskDirectoryResponseBodyItem>;
+export const ListNodeDiskDirectoryResponseBodyList = /*@__PURE__*/ S.Array(
+  ListNodeDiskDirectoryResponseBodyItem,
+) as any as S.Schema<ListNodeDiskDirectoryResponseBodyList>;
+
+export type ListNodeDiskDirectoryResponse =
+  ListNodeDiskDirectoryResponseBodyList;
+export const ListNodeDiskDirectoryResponse = /*@__PURE__*/ S.suspend(() =>
+  ListNodeDiskDirectoryResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListNodeDiskDirectoryResponse",
+}) as any as S.Schema<ListNodeDiskDirectoryResponse>;
+
+export type ListNodeDiskListRequestUsageType =
+  | "unused"
+  | "mounted"
+  | "lvm"
+  | "zfs"
+  | "devicemapper"
+  | "partitions"
+  | "filesystem";
+export const ListNodeDiskListRequestUsageType = S.String;
+
+export interface ListNodeDiskListRequest {
+  node: string;
+  /** Include partitions. */
+  include_partitions?: string;
+  /** Skip smart checks. */
+  skipsmart?: string;
+  /** What a block device (disk) is used for. */
+  usage_type?: ListNodeDiskListRequestUsageType | (string & {});
+}
+export const ListNodeDiskListRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    node: S.String.pipe(T.Label()),
+    include_partitions: S.optional(
+      S.String.pipe(T.Query("include-partitions")),
+    ),
+    skipsmart: S.optional(S.String.pipe(T.Query())),
+    usage_type: S.optional(
+      ListNodeDiskListRequestUsageType.pipe(T.Query("usage-type")),
+    ),
+  }).pipe(
+    T.Http({ method: "GET", uri: "/nodes/{node}/disks/list", code: 200 }),
+  ),
+).annotate({
+  identifier: "ListNodeDiskListRequest",
+}) as any as S.Schema<ListNodeDiskListRequest>;
+
+export type ListNodeDiskListResponseBodyItemDiskType =
+  | "unknown"
+  | "hdd"
+  | "ssd"
+  | "usb";
+export const ListNodeDiskListResponseBodyItemDiskType = S.String;
+
+export type ListNodeDiskListResponseBodyItemPartitionsItemUsed =
+  | "unused"
+  | "lvm"
+  | "zfs"
+  | "zfsreserved"
+  | "efi"
+  | "bios"
+  | "filesystem";
+export const ListNodeDiskListResponseBodyItemPartitionsItemUsed = S.String;
+
+export interface ListNodeDiskListResponseBodyItemPartitionsItem {
+  devpath?: string;
+  filesystem?: string;
+  gpt: unknown;
+  mounted: unknown;
+  name: string;
+  size?: number;
+  used: ListNodeDiskListResponseBodyItemPartitionsItemUsed;
+  uuid?: string;
+}
+export const ListNodeDiskListResponseBodyItemPartitionsItem =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      devpath: S.optional(S.String),
+      filesystem: S.optional(S.String),
+      gpt: S.Unknown,
+      mounted: S.Unknown,
+      name: S.String,
+      size: S.optional(S.Number),
+      used: ListNodeDiskListResponseBodyItemPartitionsItemUsed,
+      uuid: S.optional(S.String),
+    }),
+  ).annotate({
+    identifier: "ListNodeDiskListResponseBodyItemPartitionsItem",
+  }) as any as S.Schema<ListNodeDiskListResponseBodyItemPartitionsItem>;
+
+export type ListNodeDiskListResponseBodyItemPartitionsList =
+  Array<ListNodeDiskListResponseBodyItemPartitionsItem>;
+export const ListNodeDiskListResponseBodyItemPartitionsList =
+  /*@__PURE__*/ S.Array(
+    ListNodeDiskListResponseBodyItemPartitionsItem,
+  ) as any as S.Schema<ListNodeDiskListResponseBodyItemPartitionsList>;
+
+export type ListNodeDiskListResponseBodyItemStatus =
+  | "passed"
+  | "failed"
+  | "unknown";
+export const ListNodeDiskListResponseBodyItemStatus = S.String;
+
+export type ListNodeDiskListResponseBodyItemUsed =
+  | "unused"
+  | "mounted"
+  | "lvm"
+  | "zfs"
+  | "devicemapper"
+  | "partitions"
+  | "filesystem";
+export const ListNodeDiskListResponseBodyItemUsed = S.String;
+
+export interface ListNodeDiskListResponseBodyItem {
+  devpath?: string;
+  disk_type?: ListNodeDiskListResponseBodyItemDiskType;
+  gpt: unknown;
+  model?: string;
+  name: string;
+  partitions?: ListNodeDiskListResponseBodyItemPartitionsList;
+  rpm?: number;
+  serial?: string;
+  size: number;
+  status: ListNodeDiskListResponseBodyItemStatus;
+  used: ListNodeDiskListResponseBodyItemUsed;
+  vendor?: string;
+  wearout?: number;
+  wwn?: string;
+}
+export const ListNodeDiskListResponseBodyItem = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    devpath: S.optional(S.String),
+    disk_type: S.optional(
+      ListNodeDiskListResponseBodyItemDiskType.pipe(T.Body("disk-type")),
+    ),
+    gpt: S.Unknown,
+    model: S.optional(S.String),
+    name: S.String,
+    partitions: S.optional(ListNodeDiskListResponseBodyItemPartitionsList),
+    rpm: S.optional(S.Number),
+    serial: S.optional(S.String),
+    size: S.Number,
+    status: ListNodeDiskListResponseBodyItemStatus,
+    used: ListNodeDiskListResponseBodyItemUsed,
+    vendor: S.optional(S.String),
+    wearout: S.optional(S.Number),
+    wwn: S.optional(S.String),
+  }),
+).annotate({
+  identifier: "ListNodeDiskListResponseBodyItem",
+}) as any as S.Schema<ListNodeDiskListResponseBodyItem>;
+
+export type ListNodeDiskListResponseBodyList =
+  Array<ListNodeDiskListResponseBodyItem>;
+export const ListNodeDiskListResponseBodyList = /*@__PURE__*/ S.Array(
+  ListNodeDiskListResponseBodyItem,
+) as any as S.Schema<ListNodeDiskListResponseBodyList>;
+
+export type ListNodeDiskListResponse = ListNodeDiskListResponseBodyList;
+export const ListNodeDiskListResponse = /*@__PURE__*/ S.suspend(() =>
+  ListNodeDiskListResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListNodeDiskListResponse",
+}) as any as S.Schema<ListNodeDiskListResponse>;
+
+export interface ListNodeDiskZfsRequest {
+  node: string;
+}
+export const ListNodeDiskZfsRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    node: S.String.pipe(T.Label()),
+  }).pipe(T.Http({ method: "GET", uri: "/nodes/{node}/disks/zfs", code: 200 })),
+).annotate({
+  identifier: "ListNodeDiskZfsRequest",
+}) as any as S.Schema<ListNodeDiskZfsRequest>;
+
+export interface ListNodeDiskZfsResponseBodyItem {
+  alloc: number;
+  dedup: number;
+  frag: number;
+  free: number;
+  health: string;
+  name: string;
+  size: number;
+}
+export const ListNodeDiskZfsResponseBodyItem = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    alloc: S.Number,
+    dedup: S.Number,
+    frag: S.Number,
+    free: S.Number,
+    health: S.String,
+    name: S.String,
+    size: S.Number,
+  }),
+).annotate({
+  identifier: "ListNodeDiskZfsResponseBodyItem",
+}) as any as S.Schema<ListNodeDiskZfsResponseBodyItem>;
+
+export type ListNodeDiskZfsResponseBodyList =
+  Array<ListNodeDiskZfsResponseBodyItem>;
+export const ListNodeDiskZfsResponseBodyList = /*@__PURE__*/ S.Array(
+  ListNodeDiskZfsResponseBodyItem,
+) as any as S.Schema<ListNodeDiskZfsResponseBodyList>;
+
+export type ListNodeDiskZfsResponse = ListNodeDiskZfsResponseBodyList;
+export const ListNodeDiskZfsResponse = /*@__PURE__*/ S.suspend(() =>
+  ListNodeDiskZfsResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListNodeDiskZfsResponse",
+}) as any as S.Schema<ListNodeDiskZfsResponse>;
+
+export interface ListNodeNetworkRequest {
+  node: string;
+}
+export const ListNodeNetworkRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    node: S.String.pipe(T.Label()),
+  }).pipe(T.Http({ method: "GET", uri: "/nodes/{node}/network", code: 200 })),
+).annotate({
+  identifier: "ListNodeNetworkRequest",
+}) as any as S.Schema<ListNodeNetworkRequest>;
+
+export type ListNodeNetworkResponseBodyItemAltnamesList = Array<string>;
+export const ListNodeNetworkResponseBodyItemAltnamesList =
+  /*@__PURE__*/ S.Array(
+    S.String,
+  ) as any as S.Schema<ListNodeNetworkResponseBodyItemAltnamesList>;
+
+export type ListNodeNetworkResponseBodyItemBondMode =
+  | "balance-rr"
+  | "active-backup"
+  | "balance-xor"
+  | "broadcast"
+  | "802.3ad"
+  | "balance-tlb"
+  | "balance-alb";
+export const ListNodeNetworkResponseBodyItemBondMode = S.String;
+
+export type ListNodeNetworkResponseBodyItemBondXmitHashPolicy =
+  | "layer2"
+  | "layer2+3"
+  | "layer3+4";
+export const ListNodeNetworkResponseBodyItemBondXmitHashPolicy = S.String;
+
+export type ListNodeNetworkResponseBodyItemBridgePortsList = Array<string>;
+export const ListNodeNetworkResponseBodyItemBridgePortsList =
+  /*@__PURE__*/ S.Array(
+    S.String,
+  ) as any as S.Schema<ListNodeNetworkResponseBodyItemBridgePortsList>;
+
+export type ListNodeNetworkResponseBodyItemMethod =
+  | "manual"
+  | "static"
+  | "dhcp"
+  | "loopback";
+export const ListNodeNetworkResponseBodyItemMethod = S.String;
+
+export type ListNodeNetworkResponseBodyItemMethod6 =
+  | "manual"
+  | "static"
+  | "dhcp"
+  | "loopback";
+export const ListNodeNetworkResponseBodyItemMethod6 = S.String;
+
+export type ListNodeNetworkResponseBodyItemOptionsList = Array<string>;
+export const ListNodeNetworkResponseBodyItemOptionsList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<ListNodeNetworkResponseBodyItemOptionsList>;
+
+export type ListNodeNetworkResponseBodyItemOptions6List = Array<string>;
+export const ListNodeNetworkResponseBodyItemOptions6List =
+  /*@__PURE__*/ S.Array(
+    S.String,
+  ) as any as S.Schema<ListNodeNetworkResponseBodyItemOptions6List>;
+
+export type ListNodeNetworkResponseBodyItemSlavesList = Array<string>;
+export const ListNodeNetworkResponseBodyItemSlavesList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<ListNodeNetworkResponseBodyItemSlavesList>;
+
+export type ListNodeNetworkResponseBodyItemType =
+  | "loopback"
+  | "eth"
+  | "bridge"
+  | "bond"
+  | "vlan"
+  | "alias"
+  | "unknown";
+export const ListNodeNetworkResponseBodyItemType = S.String;
+
+export interface ListNodeNetworkResponseBodyItem {
+  active: unknown;
+  altnames: ListNodeNetworkResponseBodyItemAltnamesList;
+  autostart: unknown;
+  bond_primary?: string;
+  bond_mode?: ListNodeNetworkResponseBodyItemBondMode;
+  bond_xmit_hash_policy?: ListNodeNetworkResponseBodyItemBondXmitHashPolicy;
+  bridge_ports?: ListNodeNetworkResponseBodyItemBridgePortsList;
+  bridge_vlan_aware?: unknown;
+  cidr?: string;
+  cidr6?: string;
+  comments?: string;
+  comments6?: string;
+  gateway?: string;
+  gateway6?: string;
+  method?: ListNodeNetworkResponseBodyItemMethod;
+  method6?: ListNodeNetworkResponseBodyItemMethod6;
+  mtu?: number;
+  name: string;
+  options: ListNodeNetworkResponseBodyItemOptionsList;
+  options6: ListNodeNetworkResponseBodyItemOptions6List;
+  slaves?: ListNodeNetworkResponseBodyItemSlavesList;
+  type: ListNodeNetworkResponseBodyItemType;
+  vlan_id?: number;
+  vlan_raw_device?: string;
+}
+export const ListNodeNetworkResponseBodyItem = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    active: S.Unknown,
+    altnames: ListNodeNetworkResponseBodyItemAltnamesList,
+    autostart: S.Unknown,
+    bond_primary: S.optional(S.String.pipe(T.Body("bond-primary"))),
+    bond_mode: S.optional(ListNodeNetworkResponseBodyItemBondMode),
+    bond_xmit_hash_policy: S.optional(
+      ListNodeNetworkResponseBodyItemBondXmitHashPolicy,
+    ),
+    bridge_ports: S.optional(ListNodeNetworkResponseBodyItemBridgePortsList),
+    bridge_vlan_aware: S.optional(S.Unknown),
+    cidr: S.optional(S.String),
+    cidr6: S.optional(S.String),
+    comments: S.optional(S.String),
+    comments6: S.optional(S.String),
+    gateway: S.optional(S.String),
+    gateway6: S.optional(S.String),
+    method: S.optional(ListNodeNetworkResponseBodyItemMethod),
+    method6: S.optional(ListNodeNetworkResponseBodyItemMethod6),
+    mtu: S.optional(S.Number),
+    name: S.String,
+    options: ListNodeNetworkResponseBodyItemOptionsList,
+    options6: ListNodeNetworkResponseBodyItemOptions6List,
+    slaves: S.optional(ListNodeNetworkResponseBodyItemSlavesList),
+    type: ListNodeNetworkResponseBodyItemType,
+    vlan_id: S.optional(S.Number.pipe(T.Body("vlan-id"))),
+    vlan_raw_device: S.optional(S.String.pipe(T.Body("vlan-raw-device"))),
+  }),
+).annotate({
+  identifier: "ListNodeNetworkResponseBodyItem",
+}) as any as S.Schema<ListNodeNetworkResponseBodyItem>;
+
+export type ListNodeNetworkResponseBodyList =
+  Array<ListNodeNetworkResponseBodyItem>;
+export const ListNodeNetworkResponseBodyList = /*@__PURE__*/ S.Array(
+  ListNodeNetworkResponseBodyItem,
+) as any as S.Schema<ListNodeNetworkResponseBodyList>;
+
+export type ListNodeNetworkResponse = ListNodeNetworkResponseBodyList;
+export const ListNodeNetworkResponse = /*@__PURE__*/ S.suspend(() =>
+  ListNodeNetworkResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListNodeNetworkResponse",
+}) as any as S.Schema<ListNodeNetworkResponse>;
+
+export interface ListNodeServicesRequest {
+  node: string;
+}
+export const ListNodeServicesRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    node: S.String.pipe(T.Label()),
+  }).pipe(T.Http({ method: "GET", uri: "/nodes/{node}/services", code: 200 })),
+).annotate({
+  identifier: "ListNodeServicesRequest",
+}) as any as S.Schema<ListNodeServicesRequest>;
+
+export interface ListNodeServicesResponseBodyItem {
+  desc: string;
+  name: string;
+  service: string;
+  state: string;
+  unit_state?: string;
+}
+export const ListNodeServicesResponseBodyItem = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    desc: S.String,
+    name: S.String,
+    service: S.String,
+    state: S.String,
+    unit_state: S.optional(S.String.pipe(T.Body("unit-state"))),
+  }),
+).annotate({
+  identifier: "ListNodeServicesResponseBodyItem",
+}) as any as S.Schema<ListNodeServicesResponseBodyItem>;
+
+export type ListNodeServicesResponseBodyList =
+  Array<ListNodeServicesResponseBodyItem>;
+export const ListNodeServicesResponseBodyList = /*@__PURE__*/ S.Array(
+  ListNodeServicesResponseBodyItem,
+) as any as S.Schema<ListNodeServicesResponseBodyList>;
+
+export type ListNodeServicesResponse = ListNodeServicesResponseBodyList;
+export const ListNodeServicesResponse = /*@__PURE__*/ S.suspend(() =>
+  ListNodeServicesResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListNodeServicesResponse",
+}) as any as S.Schema<ListNodeServicesResponse>;
+
+export interface ListNodeSyslogRequest {
+  node: string;
+  /** Max. number of lines. */
+  limit?: string;
+  /** Service ID. */
+  service?: string;
+  /** Display all log since this date-time string. */
+  since?: string;
+  /** Start line number. */
+  start?: string;
+  /** Display all log until this date-time string. */
+  until?: string;
+}
+export const ListNodeSyslogRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    node: S.String.pipe(T.Label()),
+    limit: S.optional(S.String.pipe(T.Query())),
+    service: S.optional(S.String.pipe(T.Query())),
+    since: S.optional(S.String.pipe(T.Query())),
+    start: S.optional(S.String.pipe(T.Query())),
+    until: S.optional(S.String.pipe(T.Query())),
+  }).pipe(T.Http({ method: "GET", uri: "/nodes/{node}/syslog", code: 200 })),
+).annotate({
+  identifier: "ListNodeSyslogRequest",
+}) as any as S.Schema<ListNodeSyslogRequest>;
+
+export interface ListNodeSyslogResponseBodyItem {
+  n: number;
+  t: string;
+}
+export const ListNodeSyslogResponseBodyItem = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    n: S.Number,
+    t: S.String,
+  }),
+).annotate({
+  identifier: "ListNodeSyslogResponseBodyItem",
+}) as any as S.Schema<ListNodeSyslogResponseBodyItem>;
+
+export type ListNodeSyslogResponseBodyList =
+  Array<ListNodeSyslogResponseBodyItem>;
+export const ListNodeSyslogResponseBodyList = /*@__PURE__*/ S.Array(
+  ListNodeSyslogResponseBodyItem,
+) as any as S.Schema<ListNodeSyslogResponseBodyList>;
+
+export type ListNodeSyslogResponse = ListNodeSyslogResponseBodyList;
+export const ListNodeSyslogResponse = /*@__PURE__*/ S.suspend(() =>
+  ListNodeSyslogResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListNodeSyslogResponse",
+}) as any as S.Schema<ListNodeSyslogResponse>;
+
+export type ListNodeTasksRequestStatusfilterItem =
+  | "ok"
+  | "warning"
+  | "error"
+  | "unknown";
+export const ListNodeTasksRequestStatusfilterItem = S.String;
+
+export type ListNodeTasksRequestStatusfilterList = Array<
+  ListNodeTasksRequestStatusfilterItem | (string & {})
+>;
+export const ListNodeTasksRequestStatusfilterList = /*@__PURE__*/ S.Array(
+  ListNodeTasksRequestStatusfilterItem,
+) as any as S.Schema<ListNodeTasksRequestStatusfilterList>;
+
+export interface ListNodeTasksRequest {
+  node: string;
+  /** Only list erroneous tasks. */
+  errors?: string;
+  /** Only list this amount of tasks. (0 means no limit) */
+  limit?: string;
+  /** Only list running tasks. */
+  running?: string;
+  /** Only list tasks since this UNIX epoch. */
+  since?: string;
+  /** List tasks beginning from this offset. */
+  start?: string;
+  /** Only list tasks which have any one of the listed status. */
+  statusfilter?: ListNodeTasksRequestStatusfilterList;
+  /** Datastore name. */
+  store?: string;
+  /** Only list tasks whose type contains this. */
+  typefilter?: string;
+  /** Only list tasks until this UNIX epoch. */
+  until?: string;
+  /** Only list tasks from this user. */
+  userfilter?: string;
+}
+export const ListNodeTasksRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    node: S.String.pipe(T.Label()),
+    errors: S.optional(S.String.pipe(T.Query())),
+    limit: S.optional(S.String.pipe(T.Query())),
+    running: S.optional(S.String.pipe(T.Query())),
+    since: S.optional(S.String.pipe(T.Query())),
+    start: S.optional(S.String.pipe(T.Query())),
+    statusfilter: S.optional(
+      ListNodeTasksRequestStatusfilterList.pipe(T.Query()),
+    ),
+    store: S.optional(S.String.pipe(T.Query())),
+    typefilter: S.optional(S.String.pipe(T.Query())),
+    until: S.optional(S.String.pipe(T.Query())),
+    userfilter: S.optional(S.String.pipe(T.Query())),
+  }).pipe(T.Http({ method: "GET", uri: "/nodes/{node}/tasks", code: 200 })),
+).annotate({
+  identifier: "ListNodeTasksRequest",
+}) as any as S.Schema<ListNodeTasksRequest>;
+
+export interface ListNodeTasksResponseBodyItem {
+  endtime?: number;
+  node: string;
+  pid: number;
+  pstart: number;
+  starttime: number;
+  status?: string;
+  upid: string;
+  user: string;
+  worker_id?: string;
+  worker_type: string;
+}
+export const ListNodeTasksResponseBodyItem = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    endtime: S.optional(S.Number),
+    node: S.String,
+    pid: S.Number,
+    pstart: S.Number,
+    starttime: S.Number,
+    status: S.optional(S.String),
+    upid: S.String,
+    user: S.String,
+    worker_id: S.optional(S.String),
+    worker_type: S.String,
+  }),
+).annotate({
+  identifier: "ListNodeTasksResponseBodyItem",
+}) as any as S.Schema<ListNodeTasksResponseBodyItem>;
+
+export type ListNodeTasksResponseBodyList =
+  Array<ListNodeTasksResponseBodyItem>;
+export const ListNodeTasksResponseBodyList = /*@__PURE__*/ S.Array(
+  ListNodeTasksResponseBodyItem,
+) as any as S.Schema<ListNodeTasksResponseBodyList>;
+
+export type ListNodeTasksResponse = ListNodeTasksResponseBodyList;
+export const ListNodeTasksResponse = /*@__PURE__*/ S.suspend(() =>
+  ListNodeTasksResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListNodeTasksResponse",
+}) as any as S.Schema<ListNodeTasksResponse>;
+
+export interface PutNodeAptRepositoriesRequest {
+  node: string;
+  /** Prevent changes if current configuration file has different SHA256 digest. This can be used to prevent concurrent modifications. */
+  digest?: string;
+  /** Handle referencing a standard APT repository. */
+  handle: string;
+}
+export const PutNodeAptRepositoriesRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    node: S.String.pipe(T.Label()),
+    digest: S.optional(S.String),
+    handle: S.String,
+  }).pipe(
+    T.Http({
+      method: "PUT",
+      uri: "/nodes/{node}/apt/repositories",
+      code: 200,
+      contentType: "form-urlencoded",
+    }),
+  ),
+).annotate({
+  identifier: "PutNodeAptRepositoriesRequest",
+}) as any as S.Schema<PutNodeAptRepositoriesRequest>;
+
+export interface PutNodeAptRepositoriesResponse {}
+export const PutNodeAptRepositoriesResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "PutNodeAptRepositoriesResponse",
+}) as any as S.Schema<PutNodeAptRepositoriesResponse>;
+
+export interface PutNodeCertificateAcmeCertificateRequest {
+  node: string;
+  /** Force replacement of existing files. */
+  force?: string;
+}
+export const PutNodeCertificateAcmeCertificateRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      node: S.String.pipe(T.Label()),
+      force: S.optional(S.String),
+    }).pipe(
+      T.Http({
+        method: "PUT",
+        uri: "/nodes/{node}/certificates/acme/certificate",
+        code: 200,
+        contentType: "form-urlencoded",
+      }),
+    ),
+).annotate({
+  identifier: "PutNodeCertificateAcmeCertificateRequest",
+}) as any as S.Schema<PutNodeCertificateAcmeCertificateRequest>;
+
+export interface PutNodeCertificateAcmeCertificateResponse {}
+export const PutNodeCertificateAcmeCertificateResponse =
+  /*@__PURE__*/ S.suspend(() => S.Struct({})).annotate({
+    identifier: "PutNodeCertificateAcmeCertificateResponse",
+  }) as any as S.Schema<PutNodeCertificateAcmeCertificateResponse>;
+
+export type PutNodeConfigRequestDefaultLang =
+  | "ar"
+  | "ca"
+  | "da"
+  | "de"
+  | "en"
+  | "es"
+  | "eu"
+  | "fa"
+  | "fr"
+  | "gl"
+  | "he"
+  | "hu"
+  | "it"
+  | "ja"
+  | "kr"
+  | "nb"
+  | "nl"
+  | "nn"
+  | "pl"
+  | "pt_BR"
+  | "ru"
+  | "sl"
+  | "sv"
+  | "tr"
+  | "zh_CN"
+  | "zh_TW";
+export const PutNodeConfigRequestDefaultLang = S.String;
+
+export type PutNodeConfigRequestDeleteItem =
+  | "acme"
+  | "acmedomain0"
+  | "acmedomain1"
+  | "acmedomain2"
+  | "acmedomain3"
+  | "acmedomain4"
+  | "http-proxy"
+  | "email-from"
+  | "ciphers-tls-1.3"
+  | "ciphers-tls-1.2"
+  | "default-lang"
+  | "description"
+  | "task-log-max-days"
+  | "consent-text"
+  | "location";
+export const PutNodeConfigRequestDeleteItem = S.String;
+
+export type PutNodeConfigRequestDeleteList = Array<
+  PutNodeConfigRequestDeleteItem | (string & {})
+>;
+export const PutNodeConfigRequestDeleteList = /*@__PURE__*/ S.Array(
+  PutNodeConfigRequestDeleteItem,
+) as any as S.Schema<PutNodeConfigRequestDeleteList>;
+
+export interface PutNodeConfigRequest {
+  node: string;
+  /** The acme account to use on this node. */
+  acme?: string;
+  /** ACME domain configuration string */
+  acmedomain0?: string;
+  /** ACME domain configuration string */
+  acmedomain1?: string;
+  /** ACME domain configuration string */
+  acmedomain2?: string;
+  /** ACME domain configuration string */
+  acmedomain3?: string;
+  /** ACME domain configuration string */
+  acmedomain4?: string;
+  /** OpenSSL cipher list used by the proxy for TLS <= 1.2 */
+  ciphers_tls_1_2?: string;
+  /** OpenSSL ciphersuites list used by the proxy for TLS 1.3 */
+  ciphers_tls_1_3?: string;
+  /** Consent banner text */
+  consent_text?: string;
+  /** All available languages in Proxmox. Taken from proxmox-i18n repository. pt_BR, zh_CN, and zh_TW use the same case in the translation files. */
+  default_lang?: PutNodeConfigRequestDefaultLang | (string & {});
+  /** List of properties to delete. */
+  delete?: PutNodeConfigRequestDeleteList;
+  /** Comment (multiple lines). */
+  description?: string;
+  /** Digest to protect against concurrent updates */
+  digest?: string;
+  /** E-Mail Address. */
+  email_from?: string;
+  /** HTTP proxy configuration [http://]<host>[:port] */
+  http_proxy?: string;
+  /** The location of the PBS instance. */
+  location?: string;
+  /** Maximum days to keep Task logs */
+  task_log_max_days?: string;
+}
+export const PutNodeConfigRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    node: S.String.pipe(T.Label()),
+    acme: S.optional(S.String),
+    acmedomain0: S.optional(S.String),
+    acmedomain1: S.optional(S.String),
+    acmedomain2: S.optional(S.String),
+    acmedomain3: S.optional(S.String),
+    acmedomain4: S.optional(S.String),
+    ciphers_tls_1_2: S.optional(S.String.pipe(T.Body("ciphers-tls-1.2"))),
+    ciphers_tls_1_3: S.optional(S.String.pipe(T.Body("ciphers-tls-1.3"))),
+    consent_text: S.optional(S.String.pipe(T.Body("consent-text"))),
+    default_lang: S.optional(
+      PutNodeConfigRequestDefaultLang.pipe(T.Body("default-lang")),
+    ),
+    delete: S.optional(PutNodeConfigRequestDeleteList),
+    description: S.optional(S.String),
+    digest: S.optional(S.String),
+    email_from: S.optional(S.String.pipe(T.Body("email-from"))),
+    http_proxy: S.optional(S.String.pipe(T.Body("http-proxy"))),
+    location: S.optional(S.String),
+    task_log_max_days: S.optional(S.String.pipe(T.Body("task-log-max-days"))),
+  }).pipe(
+    T.Http({
+      method: "PUT",
+      uri: "/nodes/{node}/config",
+      code: 200,
+      contentType: "form-urlencoded",
+    }),
+  ),
+).annotate({
+  identifier: "PutNodeConfigRequest",
+}) as any as S.Schema<PutNodeConfigRequest>;
+
+export interface PutNodeConfigResponse {}
+export const PutNodeConfigResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "PutNodeConfigResponse",
+}) as any as S.Schema<PutNodeConfigResponse>;
+
+export interface PutNodeDiskWipediskRequest {
+  node: string;
+  /** (Partition) block device name (/sys/class/block/<name>). */
+  disk: string;
+}
+export const PutNodeDiskWipediskRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    node: S.String.pipe(T.Label()),
+    disk: S.String,
+  }).pipe(
+    T.Http({
+      method: "PUT",
+      uri: "/nodes/{node}/disks/wipedisk",
+      code: 200,
+      contentType: "form-urlencoded",
+    }),
+  ),
+).annotate({
+  identifier: "PutNodeDiskWipediskRequest",
+}) as any as S.Schema<PutNodeDiskWipediskRequest>;
+
+export type PutNodeDiskWipediskResponse = string;
+export const PutNodeDiskWipediskResponse = /*@__PURE__*/ S.suspend(() =>
+  S.String.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "PutNodeDiskWipediskResponse",
+}) as any as S.Schema<PutNodeDiskWipediskResponse>;
+
+export type PutNodeDnsRequestDeleteItem = "dns1" | "dns2" | "dns3";
+export const PutNodeDnsRequestDeleteItem = S.String;
+
+export type PutNodeDnsRequestDeleteList = Array<
+  PutNodeDnsRequestDeleteItem | (string & {})
+>;
+export const PutNodeDnsRequestDeleteList = /*@__PURE__*/ S.Array(
+  PutNodeDnsRequestDeleteItem,
+) as any as S.Schema<PutNodeDnsRequestDeleteList>;
+
+export interface PutNodeDnsRequest {
+  node: string;
+  /** List of properties to delete. */
+  delete?: PutNodeDnsRequestDeleteList;
+  /** Prevent changes if current configuration file has different SHA256 digest. This can be used to prevent concurrent modifications. */
+  digest?: string;
+  /** First name server IP address. */
+  dns1?: string;
+  /** Second name server IP address. */
+  dns2?: string;
+  /** Third name server IP address. */
+  dns3?: string;
+  /** Search domain for host-name lookup. */
+  search?: string;
+}
+export const PutNodeDnsRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    node: S.String.pipe(T.Label()),
+    delete: S.optional(PutNodeDnsRequestDeleteList),
+    digest: S.optional(S.String),
+    dns1: S.optional(S.String),
+    dns2: S.optional(S.String),
+    dns3: S.optional(S.String),
+    search: S.optional(S.String),
+  }).pipe(
+    T.Http({
+      method: "PUT",
+      uri: "/nodes/{node}/dns",
+      code: 200,
+      contentType: "form-urlencoded",
+    }),
+  ),
+).annotate({
+  identifier: "PutNodeDnsRequest",
+}) as any as S.Schema<PutNodeDnsRequest>;
+
+export interface PutNodeDnsResponse {}
+export const PutNodeDnsResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "PutNodeDnsResponse",
+}) as any as S.Schema<PutNodeDnsResponse>;
+
+export interface PutNodeNetworkRequest {
+  node: string;
+}
+export const PutNodeNetworkRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    node: S.String.pipe(T.Label()),
+  }).pipe(T.Http({ method: "PUT", uri: "/nodes/{node}/network", code: 200 })),
+).annotate({
+  identifier: "PutNodeNetworkRequest",
+}) as any as S.Schema<PutNodeNetworkRequest>;
+
+export interface PutNodeNetworkResponse {}
+export const PutNodeNetworkResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "PutNodeNetworkResponse",
+}) as any as S.Schema<PutNodeNetworkResponse>;
+
+export type PutNodeNetwork2RequestBondMode =
+  | "balance-rr"
+  | "active-backup"
+  | "balance-xor"
+  | "broadcast"
+  | "802.3ad"
+  | "balance-tlb"
+  | "balance-alb";
+export const PutNodeNetwork2RequestBondMode = S.String;
+
+export type PutNodeNetwork2RequestBondXmitHashPolicy =
+  | "layer2"
+  | "layer2+3"
+  | "layer3+4";
+export const PutNodeNetwork2RequestBondXmitHashPolicy = S.String;
+
+export type PutNodeNetwork2RequestDeleteItem =
+  | "cidr"
+  | "cidr6"
+  | "gateway"
+  | "gateway6"
+  | "method"
+  | "method6"
+  | "comments"
+  | "comments6"
+  | "mtu"
+  | "autostart"
+  | "bridge_ports"
+  | "bridge_vlan_aware"
+  | "slaves"
+  | "bond-primary"
+  | "bond_xmit_hash_policy";
+export const PutNodeNetwork2RequestDeleteItem = S.String;
+
+export type PutNodeNetwork2RequestDeleteList = Array<
+  PutNodeNetwork2RequestDeleteItem | (string & {})
+>;
+export const PutNodeNetwork2RequestDeleteList = /*@__PURE__*/ S.Array(
+  PutNodeNetwork2RequestDeleteItem,
+) as any as S.Schema<PutNodeNetwork2RequestDeleteList>;
+
+export type PutNodeNetwork2RequestMethod =
+  | "manual"
+  | "static"
+  | "dhcp"
+  | "loopback";
+export const PutNodeNetwork2RequestMethod = S.String;
+
+export type PutNodeNetwork2RequestMethod6 =
+  | "manual"
+  | "static"
+  | "dhcp"
+  | "loopback";
+export const PutNodeNetwork2RequestMethod6 = S.String;
+
+export type PutNodeNetwork2RequestType =
+  | "loopback"
+  | "eth"
+  | "bridge"
+  | "bond"
+  | "vlan"
+  | "alias"
+  | "unknown";
+export const PutNodeNetwork2RequestType = S.String;
+
+export interface PutNodeNetwork2Request {
+  node: string;
+  iface: string;
+  /** Autostart interface. */
+  autostart?: string;
+  /** Network interface name. */
+  bond_primary?: string;
+  /** Linux Bond Mode */
+  bond_mode?: PutNodeNetwork2RequestBondMode | (string & {});
+  /** Bond Transmit Hash Policy for LACP (802.3ad) */
+  bond_xmit_hash_policy?:
+    | PutNodeNetwork2RequestBondXmitHashPolicy
+    | (string & {});
+  /** A list of network devices, comma separated. */
+  bridge_ports?: string;
+  /** Enable bridge vlan support. */
+  bridge_vlan_aware?: string;
+  /** IPv4 address with netmask (CIDR notation). */
+  cidr?: string;
+  /** IPv6 address with netmask (CIDR notation). */
+  cidr6?: string;
+  /** Comments (inet, may span multiple lines) */
+  comments?: string;
+  /** Comments (inet5, may span multiple lines) */
+  comments6?: string;
+  /** List of properties to delete. */
+  delete?: PutNodeNetwork2RequestDeleteList;
+  /** Prevent changes if current configuration file has different SHA256 digest. This can be used to prevent concurrent modifications. */
+  digest?: string;
+  /** IPv4 address. */
+  gateway?: string;
+  /** IPv6 address. */
+  gateway6?: string;
+  /** Interface configuration method */
+  method?: PutNodeNetwork2RequestMethod | (string & {});
+  /** Interface configuration method */
+  method6?: PutNodeNetwork2RequestMethod6 | (string & {});
+  /** Maximum Transmission Unit. */
+  mtu?: string;
+  /** A list of network devices, comma separated. */
+  slaves?: string;
+  /** Network interface type */
+  type?: PutNodeNetwork2RequestType | (string & {});
+  /** VLAN ID. */
+  vlan_id?: string;
+  /** Network interface name. */
+  vlan_raw_device?: string;
+}
+export const PutNodeNetwork2Request = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    node: S.String.pipe(T.Label()),
+    iface: S.String.pipe(T.Label()),
+    autostart: S.optional(S.String),
+    bond_primary: S.optional(S.String.pipe(T.Body("bond-primary"))),
+    bond_mode: S.optional(PutNodeNetwork2RequestBondMode),
+    bond_xmit_hash_policy: S.optional(PutNodeNetwork2RequestBondXmitHashPolicy),
+    bridge_ports: S.optional(S.String),
+    bridge_vlan_aware: S.optional(S.String),
+    cidr: S.optional(S.String),
+    cidr6: S.optional(S.String),
+    comments: S.optional(S.String),
+    comments6: S.optional(S.String),
+    delete: S.optional(PutNodeNetwork2RequestDeleteList),
+    digest: S.optional(S.String),
+    gateway: S.optional(S.String),
+    gateway6: S.optional(S.String),
+    method: S.optional(PutNodeNetwork2RequestMethod),
+    method6: S.optional(PutNodeNetwork2RequestMethod6),
+    mtu: S.optional(S.String),
+    slaves: S.optional(S.String),
+    type: S.optional(PutNodeNetwork2RequestType),
+    vlan_id: S.optional(S.String.pipe(T.Body("vlan-id"))),
+    vlan_raw_device: S.optional(S.String.pipe(T.Body("vlan-raw-device"))),
+  }).pipe(
+    T.Http({
+      method: "PUT",
+      uri: "/nodes/{node}/network/{iface}",
+      code: 200,
+      contentType: "form-urlencoded",
+    }),
+  ),
+).annotate({
+  identifier: "PutNodeNetwork2Request",
+}) as any as S.Schema<PutNodeNetwork2Request>;
+
+export interface PutNodeNetwork2Response {}
+export const PutNodeNetwork2Response = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "PutNodeNetwork2Response",
+}) as any as S.Schema<PutNodeNetwork2Response>;
+
+export interface PutNodeSubscriptionRequest {
+  node: string;
+  /** The subscription key to install. */
+  key: string;
+}
+export const PutNodeSubscriptionRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    node: S.String.pipe(T.Label()),
+    key: S.String,
+  }).pipe(
+    T.Http({
+      method: "PUT",
+      uri: "/nodes/{node}/subscription",
+      code: 200,
+      contentType: "form-urlencoded",
+    }),
+  ),
+).annotate({
+  identifier: "PutNodeSubscriptionRequest",
+}) as any as S.Schema<PutNodeSubscriptionRequest>;
+
+export interface PutNodeSubscriptionResponse {}
+export const PutNodeSubscriptionResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "PutNodeSubscriptionResponse",
+}) as any as S.Schema<PutNodeSubscriptionResponse>;
+
+export interface PutNodeTimeRequest {
+  node: string;
+  /** Time zone. The file '/usr/share/zoneinfo/zone.tab' contains the list of valid names. */
+  timezone: string;
+}
+export const PutNodeTimeRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    node: S.String.pipe(T.Label()),
+    timezone: S.String,
+  }).pipe(
+    T.Http({
+      method: "PUT",
+      uri: "/nodes/{node}/time",
+      code: 200,
+      contentType: "form-urlencoded",
+    }),
+  ),
+).annotate({
+  identifier: "PutNodeTimeRequest",
+}) as any as S.Schema<PutNodeTimeRequest>;
+
+export interface PutNodeTimeResponse {}
+export const PutNodeTimeResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "PutNodeTimeResponse",
+}) as any as S.Schema<PutNodeTimeResponse>;
+
+export interface RestartNodesServiceRequest {
+  node: string;
+  service: string;
+}
+export const RestartNodesServiceRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    node: S.String.pipe(T.Label()),
+    service: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/nodes/{node}/services/{service}/restart",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "RestartNodesServiceRequest",
+}) as any as S.Schema<RestartNodesServiceRequest>;
+
+export interface RestartNodesServiceResponse {}
+export const RestartNodesServiceResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "RestartNodesServiceResponse",
+}) as any as S.Schema<RestartNodesServiceResponse>;
+
+export interface StartNodesServiceRequest {
+  node: string;
+  service: string;
+}
+export const StartNodesServiceRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    node: S.String.pipe(T.Label()),
+    service: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/nodes/{node}/services/{service}/start",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "StartNodesServiceRequest",
+}) as any as S.Schema<StartNodesServiceRequest>;
+
+export interface StartNodesServiceResponse {}
+export const StartNodesServiceResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "StartNodesServiceResponse",
+}) as any as S.Schema<StartNodesServiceResponse>;
+
+export interface StopNodesServiceRequest {
+  node: string;
+  service: string;
+}
+export const StopNodesServiceRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    node: S.String.pipe(T.Label()),
+    service: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/nodes/{node}/services/{service}/stop",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "StopNodesServiceRequest",
+}) as any as S.Schema<StopNodesServiceRequest>;
+
+export interface StopNodesServiceResponse {}
+export const StopNodesServiceResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "StopNodesServiceResponse",
+}) as any as S.Schema<StopNodesServiceResponse>;
+
+export interface UpdateNodesAptRequest {
+  node: string;
+  /** Send notification mail about new package updates available to the email address configured for 'root@pam'). */
+  notify?: string;
+  /** Only produces output suitable for logging, omitting progress indicators. */
+  quiet?: string;
+}
+export const UpdateNodesAptRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    node: S.String.pipe(T.Label()),
+    notify: S.optional(S.String),
+    quiet: S.optional(S.String),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/nodes/{node}/apt/update",
+      code: 200,
+      contentType: "form-urlencoded",
+    }),
+  ),
+).annotate({
+  identifier: "UpdateNodesAptRequest",
+}) as any as S.Schema<UpdateNodesAptRequest>;
+
+export type UpdateNodesAptResponse = string;
+export const UpdateNodesAptResponse = /*@__PURE__*/ S.suspend(() =>
+  S.String.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "UpdateNodesAptResponse",
+}) as any as S.Schema<UpdateNodesAptResponse>;
+
+export type CreateNodeAptRepositoryError = ProxmoxBackupOpError;
+/** Change the properties of the specified repository. The `digest` parameter asserts that the configuration has not been modified. */
+export const createNodeAptRepository: API.OperationMethod<
+  CreateNodeAptRepositoryRequest,
+  CreateNodeAptRepositoryResponse,
+  CreateNodeAptRepositoryError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateNodeAptRepositoryRequest,
+  output: CreateNodeAptRepositoryResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateNodeCertificateAcmeCertificateError = ProxmoxBackupOpError;
+/** Order a new ACME certificate. */
+export const createNodeCertificateAcmeCertificate: API.OperationMethod<
+  CreateNodeCertificateAcmeCertificateRequest,
+  CreateNodeCertificateAcmeCertificateResponse,
+  CreateNodeCertificateAcmeCertificateError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateNodeCertificateAcmeCertificateRequest,
+  output: CreateNodeCertificateAcmeCertificateResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateNodeCertificateCustomError = ProxmoxBackupOpError;
+/** Upload a custom certificate. */
+export const createNodeCertificateCustom: API.OperationMethod<
+  CreateNodeCertificateCustomRequest,
+  CreateNodeCertificateCustomResponse,
+  CreateNodeCertificateCustomError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateNodeCertificateCustomRequest,
+  output: CreateNodeCertificateCustomResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateNodeDiskDirectoryError = ProxmoxBackupOpError;
+/** Create a Filesystem on an unused disk. Will be mounted under `/mnt/datastore/<name>`. */
+export const createNodeDiskDirectory: API.OperationMethod<
+  CreateNodeDiskDirectoryRequest,
+  CreateNodeDiskDirectoryResponse,
+  CreateNodeDiskDirectoryError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateNodeDiskDirectoryRequest,
+  output: CreateNodeDiskDirectoryResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateNodeDiskInitgptError = ProxmoxBackupOpError;
+/** Initialize empty Disk with GPT */
+export const createNodeDiskInitgpt: API.OperationMethod<
+  CreateNodeDiskInitgptRequest,
+  CreateNodeDiskInitgptResponse,
+  CreateNodeDiskInitgptError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateNodeDiskInitgptRequest,
+  output: CreateNodeDiskInitgptResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateNodeDiskZfsError = ProxmoxBackupOpError;
+/** Create a new ZFS pool. Will be mounted under `/mnt/datastore/<name>`. */
+export const createNodeDiskZfs: API.OperationMethod<
+  CreateNodeDiskZfsRequest,
+  CreateNodeDiskZfsResponse,
+  CreateNodeDiskZfsError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateNodeDiskZfsRequest,
+  output: CreateNodeDiskZfsResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateNodeNetworkError = ProxmoxBackupOpError;
+/** Create network interface configuration. */
+export const createNodeNetwork: API.OperationMethod<
+  CreateNodeNetworkRequest,
+  CreateNodeNetworkResponse,
+  CreateNodeNetworkError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateNodeNetworkRequest,
+  output: CreateNodeNetworkResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateNodeServiceReloadError = ProxmoxBackupOpError;
+/** Reload service. */
+export const createNodeServiceReload: API.OperationMethod<
+  CreateNodeServiceReloadRequest,
+  CreateNodeServiceReloadResponse,
+  CreateNodeServiceReloadError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateNodeServiceReloadRequest,
+  output: CreateNodeServiceReloadResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateNodeStatusError = ProxmoxBackupOpError;
+/** Reboot or shutdown the node. */
+export const createNodeStatus: API.OperationMethod<
+  CreateNodeStatusRequest,
+  CreateNodeStatusResponse,
+  CreateNodeStatusError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateNodeStatusRequest,
+  output: CreateNodeStatusResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateNodeSubscriptionError = ProxmoxBackupOpError;
+/** Check and update subscription status. */
+export const createNodeSubscription: API.OperationMethod<
+  CreateNodeSubscriptionRequest,
+  CreateNodeSubscriptionResponse,
+  CreateNodeSubscriptionError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateNodeSubscriptionRequest,
+  output: CreateNodeSubscriptionResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateNodeTermproxyError = ProxmoxBackupOpError;
+/** Call termproxy and return shell ticket */
+export const createNodeTermproxy: API.OperationMethod<
+  CreateNodeTermproxyRequest,
+  CreateNodeTermproxyResponse,
+  CreateNodeTermproxyError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateNodeTermproxyRequest,
+  output: CreateNodeTermproxyResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteNodeCertificateCustomError = ProxmoxBackupOpError;
+/** Delete the current certificate and regenerate a self signed one. */
+export const deleteNodeCertificateCustom: API.OperationMethod<
+  DeleteNodeCertificateCustomRequest,
+  DeleteNodeCertificateCustomResponse,
+  DeleteNodeCertificateCustomError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteNodeCertificateCustomRequest,
+  output: DeleteNodeCertificateCustomResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteNodeDiskDirectoryError = ProxmoxBackupOpError;
+/** Remove a Filesystem mounted under `/mnt/datastore/<name>`. */
+export const deleteNodeDiskDirectory: API.OperationMethod<
+  DeleteNodeDiskDirectoryRequest,
+  DeleteNodeDiskDirectoryResponse,
+  DeleteNodeDiskDirectoryError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteNodeDiskDirectoryRequest,
+  output: DeleteNodeDiskDirectoryResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteNodeNetworkError = ProxmoxBackupOpError;
+/** Revert network configuration (rm /etc/network/interfaces.new). */
+export const deleteNodeNetwork: API.OperationMethod<
+  DeleteNodeNetworkRequest,
+  DeleteNodeNetworkResponse,
+  DeleteNodeNetworkError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteNodeNetworkRequest,
+  output: DeleteNodeNetworkResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteNodeNetwork2Error = ProxmoxBackupOpError;
+/** Remove network interface configuration. */
+export const deleteNodeNetwork2: API.OperationMethod<
+  DeleteNodeNetwork2Request,
+  DeleteNodeNetwork2Response,
+  DeleteNodeNetwork2Error,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteNodeNetwork2Request,
+  output: DeleteNodeNetwork2Response,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteNodeSubscriptionError = ProxmoxBackupOpError;
+/** Delete subscription info. */
+export const deleteNodeSubscription: API.OperationMethod<
+  DeleteNodeSubscriptionRequest,
+  DeleteNodeSubscriptionResponse,
+  DeleteNodeSubscriptionError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteNodeSubscriptionRequest,
+  output: DeleteNodeSubscriptionResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteNodeTaskError = ProxmoxBackupOpError;
+/** Try to stop a task. */
+export const deleteNodeTask: API.OperationMethod<
+  DeleteNodeTaskRequest,
+  DeleteNodeTaskResponse,
+  DeleteNodeTaskError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteNodeTaskRequest,
+  output: DeleteNodeTaskResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetNodeError = ProxmoxBackupOpError;
+/** Directory index. */
+export const getNode: API.OperationMethod<
+  GetNodeRequest,
+  GetNodeResponse,
+  GetNodeError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetNodeRequest,
+  output: GetNodeResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetNodeAptError = ProxmoxBackupOpError;
+/** Directory index. */
+export const getNodeApt: API.OperationMethod<
+  GetNodeAptRequest,
+  GetNodeAptResponse,
+  GetNodeAptError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetNodeAptRequest,
+  output: GetNodeAptResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetNodeAptChangelogError = ProxmoxBackupOpError;
+/** Retrieve the changelog of the specified package. */
+export const getNodeAptChangelog: API.OperationMethod<
+  GetNodeAptChangelogRequest,
+  GetNodeAptChangelogResponse,
+  GetNodeAptChangelogError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetNodeAptChangelogRequest,
+  output: GetNodeAptChangelogResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetNodeAptRepositoriesError = ProxmoxBackupOpError;
+/** Get APT repository information. */
+export const getNodeAptRepositories: API.OperationMethod<
+  GetNodeAptRepositoriesRequest,
+  GetNodeAptRepositoriesResponse,
+  GetNodeAptRepositoriesError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetNodeAptRepositoriesRequest,
+  output: GetNodeAptRepositoriesResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetNodeCertificateAcmeError = ProxmoxBackupOpError;
+/** Directory index. */
+export const getNodeCertificateAcme: API.OperationMethod<
+  GetNodeCertificateAcmeRequest,
+  GetNodeCertificateAcmeResponse,
+  GetNodeCertificateAcmeError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetNodeCertificateAcmeRequest,
+  output: GetNodeCertificateAcmeResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetNodeCertificatesError = ProxmoxBackupOpError;
+/** Directory index. */
+export const getNodeCertificates: API.OperationMethod<
+  GetNodeCertificatesRequest,
+  GetNodeCertificatesResponse,
+  GetNodeCertificatesError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetNodeCertificatesRequest,
+  output: GetNodeCertificatesResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetNodeConfigError = ProxmoxBackupOpError;
+/** Get the node configuration */
+export const getNodeConfig: API.OperationMethod<
+  GetNodeConfigRequest,
+  GetNodeConfigResponse,
+  GetNodeConfigError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetNodeConfigRequest,
+  output: GetNodeConfigResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetNodeDisksError = ProxmoxBackupOpError;
+/** Directory index. */
+export const getNodeDisks: API.OperationMethod<
+  GetNodeDisksRequest,
+  GetNodeDisksResponse,
+  GetNodeDisksError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetNodeDisksRequest,
+  output: GetNodeDisksResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetNodeDiskSmartError = ProxmoxBackupOpError;
+/** Get SMART attributes and health of a disk. */
+export const getNodeDiskSmart: API.OperationMethod<
+  GetNodeDiskSmartRequest,
+  GetNodeDiskSmartResponse,
+  GetNodeDiskSmartError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetNodeDiskSmartRequest,
+  output: GetNodeDiskSmartResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetNodeDiskZfsError = ProxmoxBackupOpError;
+/** Get zpool status details. */
+export const getNodeDiskZfs: API.OperationMethod<
+  GetNodeDiskZfsRequest,
+  GetNodeDiskZfsResponse,
+  GetNodeDiskZfsError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetNodeDiskZfsRequest,
+  output: GetNodeDiskZfsResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetNodeDnsError = ProxmoxBackupOpError;
+/** Read DNS settings. */
+export const getNodeDns: API.OperationMethod<
+  GetNodeDnsRequest,
+  GetNodeDnsResponse,
+  GetNodeDnsError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetNodeDnsRequest,
+  output: GetNodeDnsResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetNodeIdentityError = ProxmoxBackupOpError;
+/** Returns a unique server identity. The ID is derived from `/etc/machine-id`. */
+export const getNodeIdentity: API.OperationMethod<
+  GetNodeIdentityRequest,
+  GetNodeIdentityResponse,
+  GetNodeIdentityError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetNodeIdentityRequest,
+  output: GetNodeIdentityResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetNodeJournalError = ProxmoxBackupOpError;
+/** Read syslog entries. */
+export const getNodeJournal: API.OperationMethod<
+  GetNodeJournalRequest,
+  GetNodeJournalResponse,
+  GetNodeJournalError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetNodeJournalRequest,
+  output: GetNodeJournalResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetNodeNetworkError = ProxmoxBackupOpError;
+/** Read a network interface configuration. */
+export const getNodeNetwork: API.OperationMethod<
+  GetNodeNetworkRequest,
+  GetNodeNetworkResponse,
+  GetNodeNetworkError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetNodeNetworkRequest,
+  output: GetNodeNetworkResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetNodeReportError = ProxmoxBackupOpError;
+/** Generate a report */
+export const getNodeReport: API.OperationMethod<
+  GetNodeReportRequest,
+  GetNodeReportResponse,
+  GetNodeReportError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetNodeReportRequest,
+  output: GetNodeReportResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetNodeRrdError = ProxmoxBackupOpError;
+/** Read node stats */
+export const getNodeRrd: API.OperationMethod<
+  GetNodeRrdRequest,
+  GetNodeRrdResponse,
+  GetNodeRrdError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetNodeRrdRequest,
+  output: GetNodeRrdResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetNodesError = ProxmoxBackupOpError;
+/** List Nodes (only for compatibility) */
+export const getNodes: API.OperationMethod<
+  GetNodesRequest,
+  GetNodesResponse,
+  GetNodesError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetNodesRequest,
+  output: GetNodesResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetNodeServiceError = ProxmoxBackupOpError;
+/** Directory index. */
+export const getNodeService: API.OperationMethod<
+  GetNodeServiceRequest,
+  GetNodeServiceResponse,
+  GetNodeServiceError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetNodeServiceRequest,
+  output: GetNodeServiceResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetNodeServiceStateError = ProxmoxBackupOpError;
+/** Read service properties. */
+export const getNodeServiceState: API.OperationMethod<
+  GetNodeServiceStateRequest,
+  GetNodeServiceStateResponse,
+  GetNodeServiceStateError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetNodeServiceStateRequest,
+  output: GetNodeServiceStateResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetNodeStatusError = ProxmoxBackupOpError;
+/** Read node memory, CPU and (root) disk usage */
+export const getNodeStatus: API.OperationMethod<
+  GetNodeStatusRequest,
+  GetNodeStatusResponse,
+  GetNodeStatusError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetNodeStatusRequest,
+  output: GetNodeStatusResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetNodeSubscriptionError = ProxmoxBackupOpError;
+/** Read subscription info. */
+export const getNodeSubscription: API.OperationMethod<
+  GetNodeSubscriptionRequest,
+  GetNodeSubscriptionResponse,
+  GetNodeSubscriptionError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetNodeSubscriptionRequest,
+  output: GetNodeSubscriptionResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetNodeTaskError = ProxmoxBackupOpError;
+/** Directory index. */
+export const getNodeTask: API.OperationMethod<
+  GetNodeTaskRequest,
+  GetNodeTaskResponse,
+  GetNodeTaskError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetNodeTaskRequest,
+  output: GetNodeTaskResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetNodeTaskLogError = ProxmoxBackupOpError;
+/** Read the task log */
+export const getNodeTaskLog: API.OperationMethod<
+  GetNodeTaskLogRequest,
+  GetNodeTaskLogResponse,
+  GetNodeTaskLogError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetNodeTaskLogRequest,
+  output: GetNodeTaskLogResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetNodeTaskStatusError = ProxmoxBackupOpError;
+/** Get task status. */
+export const getNodeTaskStatus: API.OperationMethod<
+  GetNodeTaskStatusRequest,
+  GetNodeTaskStatusResponse,
+  GetNodeTaskStatusError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetNodeTaskStatusRequest,
+  output: GetNodeTaskStatusResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetNodeTimeError = ProxmoxBackupOpError;
+/** Read server time and time zone settings. */
+export const getNodeTime: API.OperationMethod<
+  GetNodeTimeRequest,
+  GetNodeTimeResponse,
+  GetNodeTimeError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetNodeTimeRequest,
+  output: GetNodeTimeResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetNodeVncwebsocketError = ProxmoxBackupOpError;
+/** Upgraded to websocket */
+export const getNodeVncwebsocket: API.OperationMethod<
+  GetNodeVncwebsocketRequest,
+  GetNodeVncwebsocketResponse,
+  GetNodeVncwebsocketError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetNodeVncwebsocketRequest,
+  output: GetNodeVncwebsocketResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListNodeAptUpdateError = ProxmoxBackupOpError;
+/** List available APT updates */
+export const listNodeAptUpdate: API.OperationMethod<
+  ListNodeAptUpdateRequest,
+  ListNodeAptUpdateResponse,
+  ListNodeAptUpdateError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListNodeAptUpdateRequest,
+  output: ListNodeAptUpdateResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListNodeAptVersionsError = ProxmoxBackupOpError;
+/** Get package information for important Proxmox Backup Server packages. */
+export const listNodeAptVersions: API.OperationMethod<
+  ListNodeAptVersionsRequest,
+  ListNodeAptVersionsResponse,
+  ListNodeAptVersionsError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListNodeAptVersionsRequest,
+  output: ListNodeAptVersionsResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListNodeCertificateInfoError = ProxmoxBackupOpError;
+/** Get certificate info. */
+export const listNodeCertificateInfo: API.OperationMethod<
+  ListNodeCertificateInfoRequest,
+  ListNodeCertificateInfoResponse,
+  ListNodeCertificateInfoError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListNodeCertificateInfoRequest,
+  output: ListNodeCertificateInfoResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListNodeDiskDirectoryError = ProxmoxBackupOpError;
+/** List systemd datastore mount units. */
+export const listNodeDiskDirectory: API.OperationMethod<
+  ListNodeDiskDirectoryRequest,
+  ListNodeDiskDirectoryResponse,
+  ListNodeDiskDirectoryError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListNodeDiskDirectoryRequest,
+  output: ListNodeDiskDirectoryResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListNodeDiskListError = ProxmoxBackupOpError;
+/** List local disks */
+export const listNodeDiskList: API.OperationMethod<
+  ListNodeDiskListRequest,
+  ListNodeDiskListResponse,
+  ListNodeDiskListError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListNodeDiskListRequest,
+  output: ListNodeDiskListResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListNodeDiskZfsError = ProxmoxBackupOpError;
+/** List zfs pools. */
+export const listNodeDiskZfs: API.OperationMethod<
+  ListNodeDiskZfsRequest,
+  ListNodeDiskZfsResponse,
+  ListNodeDiskZfsError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListNodeDiskZfsRequest,
+  output: ListNodeDiskZfsResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListNodeNetworkError = ProxmoxBackupOpError;
+/** List all datastores */
+export const listNodeNetwork: API.OperationMethod<
+  ListNodeNetworkRequest,
+  ListNodeNetworkResponse,
+  ListNodeNetworkError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListNodeNetworkRequest,
+  output: ListNodeNetworkResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListNodeServicesError = ProxmoxBackupOpError;
+/** Service list. */
+export const listNodeServices: API.OperationMethod<
+  ListNodeServicesRequest,
+  ListNodeServicesResponse,
+  ListNodeServicesError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListNodeServicesRequest,
+  output: ListNodeServicesResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListNodeSyslogError = ProxmoxBackupOpError;
+/** Read syslog entries. */
+export const listNodeSyslog: API.OperationMethod<
+  ListNodeSyslogRequest,
+  ListNodeSyslogResponse,
+  ListNodeSyslogError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListNodeSyslogRequest,
+  output: ListNodeSyslogResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListNodeTasksError = ProxmoxBackupOpError;
+/** List tasks. */
+export const listNodeTasks: API.OperationMethod<
+  ListNodeTasksRequest,
+  ListNodeTasksResponse,
+  ListNodeTasksError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListNodeTasksRequest,
+  output: ListNodeTasksResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type PutNodeAptRepositoriesError = ProxmoxBackupOpError;
+/** Add the repository identified by the `handle`. If the repository is already configured, it will be set to enabled. The `digest` parameter asserts that the configuration has not been modified. */
+export const putNodeAptRepositories: API.OperationMethod<
+  PutNodeAptRepositoriesRequest,
+  PutNodeAptRepositoriesResponse,
+  PutNodeAptRepositoriesError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PutNodeAptRepositoriesRequest,
+  output: PutNodeAptRepositoriesResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type PutNodeCertificateAcmeCertificateError = ProxmoxBackupOpError;
+/** Renew the current ACME certificate if it is within its renewal lead time (or always if the `force` parameter is set). */
+export const putNodeCertificateAcmeCertificate: API.OperationMethod<
+  PutNodeCertificateAcmeCertificateRequest,
+  PutNodeCertificateAcmeCertificateResponse,
+  PutNodeCertificateAcmeCertificateError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PutNodeCertificateAcmeCertificateRequest,
+  output: PutNodeCertificateAcmeCertificateResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type PutNodeConfigError = ProxmoxBackupOpError;
+/** Update the node configuration */
+export const putNodeConfig: API.OperationMethod<
+  PutNodeConfigRequest,
+  PutNodeConfigResponse,
+  PutNodeConfigError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PutNodeConfigRequest,
+  output: PutNodeConfigResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type PutNodeDiskWipediskError = ProxmoxBackupOpError;
+/** wipe disk */
+export const putNodeDiskWipedisk: API.OperationMethod<
+  PutNodeDiskWipediskRequest,
+  PutNodeDiskWipediskResponse,
+  PutNodeDiskWipediskError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PutNodeDiskWipediskRequest,
+  output: PutNodeDiskWipediskResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type PutNodeDnsError = ProxmoxBackupOpError;
+/** Update DNS settings. */
+export const putNodeDns: API.OperationMethod<
+  PutNodeDnsRequest,
+  PutNodeDnsResponse,
+  PutNodeDnsError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PutNodeDnsRequest,
+  output: PutNodeDnsResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type PutNodeNetworkError = ProxmoxBackupOpError;
+/** Reload network configuration (requires ifupdown2). */
+export const putNodeNetwork: API.OperationMethod<
+  PutNodeNetworkRequest,
+  PutNodeNetworkResponse,
+  PutNodeNetworkError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PutNodeNetworkRequest,
+  output: PutNodeNetworkResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type PutNodeNetwork2Error = ProxmoxBackupOpError;
+/** Update network interface config. */
+export const putNodeNetwork2: API.OperationMethod<
+  PutNodeNetwork2Request,
+  PutNodeNetwork2Response,
+  PutNodeNetwork2Error,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PutNodeNetwork2Request,
+  output: PutNodeNetwork2Response,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type PutNodeSubscriptionError = ProxmoxBackupOpError;
+/** Set a subscription key and check it. */
+export const putNodeSubscription: API.OperationMethod<
+  PutNodeSubscriptionRequest,
+  PutNodeSubscriptionResponse,
+  PutNodeSubscriptionError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PutNodeSubscriptionRequest,
+  output: PutNodeSubscriptionResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type PutNodeTimeError = ProxmoxBackupOpError;
+/** Set time zone */
+export const putNodeTime: API.OperationMethod<
+  PutNodeTimeRequest,
+  PutNodeTimeResponse,
+  PutNodeTimeError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PutNodeTimeRequest,
+  output: PutNodeTimeResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type RestartNodesServiceError = ProxmoxBackupOpError;
+/** Restart service. */
+export const restartNodesService: API.OperationMethod<
+  RestartNodesServiceRequest,
+  RestartNodesServiceResponse,
+  RestartNodesServiceError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: RestartNodesServiceRequest,
+  output: RestartNodesServiceResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type StartNodesServiceError = ProxmoxBackupOpError;
+/** Start service. */
+export const startNodesService: API.OperationMethod<
+  StartNodesServiceRequest,
+  StartNodesServiceResponse,
+  StartNodesServiceError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: StartNodesServiceRequest,
+  output: StartNodesServiceResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type StopNodesServiceError = ProxmoxBackupOpError;
+/** Stop service. */
+export const stopNodesService: API.OperationMethod<
+  StopNodesServiceRequest,
+  StopNodesServiceResponse,
+  StopNodesServiceError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: StopNodesServiceRequest,
+  output: StopNodesServiceResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));
+
+export type UpdateNodesAptError = ProxmoxBackupOpError;
+/** Update the APT database */
+export const updateNodesApt: API.OperationMethod<
+  UpdateNodesAptRequest,
+  UpdateNodesAptResponse,
+  UpdateNodesAptError,
+  ProxmoxBackupOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: UpdateNodesAptRequest,
+  output: UpdateNodesAptResponse,
+  errors: [],
+  protocol: ProxmoxBackupProtocol,
+  retry: Retry.Retry,
+}));