@distilled.cloud/stackit 0.0.0-stage → 1.0.0-rc.14

package/src/services/server_backup.ts

@@ -0,0 +1,983 @@
+import * as API from "@distilled.cloud/core/api";
+import * as C from "@distilled.cloud/core/category";
+// AUTO-GENERATED by scripts/generate.ts from .generated-specs (specs/spec-mirror-stackit). Do not edit.
+import * as S from "@distilled.cloud/core/schema";
+import { UnknownStackitError } from "../errors.ts";
+import { StackitProtocol, type StackitOpError, type StackitOpContext } from "../protocol.ts";
+import * as Retry from "../retry.ts";
+import * as T from "../traits.ts";
+
+export type { StackitOpError, StackitOpContext };
+
+export class BadRequest
+  extends /*@__PURE__*/ T.applyErrorMatchers(
+    /*@__PURE__*/ S.TaggedError<BadRequest>()("BadRequest", {
+      code: S.Number,
+      message: S.String,
+    }).pipe(C.withBadRequestError),
+    [{ status: 400 }],
+  ) {}
+
+export class Conflict
+  extends /*@__PURE__*/ T.applyErrorMatchers(
+    /*@__PURE__*/ S.TaggedError<Conflict>()("Conflict", {
+      code: S.Number,
+      message: S.String,
+    }).pipe(C.withConflictError),
+    [{ status: 409 }],
+  ) {}
+
+export class NotFound
+  extends /*@__PURE__*/ T.applyErrorMatchers(
+    /*@__PURE__*/ S.TaggedError<NotFound>()("NotFound", {
+      code: S.Number,
+      message: S.String,
+    }).pipe(C.withBadRequestError),
+    [{ status: 404 }],
+  ) {}
+
+export type CreateBackupRequestVolumeIdsList = Array<string>;
+export const CreateBackupRequestVolumeIdsList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<CreateBackupRequestVolumeIdsList>;
+
+export interface CreateBackupRequest {
+  /** project id */
+  projectId: string;
+  /** region */
+  region: string;
+  /** server id */
+  serverId: string;
+  /** Max 255 characters */
+  name: string;
+  /** Values are set in days (1-36500) */
+  retentionPeriod: number;
+  volumeIds?: CreateBackupRequestVolumeIdsList;
+}
+export const CreateBackupRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    projectId: S.String.pipe(T.Label()),
+    region: S.String.pipe(T.Label()),
+    serverId: S.String.pipe(T.Label()),
+    name: S.String,
+    retentionPeriod: S.Number,
+    volumeIds: S.optional(CreateBackupRequestVolumeIdsList),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/v2/projects/{projectId}/regions/{region}/servers/{serverId}/backups",
+      code: 200,
+      baseUrl: "https://server-backup.api.stackit.cloud",
+    }),
+  ),
+).annotate({ identifier: "CreateBackupRequest" }) as any as S.Schema<CreateBackupRequest>;
+
+export interface BackupJob {
+  id: string;
+}
+export const BackupJob = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    id: S.String,
+  }),
+).annotate({ identifier: "BackupJob" }) as any as S.Schema<BackupJob>;
+
+export type BackupPropertiesVolumeIdsList = Array<string>;
+export const BackupPropertiesVolumeIdsList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<BackupPropertiesVolumeIdsList>;
+
+export interface BackupProperties {
+  /** Max 255 characters */
+  name: string;
+  /** Values are set in days (1-36500) */
+  retentionPeriod: number;
+  volumeIds?: BackupPropertiesVolumeIdsList;
+}
+export const BackupProperties = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    name: S.String,
+    retentionPeriod: S.Number,
+    volumeIds: S.optional(BackupPropertiesVolumeIdsList),
+  }),
+).annotate({ identifier: "BackupProperties" }) as any as S.Schema<BackupProperties>;
+
+export interface CreateBackupScheduleRequest {
+  /** project id */
+  projectId: string;
+  /** region */
+  region: string;
+  /** server id */
+  serverId: string;
+  backupProperties?: BackupProperties;
+  enabled: boolean;
+  /** Max 255 characters */
+  name: string;
+  /** An rrule (Recurrence Rule) is a standardized string format used in iCalendar (RFC 5545) to define repeating events, and you can generate one by using a dedicated library or by using online generator tools to specify parameters like frequency, interval, and end dates */
+  rrule: string;
+}
+export const CreateBackupScheduleRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    projectId: S.String.pipe(T.Label()),
+    region: S.String.pipe(T.Label()),
+    serverId: S.String.pipe(T.Label()),
+    backupProperties: S.optional(BackupProperties),
+    enabled: S.Boolean,
+    name: S.String,
+    rrule: S.String,
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/v2/projects/{projectId}/regions/{region}/servers/{serverId}/backup-schedules",
+      code: 200,
+      baseUrl: "https://server-backup.api.stackit.cloud",
+    }),
+  ),
+).annotate({
+  identifier: "CreateBackupScheduleRequest",
+}) as any as S.Schema<CreateBackupScheduleRequest>;
+
+export interface BackupSchedule {
+  backupProperties?: BackupProperties;
+  enabled: boolean;
+  id: number;
+  name: string;
+  /** An rrule (Recurrence Rule) is a standardized string format used in iCalendar (RFC 5545) to define repeating events, and you can generate one by using a dedicated library or by using online generator tools to specify parameters like frequency, interval, and end dates */
+  rrule: string;
+}
+export const BackupSchedule = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    backupProperties: S.optional(BackupProperties),
+    enabled: S.Boolean,
+    id: S.Number,
+    name: S.String,
+    rrule: S.String,
+  }),
+).annotate({ identifier: "BackupSchedule" }) as any as S.Schema<BackupSchedule>;
+
+export interface DeleteBackupRequest {
+  /** project id */
+  projectId: string;
+  /** region */
+  region: string;
+  /** server id */
+  serverId: string;
+  /** id of the backup */
+  backupId: string;
+  /** force delete the backup */
+  force?: boolean;
+}
+export const DeleteBackupRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    projectId: S.String.pipe(T.Label()),
+    region: S.String.pipe(T.Label()),
+    serverId: S.String.pipe(T.Label()),
+    backupId: S.String.pipe(T.Label()),
+    force: S.optional(S.Boolean.pipe(T.Query())),
+  }).pipe(
+    T.Http({
+      method: "DELETE",
+      uri: "/v2/projects/{projectId}/regions/{region}/servers/{serverId}/backups/{backupId}",
+      code: 200,
+      baseUrl: "https://server-backup.api.stackit.cloud",
+    }),
+  ),
+).annotate({ identifier: "DeleteBackupRequest" }) as any as S.Schema<DeleteBackupRequest>;
+
+export interface DeleteBackupResponse {}
+export const DeleteBackupResponse = /*@__PURE__*/ S.suspend(() => S.Struct({})).annotate({
+  identifier: "DeleteBackupResponse",
+}) as any as S.Schema<DeleteBackupResponse>;
+
+export interface DeleteBackupScheduleRequest {
+  /** project id */
+  projectId: string;
+  /** region */
+  region: string;
+  /** server id */
+  serverId: string;
+  /** backup schedule id */
+  backupScheduleId: string;
+}
+export const DeleteBackupScheduleRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    projectId: S.String.pipe(T.Label()),
+    region: S.String.pipe(T.Label()),
+    serverId: S.String.pipe(T.Label()),
+    backupScheduleId: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "DELETE",
+      uri: "/v2/projects/{projectId}/regions/{region}/servers/{serverId}/backup-schedules/{backupScheduleId}",
+      code: 200,
+      baseUrl: "https://server-backup.api.stackit.cloud",
+    }),
+  ),
+).annotate({
+  identifier: "DeleteBackupScheduleRequest",
+}) as any as S.Schema<DeleteBackupScheduleRequest>;
+
+export interface DeleteBackupScheduleResponse {}
+export const DeleteBackupScheduleResponse = /*@__PURE__*/ S.suspend(() => S.Struct({})).annotate({
+  identifier: "DeleteBackupScheduleResponse",
+}) as any as S.Schema<DeleteBackupScheduleResponse>;
+
+export interface DeleteVolumeBackupRequest {
+  /** project id */
+  projectId: string;
+  /** region */
+  region: string;
+  /** server id */
+  serverId: string;
+  /** id of the backup */
+  backupId: string;
+  /** id of the volume backup */
+  volumeBackupId: string;
+  /** Force delete the volume backup */
+  force?: boolean;
+}
+export const DeleteVolumeBackupRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    projectId: S.String.pipe(T.Label()),
+    region: S.String.pipe(T.Label()),
+    serverId: S.String.pipe(T.Label()),
+    backupId: S.String.pipe(T.Label()),
+    volumeBackupId: S.String.pipe(T.Label()),
+    force: S.optional(S.Boolean.pipe(T.Query())),
+  }).pipe(
+    T.Http({
+      method: "DELETE",
+      uri: "/v2/projects/{projectId}/regions/{region}/servers/{serverId}/backups/{backupId}/volume-backups/{volumeBackupId}",
+      code: 200,
+      baseUrl: "https://server-backup.api.stackit.cloud",
+    }),
+  ),
+).annotate({
+  identifier: "DeleteVolumeBackupRequest",
+}) as any as S.Schema<DeleteVolumeBackupRequest>;
+
+export interface DeleteVolumeBackupResponse {}
+export const DeleteVolumeBackupResponse = /*@__PURE__*/ S.suspend(() => S.Struct({})).annotate({
+  identifier: "DeleteVolumeBackupResponse",
+}) as any as S.Schema<DeleteVolumeBackupResponse>;
+
+export interface DisableServiceResourceRequest {
+  /** project id */
+  projectId: string;
+  /** region */
+  region: string;
+  /** server id */
+  serverId: string;
+}
+export const DisableServiceResourceRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    projectId: S.String.pipe(T.Label()),
+    region: S.String.pipe(T.Label()),
+    serverId: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "DELETE",
+      uri: "/v2/projects/{projectId}/regions/{region}/servers/{serverId}/service",
+      code: 200,
+      baseUrl: "https://server-backup.api.stackit.cloud",
+    }),
+  ),
+).annotate({
+  identifier: "DisableServiceResourceRequest",
+}) as any as S.Schema<DisableServiceResourceRequest>;
+
+export interface DisableServiceResourceResponse {}
+export const DisableServiceResourceResponse = /*@__PURE__*/ S.suspend(() => S.Struct({})).annotate({
+  identifier: "DisableServiceResourceResponse",
+}) as any as S.Schema<DisableServiceResourceResponse>;
+
+export interface EnableServiceResourceRequest {
+  /** project id */
+  projectId: string;
+  /** region */
+  region: string;
+  /** server id */
+  serverId: string;
+  backupPolicyId?: string;
+}
+export const EnableServiceResourceRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    projectId: S.String.pipe(T.Label()),
+    region: S.String.pipe(T.Label()),
+    serverId: S.String.pipe(T.Label()),
+    backupPolicyId: S.optional(S.String),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/v2/projects/{projectId}/regions/{region}/servers/{serverId}/service",
+      code: 200,
+      baseUrl: "https://server-backup.api.stackit.cloud",
+    }),
+  ),
+).annotate({
+  identifier: "EnableServiceResourceRequest",
+}) as any as S.Schema<EnableServiceResourceRequest>;
+
+export interface EnableServiceResourceResponse {}
+export const EnableServiceResourceResponse = /*@__PURE__*/ S.suspend(() => S.Struct({})).annotate({
+  identifier: "EnableServiceResourceResponse",
+}) as any as S.Schema<EnableServiceResourceResponse>;
+
+export interface GetBackupRequest {
+  /** project id */
+  projectId: string;
+  /** region */
+  region: string;
+  /** server id */
+  serverId: string;
+  /** id of the backup */
+  backupId: string;
+}
+export const GetBackupRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    projectId: S.String.pipe(T.Label()),
+    region: S.String.pipe(T.Label()),
+    serverId: S.String.pipe(T.Label()),
+    backupId: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/v2/projects/{projectId}/regions/{region}/servers/{serverId}/backups/{backupId}",
+      code: 200,
+      baseUrl: "https://server-backup.api.stackit.cloud",
+    }),
+  ),
+).annotate({ identifier: "GetBackupRequest" }) as any as S.Schema<GetBackupRequest>;
+
+export type BackupStatus =
+  | "in-progress"
+  | "inconsistent"
+  | "available"
+  | "error"
+  | "error-restoring"
+  | "error-creating"
+  | "error-deleting"
+  | "unrecognized";
+export const BackupStatus = S.String;
+
+export type BackupVolumeBackupsItemStatus =
+  | "available"
+  | "creating"
+  | "deleting"
+  | "error-deleting"
+  | "error"
+  | "error-restoring"
+  | "restoring"
+  | "error-creating"
+  | "unrecognized";
+export const BackupVolumeBackupsItemStatus = S.String;
+
+export interface BackupVolumeBackupsItem {
+  id?: string;
+  lastRestoredAt?: string;
+  lastRestoredVolumeId?: string;
+  size?: number;
+  status?: BackupVolumeBackupsItemStatus;
+  volumeId?: string;
+}
+export const BackupVolumeBackupsItem = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    id: S.optional(S.String),
+    lastRestoredAt: S.optional(S.String),
+    lastRestoredVolumeId: S.optional(S.String),
+    size: S.optional(S.Number),
+    status: S.optional(BackupVolumeBackupsItemStatus),
+    volumeId: S.optional(S.String),
+  }),
+).annotate({ identifier: "BackupVolumeBackupsItem" }) as any as S.Schema<BackupVolumeBackupsItem>;
+
+export type BackupVolumeBackupsList = Array<BackupVolumeBackupsItem>;
+export const BackupVolumeBackupsList = /*@__PURE__*/ S.Array(
+  BackupVolumeBackupsItem,
+) as any as S.Schema<BackupVolumeBackupsList>;
+
+export interface Backup {
+  createdAt: string;
+  expireAt: string;
+  id: string;
+  lastRestoredAt?: string;
+  name: string;
+  size?: number;
+  status: BackupStatus;
+  volumeBackups?: BackupVolumeBackupsList;
+}
+export const Backup = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    createdAt: S.String,
+    expireAt: S.String,
+    id: S.String,
+    lastRestoredAt: S.optional(S.String),
+    name: S.String,
+    size: S.optional(S.Number),
+    status: BackupStatus,
+    volumeBackups: S.optional(BackupVolumeBackupsList),
+  }),
+).annotate({ identifier: "Backup" }) as any as S.Schema<Backup>;
+
+export interface GetBackupScheduleRequest {
+  /** project id */
+  projectId: string;
+  /** region */
+  region: string;
+  /** server id */
+  serverId: string;
+  /** backup schedule id */
+  backupScheduleId: string;
+}
+export const GetBackupScheduleRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    projectId: S.String.pipe(T.Label()),
+    region: S.String.pipe(T.Label()),
+    serverId: S.String.pipe(T.Label()),
+    backupScheduleId: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/v2/projects/{projectId}/regions/{region}/servers/{serverId}/backup-schedules/{backupScheduleId}",
+      code: 200,
+      baseUrl: "https://server-backup.api.stackit.cloud",
+    }),
+  ),
+).annotate({ identifier: "GetBackupScheduleRequest" }) as any as S.Schema<GetBackupScheduleRequest>;
+
+export interface GetServiceResourceRequest {
+  /** project id */
+  projectId: string;
+  /** region */
+  region: string;
+  /** server id */
+  serverId: string;
+}
+export const GetServiceResourceRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    projectId: S.String.pipe(T.Label()),
+    region: S.String.pipe(T.Label()),
+    serverId: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/v2/projects/{projectId}/regions/{region}/servers/{serverId}/service",
+      code: 200,
+      baseUrl: "https://server-backup.api.stackit.cloud",
+    }),
+  ),
+).annotate({
+  identifier: "GetServiceResourceRequest",
+}) as any as S.Schema<GetServiceResourceRequest>;
+
+export interface GetBackupServiceResponse {
+  enabled?: boolean;
+}
+export const GetBackupServiceResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    enabled: S.optional(S.Boolean),
+  }),
+).annotate({ identifier: "GetBackupServiceResponse" }) as any as S.Schema<GetBackupServiceResponse>;
+
+export interface ListBackupPoliciesRequest {
+  /** project id */
+  projectId: string;
+}
+export const ListBackupPoliciesRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    projectId: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/v2/projects/{projectId}/backup-policies",
+      code: 200,
+      baseUrl: "https://server-backup.api.stackit.cloud",
+    }),
+  ),
+).annotate({
+  identifier: "ListBackupPoliciesRequest",
+}) as any as S.Schema<ListBackupPoliciesRequest>;
+
+export interface BackupPolicyBackupProperties {
+  name?: string;
+  retentionPeriod?: number;
+}
+export const BackupPolicyBackupProperties = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    name: S.optional(S.String),
+    retentionPeriod: S.optional(S.Number),
+  }),
+).annotate({
+  identifier: "BackupPolicyBackupProperties",
+}) as any as S.Schema<BackupPolicyBackupProperties>;
+
+export interface BackupPolicy {
+  backupProperties?: BackupPolicyBackupProperties;
+  default?: boolean;
+  description?: string;
+  enabled?: boolean;
+  id?: string;
+  name?: string;
+  /** An rrule (Recurrence Rule) is a standardized string format used in iCalendar (RFC 5545) to define repeating events, and you can generate one by using a dedicated library or by using online generator tools to specify parameters like frequency, interval, and end dates */
+  rrule?: string;
+}
+export const BackupPolicy = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    backupProperties: S.optional(BackupPolicyBackupProperties),
+    default: S.optional(S.Boolean),
+    description: S.optional(S.String),
+    enabled: S.optional(S.Boolean),
+    id: S.optional(S.String),
+    name: S.optional(S.String),
+    rrule: S.optional(S.String),
+  }),
+).annotate({ identifier: "BackupPolicy" }) as any as S.Schema<BackupPolicy>;
+
+export type GetBackupPoliciesResponseItemsList = Array<BackupPolicy>;
+export const GetBackupPoliciesResponseItemsList = /*@__PURE__*/ S.Array(
+  BackupPolicy,
+) as any as S.Schema<GetBackupPoliciesResponseItemsList>;
+
+export interface GetBackupPoliciesResponse {
+  items?: GetBackupPoliciesResponseItemsList;
+}
+export const GetBackupPoliciesResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    items: S.optional(GetBackupPoliciesResponseItemsList),
+  }),
+).annotate({
+  identifier: "GetBackupPoliciesResponse",
+}) as any as S.Schema<GetBackupPoliciesResponse>;
+
+export interface ListBackupsRequest {
+  /** project id */
+  projectId: string;
+  /** region */
+  region: string;
+  /** server id */
+  serverId: string;
+}
+export const ListBackupsRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    projectId: S.String.pipe(T.Label()),
+    region: S.String.pipe(T.Label()),
+    serverId: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/v2/projects/{projectId}/regions/{region}/servers/{serverId}/backups",
+      code: 200,
+      baseUrl: "https://server-backup.api.stackit.cloud",
+    }),
+  ),
+).annotate({ identifier: "ListBackupsRequest" }) as any as S.Schema<ListBackupsRequest>;
+
+export type GetBackupsListResponseItemsList = Array<Backup>;
+export const GetBackupsListResponseItemsList = /*@__PURE__*/ S.Array(
+  Backup,
+) as any as S.Schema<GetBackupsListResponseItemsList>;
+
+export interface GetBackupsListResponse {
+  items?: GetBackupsListResponseItemsList;
+}
+export const GetBackupsListResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    items: S.optional(GetBackupsListResponseItemsList),
+  }),
+).annotate({ identifier: "GetBackupsListResponse" }) as any as S.Schema<GetBackupsListResponse>;
+
+export interface ListBackupSchedulesRequest {
+  /** project id */
+  projectId: string;
+  /** region */
+  region: string;
+  /** server id */
+  serverId: string;
+}
+export const ListBackupSchedulesRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    projectId: S.String.pipe(T.Label()),
+    region: S.String.pipe(T.Label()),
+    serverId: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/v2/projects/{projectId}/regions/{region}/servers/{serverId}/backup-schedules",
+      code: 200,
+      baseUrl: "https://server-backup.api.stackit.cloud",
+    }),
+  ),
+).annotate({
+  identifier: "ListBackupSchedulesRequest",
+}) as any as S.Schema<ListBackupSchedulesRequest>;
+
+export type GetBackupSchedulesResponseItemsList = Array<BackupSchedule>;
+export const GetBackupSchedulesResponseItemsList = /*@__PURE__*/ S.Array(
+  BackupSchedule,
+) as any as S.Schema<GetBackupSchedulesResponseItemsList>;
+
+export interface GetBackupSchedulesResponse {
+  items?: GetBackupSchedulesResponseItemsList;
+}
+export const GetBackupSchedulesResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    items: S.optional(GetBackupSchedulesResponseItemsList),
+  }),
+).annotate({
+  identifier: "GetBackupSchedulesResponse",
+}) as any as S.Schema<GetBackupSchedulesResponse>;
+
+export type RestoreBackupRequestVolumeIdsList = Array<string>;
+export const RestoreBackupRequestVolumeIdsList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<RestoreBackupRequestVolumeIdsList>;
+
+export interface RestoreBackupRequest {
+  /** project id */
+  projectId: string;
+  /** region */
+  region: string;
+  /** server id */
+  serverId: string;
+  /** id of the backup */
+  backupId: string;
+  startServerAfterRestore: boolean;
+  volumeIds?: RestoreBackupRequestVolumeIdsList;
+}
+export const RestoreBackupRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    projectId: S.String.pipe(T.Label()),
+    region: S.String.pipe(T.Label()),
+    serverId: S.String.pipe(T.Label()),
+    backupId: S.String.pipe(T.Label()),
+    startServerAfterRestore: S.Boolean,
+    volumeIds: S.optional(RestoreBackupRequestVolumeIdsList),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/v2/projects/{projectId}/regions/{region}/servers/{serverId}/backups/{backupId}/restore",
+      code: 200,
+      baseUrl: "https://server-backup.api.stackit.cloud",
+    }),
+  ),
+).annotate({ identifier: "RestoreBackupRequest" }) as any as S.Schema<RestoreBackupRequest>;
+
+export interface RestoreBackupResponse {}
+export const RestoreBackupResponse = /*@__PURE__*/ S.suspend(() => S.Struct({})).annotate({
+  identifier: "RestoreBackupResponse",
+}) as any as S.Schema<RestoreBackupResponse>;
+
+export interface RestoreVolumeBackupRequest {
+  /** project id */
+  projectId: string;
+  /** region */
+  region: string;
+  /** server id */
+  serverId: string;
+  /** id of the backup */
+  backupId: string;
+  /** id of the volume backup */
+  volumeBackupId: string;
+  restoreVolumeId: string;
+}
+export const RestoreVolumeBackupRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    projectId: S.String.pipe(T.Label()),
+    region: S.String.pipe(T.Label()),
+    serverId: S.String.pipe(T.Label()),
+    backupId: S.String.pipe(T.Label()),
+    volumeBackupId: S.String.pipe(T.Label()),
+    restoreVolumeId: S.String,
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/v2/projects/{projectId}/regions/{region}/servers/{serverId}/backups/{backupId}/volume-backups/{volumeBackupId}/restore",
+      code: 200,
+      baseUrl: "https://server-backup.api.stackit.cloud",
+    }),
+  ),
+).annotate({
+  identifier: "RestoreVolumeBackupRequest",
+}) as any as S.Schema<RestoreVolumeBackupRequest>;
+
+export interface RestoreVolumeBackupResponse {}
+export const RestoreVolumeBackupResponse = /*@__PURE__*/ S.suspend(() => S.Struct({})).annotate({
+  identifier: "RestoreVolumeBackupResponse",
+}) as any as S.Schema<RestoreVolumeBackupResponse>;
+
+export interface UpdateBackupScheduleRequest {
+  /** project id */
+  projectId: string;
+  /** region */
+  region: string;
+  /** server id */
+  serverId: string;
+  /** backup schedule id */
+  backupScheduleId: string;
+  backupProperties?: BackupProperties;
+  enabled: boolean;
+  /** Max 255 characters */
+  name: string;
+  /** An rrule (Recurrence Rule) is a standardized string format used in iCalendar (RFC 5545) to define repeating events, and you can generate one by using a dedicated library or by using online generator tools to specify parameters like frequency, interval, and end dates */
+  rrule: string;
+}
+export const UpdateBackupScheduleRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    projectId: S.String.pipe(T.Label()),
+    region: S.String.pipe(T.Label()),
+    serverId: S.String.pipe(T.Label()),
+    backupScheduleId: S.String.pipe(T.Label()),
+    backupProperties: S.optional(BackupProperties),
+    enabled: S.Boolean,
+    name: S.String,
+    rrule: S.String,
+  }).pipe(
+    T.Http({
+      method: "PUT",
+      uri: "/v2/projects/{projectId}/regions/{region}/servers/{serverId}/backup-schedules/{backupScheduleId}",
+      code: 200,
+      baseUrl: "https://server-backup.api.stackit.cloud",
+    }),
+  ),
+).annotate({
+  identifier: "UpdateBackupScheduleRequest",
+}) as any as S.Schema<UpdateBackupScheduleRequest>;
+
+export type CreateBackupError = BadRequest | NotFound | Conflict | StackitOpError;
+/** create backup */
+export const createBackup: API.OperationMethod<
+  CreateBackupRequest,
+  BackupJob,
+  CreateBackupError,
+  StackitOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateBackupRequest,
+  output: BackupJob,
+  errors: [BadRequest, NotFound, Conflict, UnknownStackitError],
+  protocol: StackitProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateBackupScheduleError = BadRequest | NotFound | StackitOpError;
+/** create backup schedule */
+export const createBackupSchedule: API.OperationMethod<
+  CreateBackupScheduleRequest,
+  BackupSchedule,
+  CreateBackupScheduleError,
+  StackitOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateBackupScheduleRequest,
+  output: BackupSchedule,
+  errors: [BadRequest, NotFound, UnknownStackitError],
+  protocol: StackitProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteBackupError = BadRequest | NotFound | StackitOpError;
+/** delete backup */
+export const deleteBackup: API.OperationMethod<
+  DeleteBackupRequest,
+  DeleteBackupResponse,
+  DeleteBackupError,
+  StackitOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteBackupRequest,
+  output: DeleteBackupResponse,
+  errors: [BadRequest, NotFound, UnknownStackitError],
+  protocol: StackitProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteBackupScheduleError = BadRequest | NotFound | StackitOpError;
+/** delete backup schedule */
+export const deleteBackupSchedule: API.OperationMethod<
+  DeleteBackupScheduleRequest,
+  DeleteBackupScheduleResponse,
+  DeleteBackupScheduleError,
+  StackitOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteBackupScheduleRequest,
+  output: DeleteBackupScheduleResponse,
+  errors: [BadRequest, NotFound, UnknownStackitError],
+  protocol: StackitProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteVolumeBackupError = BadRequest | NotFound | StackitOpError;
+/** delete volume backup */
+export const deleteVolumeBackup: API.OperationMethod<
+  DeleteVolumeBackupRequest,
+  DeleteVolumeBackupResponse,
+  DeleteVolumeBackupError,
+  StackitOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteVolumeBackupRequest,
+  output: DeleteVolumeBackupResponse,
+  errors: [BadRequest, NotFound, UnknownStackitError],
+  protocol: StackitProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DisableServiceResourceError = BadRequest | NotFound | StackitOpError;
+/** disable backup service */
+export const disableServiceResource: API.OperationMethod<
+  DisableServiceResourceRequest,
+  DisableServiceResourceResponse,
+  DisableServiceResourceError,
+  StackitOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DisableServiceResourceRequest,
+  output: DisableServiceResourceResponse,
+  errors: [BadRequest, NotFound, UnknownStackitError],
+  protocol: StackitProtocol,
+  retry: Retry.Retry,
+}));
+
+export type EnableServiceResourceError = BadRequest | NotFound | StackitOpError;
+/** enable backup service */
+export const enableServiceResource: API.OperationMethod<
+  EnableServiceResourceRequest,
+  EnableServiceResourceResponse,
+  EnableServiceResourceError,
+  StackitOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: EnableServiceResourceRequest,
+  output: EnableServiceResourceResponse,
+  errors: [BadRequest, NotFound, UnknownStackitError],
+  protocol: StackitProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetBackupError = BadRequest | NotFound | StackitOpError;
+/** get backup */
+export const getBackup: API.OperationMethod<
+  GetBackupRequest,
+  Backup,
+  GetBackupError,
+  StackitOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetBackupRequest,
+  output: Backup,
+  errors: [BadRequest, NotFound, UnknownStackitError],
+  protocol: StackitProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetBackupScheduleError = BadRequest | NotFound | StackitOpError;
+/** get single backup schedule details */
+export const getBackupSchedule: API.OperationMethod<
+  GetBackupScheduleRequest,
+  BackupSchedule,
+  GetBackupScheduleError,
+  StackitOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetBackupScheduleRequest,
+  output: BackupSchedule,
+  errors: [BadRequest, NotFound, UnknownStackitError],
+  protocol: StackitProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetServiceResourceError = BadRequest | NotFound | StackitOpError;
+/** get backup service details */
+export const getServiceResource: API.OperationMethod<
+  GetServiceResourceRequest,
+  GetBackupServiceResponse,
+  GetServiceResourceError,
+  StackitOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetServiceResourceRequest,
+  output: GetBackupServiceResponse,
+  errors: [BadRequest, NotFound, UnknownStackitError],
+  protocol: StackitProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListBackupPoliciesError = BadRequest | NotFound | StackitOpError;
+/** get list of backup policies */
+export const listBackupPolicies: API.OperationMethod<
+  ListBackupPoliciesRequest,
+  GetBackupPoliciesResponse,
+  ListBackupPoliciesError,
+  StackitOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListBackupPoliciesRequest,
+  output: GetBackupPoliciesResponse,
+  errors: [BadRequest, NotFound, UnknownStackitError],
+  protocol: StackitProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListBackupsError = BadRequest | NotFound | StackitOpError;
+/** get list of backups */
+export const listBackups: API.OperationMethod<
+  ListBackupsRequest,
+  GetBackupsListResponse,
+  ListBackupsError,
+  StackitOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListBackupsRequest,
+  output: GetBackupsListResponse,
+  errors: [BadRequest, NotFound, UnknownStackitError],
+  protocol: StackitProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListBackupSchedulesError = BadRequest | NotFound | StackitOpError;
+/** get list of backup schedules */
+export const listBackupSchedules: API.OperationMethod<
+  ListBackupSchedulesRequest,
+  GetBackupSchedulesResponse,
+  ListBackupSchedulesError,
+  StackitOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListBackupSchedulesRequest,
+  output: GetBackupSchedulesResponse,
+  errors: [BadRequest, NotFound, UnknownStackitError],
+  protocol: StackitProtocol,
+  retry: Retry.Retry,
+}));
+
+export type RestoreBackupError = BadRequest | NotFound | Conflict | StackitOpError;
+/** trigger restore of the requested backup */
+export const restoreBackup: API.OperationMethod<
+  RestoreBackupRequest,
+  RestoreBackupResponse,
+  RestoreBackupError,
+  StackitOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: RestoreBackupRequest,
+  output: RestoreBackupResponse,
+  errors: [BadRequest, NotFound, Conflict, UnknownStackitError],
+  protocol: StackitProtocol,
+  retry: Retry.Retry,
+}));
+
+export type RestoreVolumeBackupError = BadRequest | NotFound | StackitOpError;
+/** trigger restore of the requested volume backup */
+export const restoreVolumeBackup: API.OperationMethod<
+  RestoreVolumeBackupRequest,
+  RestoreVolumeBackupResponse,
+  RestoreVolumeBackupError,
+  StackitOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: RestoreVolumeBackupRequest,
+  output: RestoreVolumeBackupResponse,
+  errors: [BadRequest, NotFound, UnknownStackitError],
+  protocol: StackitProtocol,
+  retry: Retry.Retry,
+}));
+
+export type UpdateBackupScheduleError = BadRequest | NotFound | StackitOpError;
+/** update backup schedule */
+export const updateBackupSchedule: API.OperationMethod<
+  UpdateBackupScheduleRequest,
+  BackupSchedule,
+  UpdateBackupScheduleError,
+  StackitOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: UpdateBackupScheduleRequest,
+  output: BackupSchedule,
+  errors: [BadRequest, NotFound, UnknownStackitError],
+  protocol: StackitProtocol,
+  retry: Retry.Retry,
+}));