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

package/src/services/server_update.ts

@@ -0,0 +1,767 @@
+// 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 * as API from "@distilled.cloud/core/api";
+import * as C from "@distilled.cloud/core/category";
+import * as T from "../traits.ts";
+import {
+  StackitProtocol,
+  type StackitOpError,
+  type StackitOpContext,
+} from "../protocol.ts";
+import { UnknownStackitError } from "../errors.ts";
+import * as Retry from "../retry.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 interface CreateUpdateRequest {
+  /** project id */
+  projectId: string;
+  /** region */
+  region: string;
+  /** server id */
+  serverId: string;
+  backupBeforeUpdate?: boolean;
+  /** Updates start within the defined hourly window. Depending on the updates, the process may exceed this timeframe and require an automatic restart. */
+  maintenanceWindow: number;
+}
+export const CreateUpdateRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    projectId: S.String.pipe(T.Label()),
+    region: S.String.pipe(T.Label()),
+    serverId: S.String.pipe(T.Label()),
+    backupBeforeUpdate: S.optional(S.Boolean),
+    maintenanceWindow: S.Number,
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/v2/projects/{projectId}/regions/{region}/servers/{serverId}/updates",
+      code: 200,
+      baseUrl: "https://server-update.api.stackit.cloud",
+    }),
+  ),
+).annotate({
+  identifier: "CreateUpdateRequest",
+}) as any as S.Schema<CreateUpdateRequest>;
+
+export interface Update {
+  endDate?: string;
+  failReason?: string;
+  failedUpdates?: number;
+  id: number;
+  installedUpdates?: number;
+  startDate: string;
+  status: string;
+}
+export const Update = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    endDate: S.optional(S.String),
+    failReason: S.optional(S.String),
+    failedUpdates: S.optional(S.Number),
+    id: S.Number,
+    installedUpdates: S.optional(S.Number),
+    startDate: S.String,
+    status: S.String,
+  }),
+).annotate({ identifier: "Update" }) as any as S.Schema<Update>;
+
+export interface CreateUpdateScheduleRequest {
+  /** project id */
+  projectId: string;
+  /** region */
+  region: string;
+  /** server id */
+  serverId: string;
+  enabled: boolean;
+  /** Updates start within the defined hourly window. Depending on the updates, the process may exceed this timeframe and require an automatic restart. */
+  maintenanceWindow: 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 CreateUpdateScheduleRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    projectId: S.String.pipe(T.Label()),
+    region: S.String.pipe(T.Label()),
+    serverId: S.String.pipe(T.Label()),
+    enabled: S.Boolean,
+    maintenanceWindow: S.Number,
+    name: S.String,
+    rrule: S.String,
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/v2/projects/{projectId}/regions/{region}/servers/{serverId}/update-schedules",
+      code: 200,
+      baseUrl: "https://server-update.api.stackit.cloud",
+    }),
+  ),
+).annotate({
+  identifier: "CreateUpdateScheduleRequest",
+}) as any as S.Schema<CreateUpdateScheduleRequest>;
+
+export interface CreateUpdateScheduleResponse {
+  enabled: boolean;
+  /** Updates start within the defined hourly window. Depending on the updates, the process may exceed this timeframe and require an automatic restart. */
+  maintenanceWindow: 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;
+  id: number;
+}
+export const CreateUpdateScheduleResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    enabled: S.Boolean,
+    maintenanceWindow: S.Number,
+    name: S.String,
+    rrule: S.String,
+    id: S.Number,
+  }),
+).annotate({
+  identifier: "CreateUpdateScheduleResponse",
+}) as any as S.Schema<CreateUpdateScheduleResponse>;
+
+export interface DeleteUpdateScheduleRequest {
+  /** project id */
+  projectId: string;
+  /** region */
+  region: string;
+  /** server id */
+  serverId: string;
+  /** update schedule id */
+  scheduleId: string;
+}
+export const DeleteUpdateScheduleRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    projectId: S.String.pipe(T.Label()),
+    region: S.String.pipe(T.Label()),
+    serverId: S.String.pipe(T.Label()),
+    scheduleId: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "DELETE",
+      uri: "/v2/projects/{projectId}/regions/{region}/servers/{serverId}/update-schedules/{scheduleId}",
+      code: 200,
+      baseUrl: "https://server-update.api.stackit.cloud",
+    }),
+  ),
+).annotate({
+  identifier: "DeleteUpdateScheduleRequest",
+}) as any as S.Schema<DeleteUpdateScheduleRequest>;
+
+export interface DeleteUpdateScheduleResponse {}
+export const DeleteUpdateScheduleResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "DeleteUpdateScheduleResponse",
+}) as any as S.Schema<DeleteUpdateScheduleResponse>;
+
+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-update.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;
+  updatePolicyId?: 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()),
+    updatePolicyId: S.optional(S.String),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/v2/projects/{projectId}/regions/{region}/servers/{serverId}/service",
+      code: 200,
+      baseUrl: "https://server-update.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 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-update.api.stackit.cloud",
+    }),
+  ),
+).annotate({
+  identifier: "GetServiceResourceRequest",
+}) as any as S.Schema<GetServiceResourceRequest>;
+
+export interface GetUpdateServiceResponse {
+  enabled?: boolean;
+}
+export const GetUpdateServiceResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    enabled: S.optional(S.Boolean),
+  }),
+).annotate({
+  identifier: "GetUpdateServiceResponse",
+}) as any as S.Schema<GetUpdateServiceResponse>;
+
+export interface GetUpdateRequest {
+  /** project id */
+  projectId: string;
+  /** region */
+  region: string;
+  /** server id */
+  serverId: string;
+  /** id of the update */
+  updateId: string;
+}
+export const GetUpdateRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    projectId: S.String.pipe(T.Label()),
+    region: S.String.pipe(T.Label()),
+    serverId: S.String.pipe(T.Label()),
+    updateId: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/v2/projects/{projectId}/regions/{region}/servers/{serverId}/updates/{updateId}",
+      code: 200,
+      baseUrl: "https://server-update.api.stackit.cloud",
+    }),
+  ),
+).annotate({
+  identifier: "GetUpdateRequest",
+}) as any as S.Schema<GetUpdateRequest>;
+
+export interface GetUpdateScheduleRequest {
+  /** project id */
+  projectId: string;
+  /** region */
+  region: string;
+  /** server id */
+  serverId: string;
+  /** update schedule id */
+  scheduleId: string;
+}
+export const GetUpdateScheduleRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    projectId: S.String.pipe(T.Label()),
+    region: S.String.pipe(T.Label()),
+    serverId: S.String.pipe(T.Label()),
+    scheduleId: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/v2/projects/{projectId}/regions/{region}/servers/{serverId}/update-schedules/{scheduleId}",
+      code: 200,
+      baseUrl: "https://server-update.api.stackit.cloud",
+    }),
+  ),
+).annotate({
+  identifier: "GetUpdateScheduleRequest",
+}) as any as S.Schema<GetUpdateScheduleRequest>;
+
+export interface GetUpdateScheduleResponse {
+  enabled: boolean;
+  /** Updates start within the defined hourly window. Depending on the updates, the process may exceed this timeframe and require an automatic restart. */
+  maintenanceWindow: 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;
+  id: number;
+}
+export const GetUpdateScheduleResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    enabled: S.Boolean,
+    maintenanceWindow: S.Number,
+    name: S.String,
+    rrule: S.String,
+    id: S.Number,
+  }),
+).annotate({
+  identifier: "GetUpdateScheduleResponse",
+}) as any as S.Schema<GetUpdateScheduleResponse>;
+
+export interface ListUpdatePoliciesRequest {
+  /** project id */
+  projectId: string;
+}
+export const ListUpdatePoliciesRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    projectId: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/v2/projects/{projectId}/update-policies",
+      code: 200,
+      baseUrl: "https://server-update.api.stackit.cloud",
+    }),
+  ),
+).annotate({
+  identifier: "ListUpdatePoliciesRequest",
+}) as any as S.Schema<ListUpdatePoliciesRequest>;
+
+export interface UpdatePolicy {
+  default?: boolean;
+  description?: string;
+  enabled?: boolean;
+  id?: string;
+  /** Updates start within the defined hourly window. Depending on the updates, the process may exceed this timeframe and require an automatic restart. */
+  maintenanceWindow?: 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 UpdatePolicy = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    default: S.optional(S.Boolean),
+    description: S.optional(S.String),
+    enabled: S.optional(S.Boolean),
+    id: S.optional(S.String),
+    maintenanceWindow: S.optional(S.Number),
+    name: S.optional(S.String),
+    rrule: S.optional(S.String),
+  }),
+).annotate({ identifier: "UpdatePolicy" }) as any as S.Schema<UpdatePolicy>;
+
+export type GetUpdatePoliciesResponseItemsList = Array<UpdatePolicy>;
+export const GetUpdatePoliciesResponseItemsList = /*@__PURE__*/ S.Array(
+  UpdatePolicy,
+) as any as S.Schema<GetUpdatePoliciesResponseItemsList>;
+
+export interface GetUpdatePoliciesResponse {
+  items?: GetUpdatePoliciesResponseItemsList;
+}
+export const GetUpdatePoliciesResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    items: S.optional(GetUpdatePoliciesResponseItemsList),
+  }),
+).annotate({
+  identifier: "GetUpdatePoliciesResponse",
+}) as any as S.Schema<GetUpdatePoliciesResponse>;
+
+export interface ListUpdatesRequest {
+  /** project id */
+  projectId: string;
+  /** region */
+  region: string;
+  /** server id */
+  serverId: string;
+}
+export const ListUpdatesRequest = /*@__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}/updates",
+      code: 200,
+      baseUrl: "https://server-update.api.stackit.cloud",
+    }),
+  ),
+).annotate({
+  identifier: "ListUpdatesRequest",
+}) as any as S.Schema<ListUpdatesRequest>;
+
+export type GetUpdatesListResponseItemsList = Array<Update>;
+export const GetUpdatesListResponseItemsList = /*@__PURE__*/ S.Array(
+  Update,
+) as any as S.Schema<GetUpdatesListResponseItemsList>;
+
+export interface GetUpdatesListResponse {
+  items?: GetUpdatesListResponseItemsList;
+}
+export const GetUpdatesListResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    items: S.optional(GetUpdatesListResponseItemsList),
+  }),
+).annotate({
+  identifier: "GetUpdatesListResponse",
+}) as any as S.Schema<GetUpdatesListResponse>;
+
+export interface ListUpdateSchedulesRequest {
+  /** project id */
+  projectId: string;
+  /** region */
+  region: string;
+  /** server id */
+  serverId: string;
+}
+export const ListUpdateSchedulesRequest = /*@__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}/update-schedules",
+      code: 200,
+      baseUrl: "https://server-update.api.stackit.cloud",
+    }),
+  ),
+).annotate({
+  identifier: "ListUpdateSchedulesRequest",
+}) as any as S.Schema<ListUpdateSchedulesRequest>;
+
+export interface UpdateSchedule {
+  enabled: boolean;
+  /** Updates start within the defined hourly window. Depending on the updates, the process may exceed this timeframe and require an automatic restart. */
+  maintenanceWindow: 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;
+  id: number;
+}
+export const UpdateSchedule = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    enabled: S.Boolean,
+    maintenanceWindow: S.Number,
+    name: S.String,
+    rrule: S.String,
+    id: S.Number,
+  }),
+).annotate({ identifier: "UpdateSchedule" }) as any as S.Schema<UpdateSchedule>;
+
+export type GetUpdateSchedulesResponseItemsList = Array<UpdateSchedule>;
+export const GetUpdateSchedulesResponseItemsList = /*@__PURE__*/ S.Array(
+  UpdateSchedule,
+) as any as S.Schema<GetUpdateSchedulesResponseItemsList>;
+
+export interface GetUpdateSchedulesResponse {
+  items?: GetUpdateSchedulesResponseItemsList;
+}
+export const GetUpdateSchedulesResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    items: S.optional(GetUpdateSchedulesResponseItemsList),
+  }),
+).annotate({
+  identifier: "GetUpdateSchedulesResponse",
+}) as any as S.Schema<GetUpdateSchedulesResponse>;
+
+export interface UpdateUpdateScheduleRequest {
+  /** project id */
+  projectId: string;
+  /** region */
+  region: string;
+  /** server id */
+  serverId: string;
+  /** update schedule id */
+  scheduleId: string;
+  enabled: boolean;
+  /** Updates start within the defined hourly window. Depending on the updates, the process may exceed this timeframe and require an automatic restart. */
+  maintenanceWindow: 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 UpdateUpdateScheduleRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    projectId: S.String.pipe(T.Label()),
+    region: S.String.pipe(T.Label()),
+    serverId: S.String.pipe(T.Label()),
+    scheduleId: S.String.pipe(T.Label()),
+    enabled: S.Boolean,
+    maintenanceWindow: S.Number,
+    name: S.String,
+    rrule: S.String,
+  }).pipe(
+    T.Http({
+      method: "PUT",
+      uri: "/v2/projects/{projectId}/regions/{region}/servers/{serverId}/update-schedules/{scheduleId}",
+      code: 200,
+      baseUrl: "https://server-update.api.stackit.cloud",
+    }),
+  ),
+).annotate({
+  identifier: "UpdateUpdateScheduleRequest",
+}) as any as S.Schema<UpdateUpdateScheduleRequest>;
+
+export interface UpdateUpdateScheduleResponse {
+  enabled: boolean;
+  /** Updates start within the defined hourly window. Depending on the updates, the process may exceed this timeframe and require an automatic restart. */
+  maintenanceWindow: 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;
+  id: number;
+}
+export const UpdateUpdateScheduleResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    enabled: S.Boolean,
+    maintenanceWindow: S.Number,
+    name: S.String,
+    rrule: S.String,
+    id: S.Number,
+  }),
+).annotate({
+  identifier: "UpdateUpdateScheduleResponse",
+}) as any as S.Schema<UpdateUpdateScheduleResponse>;
+
+export type CreateUpdateError =
+  | BadRequest
+  | NotFound
+  | Conflict
+  | StackitOpError;
+/** create update */
+export const createUpdate: API.OperationMethod<
+  CreateUpdateRequest,
+  Update,
+  CreateUpdateError,
+  StackitOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateUpdateRequest,
+  output: Update,
+  errors: [BadRequest, NotFound, Conflict, UnknownStackitError],
+  protocol: StackitProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateUpdateScheduleError = BadRequest | NotFound | StackitOpError;
+/** create update schedule */
+export const createUpdateSchedule: API.OperationMethod<
+  CreateUpdateScheduleRequest,
+  CreateUpdateScheduleResponse,
+  CreateUpdateScheduleError,
+  StackitOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateUpdateScheduleRequest,
+  output: CreateUpdateScheduleResponse,
+  errors: [BadRequest, NotFound, UnknownStackitError],
+  protocol: StackitProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteUpdateScheduleError = BadRequest | NotFound | StackitOpError;
+/** delete update schedule */
+export const deleteUpdateSchedule: API.OperationMethod<
+  DeleteUpdateScheduleRequest,
+  DeleteUpdateScheduleResponse,
+  DeleteUpdateScheduleError,
+  StackitOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteUpdateScheduleRequest,
+  output: DeleteUpdateScheduleResponse,
+  errors: [BadRequest, NotFound, UnknownStackitError],
+  protocol: StackitProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DisableServiceResourceError =
+  | BadRequest
+  | NotFound
+  | StackitOpError;
+/** disable update 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 update 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 GetServiceResourceError = BadRequest | NotFound | StackitOpError;
+/** get update service details */
+export const getServiceResource: API.OperationMethod<
+  GetServiceResourceRequest,
+  GetUpdateServiceResponse,
+  GetServiceResourceError,
+  StackitOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetServiceResourceRequest,
+  output: GetUpdateServiceResponse,
+  errors: [BadRequest, NotFound, UnknownStackitError],
+  protocol: StackitProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetUpdateError = BadRequest | NotFound | StackitOpError;
+/** get update */
+export const getUpdate: API.OperationMethod<
+  GetUpdateRequest,
+  Update,
+  GetUpdateError,
+  StackitOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetUpdateRequest,
+  output: Update,
+  errors: [BadRequest, NotFound, UnknownStackitError],
+  protocol: StackitProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetUpdateScheduleError = BadRequest | NotFound | StackitOpError;
+/** get single update schedule details */
+export const getUpdateSchedule: API.OperationMethod<
+  GetUpdateScheduleRequest,
+  GetUpdateScheduleResponse,
+  GetUpdateScheduleError,
+  StackitOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetUpdateScheduleRequest,
+  output: GetUpdateScheduleResponse,
+  errors: [BadRequest, NotFound, UnknownStackitError],
+  protocol: StackitProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListUpdatePoliciesError = BadRequest | NotFound | StackitOpError;
+/** get list of update policies */
+export const listUpdatePolicies: API.OperationMethod<
+  ListUpdatePoliciesRequest,
+  GetUpdatePoliciesResponse,
+  ListUpdatePoliciesError,
+  StackitOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListUpdatePoliciesRequest,
+  output: GetUpdatePoliciesResponse,
+  errors: [BadRequest, NotFound, UnknownStackitError],
+  protocol: StackitProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListUpdatesError = BadRequest | NotFound | StackitOpError;
+/** get list of updates */
+export const listUpdates: API.OperationMethod<
+  ListUpdatesRequest,
+  GetUpdatesListResponse,
+  ListUpdatesError,
+  StackitOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListUpdatesRequest,
+  output: GetUpdatesListResponse,
+  errors: [BadRequest, NotFound, UnknownStackitError],
+  protocol: StackitProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListUpdateSchedulesError = BadRequest | NotFound | StackitOpError;
+/** get list of update schedules */
+export const listUpdateSchedules: API.OperationMethod<
+  ListUpdateSchedulesRequest,
+  GetUpdateSchedulesResponse,
+  ListUpdateSchedulesError,
+  StackitOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListUpdateSchedulesRequest,
+  output: GetUpdateSchedulesResponse,
+  errors: [BadRequest, NotFound, UnknownStackitError],
+  protocol: StackitProtocol,
+  retry: Retry.Retry,
+}));
+
+export type UpdateUpdateScheduleError = BadRequest | NotFound | StackitOpError;
+/** update update schedule */
+export const updateUpdateSchedule: API.OperationMethod<
+  UpdateUpdateScheduleRequest,
+  UpdateUpdateScheduleResponse,
+  UpdateUpdateScheduleError,
+  StackitOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: UpdateUpdateScheduleRequest,
+  output: UpdateUpdateScheduleResponse,
+  errors: [BadRequest, NotFound, UnknownStackitError],
+  protocol: StackitProtocol,
+  retry: Retry.Retry,
+}));