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

package/src/services/valkey.ts

@@ -0,0 +1,1266 @@
+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 * as Redacted from "effect/Redacted";
+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 interface CreateBackupRequest {
+  /** Project id on which user has permissions */
+  projectId: string;
+  /** region in which the project resides */
+  regionId: string;
+  /** Instance id */
+  instanceId: string;
+}
+export const CreateBackupRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    projectId: S.String.pipe(T.Label()),
+    regionId: S.String.pipe(T.Label()),
+    instanceId: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/v2/projects/{projectId}/regions/{regionId}/instances/{instanceId}/backups",
+      code: 200,
+      baseUrl: "https://valkey.api.stackit.cloud",
+    }),
+  ),
+).annotate({ identifier: "CreateBackupRequest" }) as any as S.Schema<CreateBackupRequest>;
+
+export interface CreateBackupResponseItem {
+  id: number;
+  message: string;
+}
+export const CreateBackupResponseItem = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    id: S.Number,
+    message: S.String,
+  }),
+).annotate({ identifier: "CreateBackupResponseItem" }) as any as S.Schema<CreateBackupResponseItem>;
+
+export interface CreateCredentialsRequest {
+  /** Project id on which user has permissions */
+  projectId: string;
+  /** region in which the project resides */
+  regionId: string;
+  /** Instance id */
+  instanceId: string;
+  parameters?: unknown;
+}
+export const CreateCredentialsRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    projectId: S.String.pipe(T.Label()),
+    regionId: S.String.pipe(T.Label()),
+    instanceId: S.String.pipe(T.Label()),
+    parameters: S.optional(S.Unknown),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/v2/projects/{projectId}/regions/{regionId}/instances/{instanceId}/credentials",
+      code: 200,
+      baseUrl: "https://valkey.api.stackit.cloud",
+    }),
+  ),
+).annotate({ identifier: "CreateCredentialsRequest" }) as any as S.Schema<CreateCredentialsRequest>;
+
+export type CredentialsHostsList = Array<string>;
+export const CredentialsHostsList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<CredentialsHostsList>;
+
+export interface Credentials {
+  host: string;
+  hosts?: CredentialsHostsList;
+  load_balanced_host?: string;
+  password: string | Redacted.Redacted<string>;
+  port?: number;
+  uri?: string;
+  username: string;
+}
+export const Credentials = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    host: S.String,
+    hosts: S.optional(CredentialsHostsList),
+    load_balanced_host: S.optional(S.String),
+    password: S.String.pipe(T.SensitiveValue({})),
+    port: S.optional(S.Number),
+    uri: S.optional(S.String),
+    username: S.String,
+  }),
+).annotate({ identifier: "Credentials" }) as any as S.Schema<Credentials>;
+
+export interface RawCredentials {
+  credentials: Credentials;
+}
+export const RawCredentials = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    credentials: Credentials,
+  }),
+).annotate({ identifier: "RawCredentials" }) as any as S.Schema<RawCredentials>;
+
+export interface CredentialsResponse {
+  id: string;
+  raw?: RawCredentials;
+  uri: string;
+}
+export const CredentialsResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    id: S.String,
+    raw: S.optional(RawCredentials),
+    uri: S.String,
+  }),
+).annotate({ identifier: "CredentialsResponse" }) as any as S.Schema<CredentialsResponse>;
+
+export type InstanceParametersLazyfreeLazyEviction = "yes" | "no";
+export const InstanceParametersLazyfreeLazyEviction = S.String;
+
+export type InstanceParametersLazyfreeLazyExpire = "yes" | "no";
+export const InstanceParametersLazyfreeLazyExpire = S.String;
+
+export type InstanceParametersMaxmemoryPolicy =
+  | "volatile-lru"
+  | "allkeys-lru"
+  | "volatile-random"
+  | "allkeys-random"
+  | "volatile-ttl"
+  | "noeviction";
+export const InstanceParametersMaxmemoryPolicy = S.String;
+
+export type InstanceParametersSyslogList = Array<string>;
+export const InstanceParametersSyslogList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<InstanceParametersSyslogList>;
+
+export interface InstanceParameters {
+  /** The unit is milliseconds. */
+  down_after_milliseconds?: number;
+  enable_monitoring?: boolean;
+  /** The unit is milliseconds. */
+  failover_timeout?: number;
+  /** If you want to monitor your service with Graphite, you can set the custom parameter graphite. It expects the host and port where the Graphite metrics should be sent to. */
+  graphite?: string;
+  lazyfree_lazy_eviction?: InstanceParametersLazyfreeLazyEviction | (string & {});
+  lazyfree_lazy_expire?: InstanceParametersLazyfreeLazyExpire | (string & {});
+  lua_time_limit?: number;
+  /** This component monitors ephemeral and persistent disk usage. If one of these disk usages reaches the default configured threshold of 80%, the a9s Parachute stops all processes on that node. */
+  max_disk_threshold?: number;
+  maxclients?: number;
+  maxmemory_policy?: InstanceParametersMaxmemoryPolicy | (string & {});
+  maxmemory_samples?: number;
+  /** Frequency of metrics being emitted in seconds */
+  metrics_frequency?: number;
+  /** Depending on your graphite provider, you might need to prefix the metrics with a certain value, like an API key for example. */
+  metrics_prefix?: string;
+  /** The amount of connected replicas that are required for the primary to accept write operations. It can be set to 0 to disable it. Should not be greater than the number of nodes (e.g. 1 or 3). */
+  min_replicas_to_write?: number;
+  /** The unit is seconds. */
+  min_replicas_max_lag?: number;
+  monitoring_instance_id?: string;
+  /** The allowed value must include the following characters only: [K,E,g,$,l,s,h,z,x,e,A,t] */
+  notify_keyspace_events?: string;
+  /** Set the replication backlog size for the cluster. */
+  repl_backlog_size?: string;
+  /** Comma separated list of IP networks in CIDR notation which are allowed to access this instance. */
+  sgw_acl?: string;
+  /** This setting must follow the original Redis configuration for RDB. */
+  snapshot?: string;
+  syslog?: InstanceParametersSyslogList;
+}
+export const InstanceParameters = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    down_after_milliseconds: S.optional(S.Number.pipe(T.Body("down-after-milliseconds"))),
+    enable_monitoring: S.optional(S.Boolean),
+    failover_timeout: S.optional(S.Number.pipe(T.Body("failover-timeout"))),
+    graphite: S.optional(S.String),
+    lazyfree_lazy_eviction: S.optional(
+      InstanceParametersLazyfreeLazyEviction.pipe(T.Body("lazyfree-lazy-eviction")),
+    ),
+    lazyfree_lazy_expire: S.optional(
+      InstanceParametersLazyfreeLazyExpire.pipe(T.Body("lazyfree-lazy-expire")),
+    ),
+    lua_time_limit: S.optional(S.Number.pipe(T.Body("lua-time-limit"))),
+    max_disk_threshold: S.optional(S.Number),
+    maxclients: S.optional(S.Number),
+    maxmemory_policy: S.optional(
+      InstanceParametersMaxmemoryPolicy.pipe(T.Body("maxmemory-policy")),
+    ),
+    maxmemory_samples: S.optional(S.Number.pipe(T.Body("maxmemory-samples"))),
+    metrics_frequency: S.optional(S.Number),
+    metrics_prefix: S.optional(S.String),
+    min_replicas_to_write: S.optional(S.Number.pipe(T.Body("min-replicas-to-write"))),
+    min_replicas_max_lag: S.optional(S.Number),
+    monitoring_instance_id: S.optional(S.String),
+    notify_keyspace_events: S.optional(S.String.pipe(T.Body("notify-keyspace-events"))),
+    repl_backlog_size: S.optional(S.String.pipe(T.Body("repl-backlog-size"))),
+    sgw_acl: S.optional(S.String),
+    snapshot: S.optional(S.String),
+    syslog: S.optional(InstanceParametersSyslogList),
+  }),
+).annotate({ identifier: "InstanceParameters" }) as any as S.Schema<InstanceParameters>;
+
+export interface CreateInstanceRequest {
+  /** Project id on which user has permissions */
+  projectId: string;
+  /** region in which the project resides */
+  regionId: string;
+  instanceName: string;
+  parameters?: InstanceParameters;
+  planId: string;
+}
+export const CreateInstanceRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    projectId: S.String.pipe(T.Label()),
+    regionId: S.String.pipe(T.Label()),
+    instanceName: S.String,
+    parameters: S.optional(InstanceParameters),
+    planId: S.String,
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/v2/projects/{projectId}/regions/{regionId}/instances",
+      code: 200,
+      baseUrl: "https://valkey.api.stackit.cloud",
+    }),
+  ),
+).annotate({ identifier: "CreateInstanceRequest" }) as any as S.Schema<CreateInstanceRequest>;
+
+export interface CreateInstanceResponse {
+  instanceId: string;
+}
+export const CreateInstanceResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    instanceId: S.String,
+  }),
+).annotate({ identifier: "CreateInstanceResponse" }) as any as S.Schema<CreateInstanceResponse>;
+
+export interface DeleteCredentialsRequest {
+  /** Project id on which user has permissions */
+  projectId: string;
+  /** region in which the project resides */
+  regionId: string;
+  /** Instance id */
+  instanceId: string;
+  /** Id of the credentials being deleted */
+  credentialsId: string;
+}
+export const DeleteCredentialsRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    projectId: S.String.pipe(T.Label()),
+    regionId: S.String.pipe(T.Label()),
+    instanceId: S.String.pipe(T.Label()),
+    credentialsId: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "DELETE",
+      uri: "/v2/projects/{projectId}/regions/{regionId}/instances/{instanceId}/credentials/{credentialsId}",
+      code: 200,
+      baseUrl: "https://valkey.api.stackit.cloud",
+    }),
+  ),
+).annotate({ identifier: "DeleteCredentialsRequest" }) as any as S.Schema<DeleteCredentialsRequest>;
+
+export interface DeleteCredentialsResponse {}
+export const DeleteCredentialsResponse = /*@__PURE__*/ S.suspend(() => S.Struct({})).annotate({
+  identifier: "DeleteCredentialsResponse",
+}) as any as S.Schema<DeleteCredentialsResponse>;
+
+export interface DeleteInstanceRequest {
+  /** Project id on which user has permissions */
+  projectId: string;
+  /** region in which the project resides */
+  regionId: string;
+  /** Instance id */
+  instanceId: string;
+}
+export const DeleteInstanceRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    projectId: S.String.pipe(T.Label()),
+    regionId: S.String.pipe(T.Label()),
+    instanceId: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "DELETE",
+      uri: "/v2/projects/{projectId}/regions/{regionId}/instances/{instanceId}",
+      code: 200,
+      baseUrl: "https://valkey.api.stackit.cloud",
+    }),
+  ),
+).annotate({ identifier: "DeleteInstanceRequest" }) as any as S.Schema<DeleteInstanceRequest>;
+
+export interface DeleteInstanceResponse {}
+export const DeleteInstanceResponse = /*@__PURE__*/ S.suspend(() => S.Struct({})).annotate({
+  identifier: "DeleteInstanceResponse",
+}) as any as S.Schema<DeleteInstanceResponse>;
+
+export interface DownloadBackupRequest {
+  /** Project id on which user has permissions */
+  projectId: string;
+  /** region in which the project resides */
+  regionId: string;
+  /** Instance id */
+  instanceId: string;
+  /** Backup id */
+  backupId: number;
+}
+export const DownloadBackupRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    projectId: S.String.pipe(T.Label()),
+    regionId: S.String.pipe(T.Label()),
+    instanceId: S.String.pipe(T.Label()),
+    backupId: S.Number.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/v2/projects/{projectId}/regions/{regionId}/instances/{instanceId}/backups/{backupId}/download",
+      code: 200,
+      baseUrl: "https://valkey.api.stackit.cloud",
+    }),
+  ),
+).annotate({ identifier: "DownloadBackupRequest" }) as any as S.Schema<DownloadBackupRequest>;
+
+export interface DownloadBackupResponse {}
+export const DownloadBackupResponse = /*@__PURE__*/ S.suspend(() => S.Struct({})).annotate({
+  identifier: "DownloadBackupResponse",
+}) as any as S.Schema<DownloadBackupResponse>;
+
+export interface GetCredentialsRequest {
+  /** Project id on which user has permissions */
+  projectId: string;
+  /** region in which the project resides */
+  regionId: string;
+  /** Instance id */
+  instanceId: string;
+  /** Credentials id of credentials to fetch */
+  credentialsId: string;
+}
+export const GetCredentialsRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    projectId: S.String.pipe(T.Label()),
+    regionId: S.String.pipe(T.Label()),
+    instanceId: S.String.pipe(T.Label()),
+    credentialsId: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/v2/projects/{projectId}/regions/{regionId}/instances/{instanceId}/credentials/{credentialsId}",
+      code: 200,
+      baseUrl: "https://valkey.api.stackit.cloud",
+    }),
+  ),
+).annotate({ identifier: "GetCredentialsRequest" }) as any as S.Schema<GetCredentialsRequest>;
+
+export interface GetInstanceRequest {
+  /** Project id on which user has permissions */
+  projectId: string;
+  /** region in which the project resides */
+  regionId: string;
+  /** Instance id */
+  instanceId: string;
+}
+export const GetInstanceRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    projectId: S.String.pipe(T.Label()),
+    regionId: S.String.pipe(T.Label()),
+    instanceId: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/v2/projects/{projectId}/regions/{regionId}/instances/{instanceId}",
+      code: 200,
+      baseUrl: "https://valkey.api.stackit.cloud",
+    }),
+  ),
+).annotate({ identifier: "GetInstanceRequest" }) as any as S.Schema<GetInstanceRequest>;
+
+export type InstanceLastOperationState = "in progress" | "succeeded" | "failed";
+export const InstanceLastOperationState = S.String;
+
+export type InstanceLastOperationType = "create" | "update" | "delete";
+export const InstanceLastOperationType = S.String;
+
+export interface InstanceLastOperation {
+  description: string;
+  state: InstanceLastOperationState;
+  type: InstanceLastOperationType;
+}
+export const InstanceLastOperation = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    description: S.String,
+    state: InstanceLastOperationState,
+    type: InstanceLastOperationType,
+  }),
+).annotate({ identifier: "InstanceLastOperation" }) as any as S.Schema<InstanceLastOperation>;
+
+export type InstanceStatus = "active" | "failed" | "stopped" | "creating" | "deleting" | "updating";
+export const InstanceStatus = S.String;
+
+export interface Instance {
+  cfGuid: string;
+  cfOrganizationGuid: string;
+  cfSpaceGuid: string;
+  dashboardUrl: string;
+  imageUrl: string;
+  instanceId?: string;
+  lastOperation: InstanceLastOperation;
+  name: string;
+  offeringName: string;
+  offeringVersion: string;
+  parameters: unknown;
+  planId: string;
+  planName: string;
+  status?: InstanceStatus;
+}
+export const Instance = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    cfGuid: S.String,
+    cfOrganizationGuid: S.String,
+    cfSpaceGuid: S.String,
+    dashboardUrl: S.String,
+    imageUrl: S.String,
+    instanceId: S.optional(S.String),
+    lastOperation: InstanceLastOperation,
+    name: S.String,
+    offeringName: S.String,
+    offeringVersion: S.String,
+    parameters: S.Unknown,
+    planId: S.String,
+    planName: S.String,
+    status: S.optional(InstanceStatus),
+  }),
+).annotate({ identifier: "Instance" }) as any as S.Schema<Instance>;
+
+export interface GetMetricsRequest {
+  /** Project id on which user has permissions */
+  projectId: string;
+  /** region in which the project resides */
+  regionId: string;
+  /** Instance id */
+  instanceId: string;
+}
+export const GetMetricsRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    projectId: S.String.pipe(T.Label()),
+    regionId: S.String.pipe(T.Label()),
+    instanceId: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/v2/projects/{projectId}/regions/{regionId}/instances/{instanceId}/metrics",
+      code: 200,
+      baseUrl: "https://valkey.api.stackit.cloud",
+    }),
+  ),
+).annotate({ identifier: "GetMetricsRequest" }) as any as S.Schema<GetMetricsRequest>;
+
+export interface GetMetricsResponse {
+  cpuIdleTime?: number;
+  cpuLoadPercent: number;
+  cpuSystemTime?: number;
+  cpuUserTime?: number;
+  diskEphemeralTotal: number;
+  diskEphemeralUsed: number;
+  diskPersistentTotal: number;
+  diskPersistentUsed: number;
+  load1: number;
+  load15: number;
+  load5: number;
+  memoryTotal: number;
+  memoryUsed: number;
+  parachuteDiskEphemeralActivated: boolean;
+  parachuteDiskEphemeralTotal: number;
+  parachuteDiskEphemeralUsed: number;
+  parachuteDiskEphemeralUsedPercent: number;
+  parachuteDiskEphemeralUsedThreshold: number;
+  parachuteDiskPersistentActivated: boolean;
+  parachuteDiskPersistentTotal: number;
+  parachuteDiskPersistentUsed: number;
+  parachuteDiskPersistentUsedPercent: number;
+  parachuteDiskPersistentUsedThreshold: number;
+}
+export const GetMetricsResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    cpuIdleTime: S.optional(S.Number),
+    cpuLoadPercent: S.Number,
+    cpuSystemTime: S.optional(S.Number),
+    cpuUserTime: S.optional(S.Number),
+    diskEphemeralTotal: S.Number,
+    diskEphemeralUsed: S.Number,
+    diskPersistentTotal: S.Number,
+    diskPersistentUsed: S.Number,
+    load1: S.Number,
+    load15: S.Number,
+    load5: S.Number,
+    memoryTotal: S.Number,
+    memoryUsed: S.Number,
+    parachuteDiskEphemeralActivated: S.Boolean,
+    parachuteDiskEphemeralTotal: S.Number,
+    parachuteDiskEphemeralUsed: S.Number,
+    parachuteDiskEphemeralUsedPercent: S.Number,
+    parachuteDiskEphemeralUsedThreshold: S.Number,
+    parachuteDiskPersistentActivated: S.Boolean,
+    parachuteDiskPersistentTotal: S.Number,
+    parachuteDiskPersistentUsed: S.Number,
+    parachuteDiskPersistentUsedPercent: S.Number,
+    parachuteDiskPersistentUsedThreshold: S.Number,
+  }),
+).annotate({ identifier: "GetMetricsResponse" }) as any as S.Schema<GetMetricsResponse>;
+
+export interface ListBackupsRequest {
+  /** Project id on which user has permissions */
+  projectId: string;
+  /** region in which the project resides */
+  regionId: string;
+  /** Instance id */
+  instanceId: string;
+}
+export const ListBackupsRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    projectId: S.String.pipe(T.Label()),
+    regionId: S.String.pipe(T.Label()),
+    instanceId: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/v2/projects/{projectId}/regions/{regionId}/instances/{instanceId}/backups",
+      code: 200,
+      baseUrl: "https://valkey.api.stackit.cloud",
+    }),
+  ),
+).annotate({ identifier: "ListBackupsRequest" }) as any as S.Schema<ListBackupsRequest>;
+
+export interface Backup {
+  downloadable?: boolean;
+  finished_at: string;
+  id: number;
+  size?: number;
+  status: string;
+  triggered_at?: string;
+}
+export const Backup = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    downloadable: S.optional(S.Boolean),
+    finished_at: S.String,
+    id: S.Number,
+    size: S.optional(S.Number),
+    status: S.String,
+    triggered_at: S.optional(S.String),
+  }),
+).annotate({ identifier: "Backup" }) as any as S.Schema<Backup>;
+
+export type ListBackupsResponse = Array<Backup>;
+export const ListBackupsResponse = /*@__PURE__*/ S.Array(
+  Backup,
+) as any as S.Schema<ListBackupsResponse>;
+
+export type ListBackupsResponse2 = ListBackupsResponse;
+export const ListBackupsResponse2 = /*@__PURE__*/ S.suspend(() =>
+  ListBackupsResponse.pipe(T.RawResponseRoot()),
+).annotate({ identifier: "ListBackupsResponse2" }) as any as S.Schema<ListBackupsResponse2>;
+
+export interface ListCredentialsRequest {
+  /** Project id on which user has permissions */
+  projectId: string;
+  /** region in which the project resides */
+  regionId: string;
+  /** Instance id */
+  instanceId: string;
+}
+export const ListCredentialsRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    projectId: S.String.pipe(T.Label()),
+    regionId: S.String.pipe(T.Label()),
+    instanceId: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/v2/projects/{projectId}/regions/{regionId}/instances/{instanceId}/credentials",
+      code: 200,
+      baseUrl: "https://valkey.api.stackit.cloud",
+    }),
+  ),
+).annotate({ identifier: "ListCredentialsRequest" }) as any as S.Schema<ListCredentialsRequest>;
+
+export interface CredentialsListItem {
+  id: string;
+}
+export const CredentialsListItem = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    id: S.String,
+  }),
+).annotate({ identifier: "CredentialsListItem" }) as any as S.Schema<CredentialsListItem>;
+
+export type ListCredentialsResponseCredentialsListList = Array<CredentialsListItem>;
+export const ListCredentialsResponseCredentialsListList = /*@__PURE__*/ S.Array(
+  CredentialsListItem,
+) as any as S.Schema<ListCredentialsResponseCredentialsListList>;
+
+export interface ListCredentialsResponse {
+  credentialsList: ListCredentialsResponseCredentialsListList;
+}
+export const ListCredentialsResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    credentialsList: ListCredentialsResponseCredentialsListList,
+  }),
+).annotate({ identifier: "ListCredentialsResponse" }) as any as S.Schema<ListCredentialsResponse>;
+
+export interface ListInstancesRequest {
+  /** Project id on which user has permissions */
+  projectId: string;
+  /** region in which the project resides */
+  regionId: string;
+}
+export const ListInstancesRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    projectId: S.String.pipe(T.Label()),
+    regionId: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/v2/projects/{projectId}/regions/{regionId}/instances",
+      code: 200,
+      baseUrl: "https://valkey.api.stackit.cloud",
+    }),
+  ),
+).annotate({ identifier: "ListInstancesRequest" }) as any as S.Schema<ListInstancesRequest>;
+
+export type ListInstancesResponseInstancesList = Array<Instance>;
+export const ListInstancesResponseInstancesList = /*@__PURE__*/ S.Array(
+  Instance,
+) as any as S.Schema<ListInstancesResponseInstancesList>;
+
+export interface ListInstancesResponse {
+  instances: ListInstancesResponseInstancesList;
+}
+export const ListInstancesResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    instances: ListInstancesResponseInstancesList,
+  }),
+).annotate({ identifier: "ListInstancesResponse" }) as any as S.Schema<ListInstancesResponse>;
+
+export interface ListOfferingsRequest {
+  /** Project id on which user has permissions */
+  projectId: string;
+  /** region in which the project resides */
+  regionId: string;
+}
+export const ListOfferingsRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    projectId: S.String.pipe(T.Label()),
+    regionId: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/v2/projects/{projectId}/regions/{regionId}/offerings",
+      code: 200,
+      baseUrl: "https://valkey.api.stackit.cloud",
+    }),
+  ),
+).annotate({ identifier: "ListOfferingsRequest" }) as any as S.Schema<ListOfferingsRequest>;
+
+export interface Plan {
+  description: string;
+  free: boolean;
+  id: string;
+  name: string;
+  skuName: string;
+}
+export const Plan = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    description: S.String,
+    free: S.Boolean,
+    id: S.String,
+    name: S.String,
+    skuName: S.String,
+  }),
+).annotate({ identifier: "Plan" }) as any as S.Schema<Plan>;
+
+export type OfferingPlansList = Array<Plan>;
+export const OfferingPlansList = /*@__PURE__*/ S.Array(Plan) as any as S.Schema<OfferingPlansList>;
+
+export interface Schema {
+  parameters: unknown;
+}
+export const Schema = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    parameters: S.Unknown,
+  }),
+).annotate({ identifier: "Schema" }) as any as S.Schema<Schema>;
+
+export interface InstanceSchema {
+  create: Schema;
+  update: Schema;
+}
+export const InstanceSchema = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    create: Schema,
+    update: Schema,
+  }),
+).annotate({ identifier: "InstanceSchema" }) as any as S.Schema<InstanceSchema>;
+
+export interface Offering {
+  description: string;
+  documentationUrl: string;
+  imageUrl: string;
+  latest: boolean;
+  lifecycle?: string;
+  name: string;
+  plans: OfferingPlansList;
+  quotaCount: number;
+  schema?: InstanceSchema;
+  version: string;
+}
+export const Offering = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    description: S.String,
+    documentationUrl: S.String,
+    imageUrl: S.String,
+    latest: S.Boolean,
+    lifecycle: S.optional(S.String),
+    name: S.String,
+    plans: OfferingPlansList,
+    quotaCount: S.Number,
+    schema: S.optional(InstanceSchema),
+    version: S.String,
+  }),
+).annotate({ identifier: "Offering" }) as any as S.Schema<Offering>;
+
+export type ListOfferingsResponseOfferingsList = Array<Offering>;
+export const ListOfferingsResponseOfferingsList = /*@__PURE__*/ S.Array(
+  Offering,
+) as any as S.Schema<ListOfferingsResponseOfferingsList>;
+
+export interface ListOfferingsResponse {
+  offerings: ListOfferingsResponseOfferingsList;
+}
+export const ListOfferingsResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    offerings: ListOfferingsResponseOfferingsList,
+  }),
+).annotate({ identifier: "ListOfferingsResponse" }) as any as S.Schema<ListOfferingsResponse>;
+
+export interface ListRestoresRequest {
+  /** Project id on which user has permissions */
+  projectId: string;
+  /** region in which the project resides */
+  regionId: string;
+  /** Instance id */
+  instanceId: string;
+}
+export const ListRestoresRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    projectId: S.String.pipe(T.Label()),
+    regionId: S.String.pipe(T.Label()),
+    instanceId: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/v2/projects/{projectId}/regions/{regionId}/instances/{instanceId}/restores",
+      code: 200,
+      baseUrl: "https://valkey.api.stackit.cloud",
+    }),
+  ),
+).annotate({ identifier: "ListRestoresRequest" }) as any as S.Schema<ListRestoresRequest>;
+
+export interface Restore {
+  backup_id: number;
+  finished_at: string;
+  id: number;
+  status: string;
+  triggered_at?: string;
+}
+export const Restore = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    backup_id: S.Number,
+    finished_at: S.String,
+    id: S.Number,
+    status: S.String,
+    triggered_at: S.optional(S.String),
+  }),
+).annotate({ identifier: "Restore" }) as any as S.Schema<Restore>;
+
+export type ListRestoresResponseInstanceRestoresList = Array<Restore>;
+export const ListRestoresResponseInstanceRestoresList = /*@__PURE__*/ S.Array(
+  Restore,
+) as any as S.Schema<ListRestoresResponseInstanceRestoresList>;
+
+export interface ListRestoresResponse {
+  instanceRestores: ListRestoresResponseInstanceRestoresList;
+}
+export const ListRestoresResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    instanceRestores: ListRestoresResponseInstanceRestoresList,
+  }),
+).annotate({ identifier: "ListRestoresResponse" }) as any as S.Schema<ListRestoresResponse>;
+
+export interface PartialUpdateInstanceRequest {
+  /** Project id on which user has permissions */
+  projectId: string;
+  /** region in which the project resides */
+  regionId: string;
+  /** Instance id */
+  instanceId: string;
+  instanceName?: string;
+  parameters?: InstanceParameters;
+  planId?: string;
+}
+export const PartialUpdateInstanceRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    projectId: S.String.pipe(T.Label()),
+    regionId: S.String.pipe(T.Label()),
+    instanceId: S.String.pipe(T.Label()),
+    instanceName: S.optional(S.String),
+    parameters: S.optional(InstanceParameters),
+    planId: S.optional(S.String),
+  }).pipe(
+    T.Http({
+      method: "PATCH",
+      uri: "/v2/projects/{projectId}/regions/{regionId}/instances/{instanceId}",
+      code: 200,
+      baseUrl: "https://valkey.api.stackit.cloud",
+    }),
+  ),
+).annotate({
+  identifier: "PartialUpdateInstanceRequest",
+}) as any as S.Schema<PartialUpdateInstanceRequest>;
+
+export interface PartialUpdateInstanceResponse {}
+export const PartialUpdateInstanceResponse = /*@__PURE__*/ S.suspend(() => S.Struct({})).annotate({
+  identifier: "PartialUpdateInstanceResponse",
+}) as any as S.Schema<PartialUpdateInstanceResponse>;
+
+export interface TriggerRecreateRequest {
+  /** Project id on which user has permissions */
+  projectId: string;
+  /** region in which the project resides */
+  regionId: string;
+  /** Instance id */
+  instanceId: string;
+}
+export const TriggerRecreateRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    projectId: S.String.pipe(T.Label()),
+    regionId: S.String.pipe(T.Label()),
+    instanceId: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "PATCH",
+      uri: "/v2/projects/{projectId}/regions/{regionId}/instances/{instanceId}/recreate",
+      code: 200,
+      baseUrl: "https://valkey.api.stackit.cloud",
+    }),
+  ),
+).annotate({ identifier: "TriggerRecreateRequest" }) as any as S.Schema<TriggerRecreateRequest>;
+
+export interface TriggerRestartRequest {
+  /** Project id on which user has permissions */
+  projectId: string;
+  /** region in which the project resides */
+  regionId: string;
+  /** Instance id */
+  instanceId: string;
+}
+export const TriggerRestartRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    projectId: S.String.pipe(T.Label()),
+    regionId: S.String.pipe(T.Label()),
+    instanceId: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "PATCH",
+      uri: "/v2/projects/{projectId}/regions/{regionId}/instances/{instanceId}/restart",
+      code: 200,
+      baseUrl: "https://valkey.api.stackit.cloud",
+    }),
+  ),
+).annotate({ identifier: "TriggerRestartRequest" }) as any as S.Schema<TriggerRestartRequest>;
+
+export interface TriggerRestoreRequest {
+  /** Project id on which user has permissions */
+  projectId: string;
+  /** region in which the project resides */
+  regionId: string;
+  /** Instance id */
+  instanceId: string;
+  /** Backup id */
+  backupId: number;
+}
+export const TriggerRestoreRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    projectId: S.String.pipe(T.Label()),
+    regionId: S.String.pipe(T.Label()),
+    instanceId: S.String.pipe(T.Label()),
+    backupId: S.Number.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/v2/projects/{projectId}/regions/{regionId}/instances/{instanceId}/backups/{backupId}/restore",
+      code: 200,
+      baseUrl: "https://valkey.api.stackit.cloud",
+    }),
+  ),
+).annotate({ identifier: "TriggerRestoreRequest" }) as any as S.Schema<TriggerRestoreRequest>;
+
+export interface TriggerRestoreResponse {
+  id: number;
+}
+export const TriggerRestoreResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    id: S.Number,
+  }),
+).annotate({ identifier: "TriggerRestoreResponse" }) as any as S.Schema<TriggerRestoreResponse>;
+
+export interface UpdateBackupsConfigRequest {
+  /** Project id on which user has permissions */
+  projectId: string;
+  /** region in which the project resides */
+  regionId: string;
+  /** Instance id */
+  instanceId: string;
+  encryption_key?: string;
+}
+export const UpdateBackupsConfigRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    projectId: S.String.pipe(T.Label()),
+    regionId: S.String.pipe(T.Label()),
+    instanceId: S.String.pipe(T.Label()),
+    encryption_key: S.optional(S.String),
+  }).pipe(
+    T.Http({
+      method: "PATCH",
+      uri: "/v2/projects/{projectId}/regions/{regionId}/instances/{instanceId}/backups-config",
+      code: 200,
+      baseUrl: "https://valkey.api.stackit.cloud",
+    }),
+  ),
+).annotate({
+  identifier: "UpdateBackupsConfigRequest",
+}) as any as S.Schema<UpdateBackupsConfigRequest>;
+
+export interface UpdateBackupsConfigResponse {
+  message: string;
+}
+export const UpdateBackupsConfigResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    message: S.String,
+  }),
+).annotate({
+  identifier: "UpdateBackupsConfigResponse",
+}) as any as S.Schema<UpdateBackupsConfigResponse>;
+
+export type CreateBackupError = BadRequest | NotFound | StackitOpError;
+/** create a backup */
+export const createBackup: API.OperationMethod<
+  CreateBackupRequest,
+  CreateBackupResponseItem,
+  CreateBackupError,
+  StackitOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateBackupRequest,
+  output: CreateBackupResponseItem,
+  errors: [BadRequest, NotFound, UnknownStackitError],
+  protocol: StackitProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateCredentialsError = BadRequest | StackitOpError;
+/** create new credentials Create new service credentials */
+export const createCredentials: API.OperationMethod<
+  CreateCredentialsRequest,
+  CredentialsResponse,
+  CreateCredentialsError,
+  StackitOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateCredentialsRequest,
+  output: CredentialsResponse,
+  errors: [BadRequest, UnknownStackitError],
+  protocol: StackitProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateInstanceError = BadRequest | Conflict | StackitOpError;
+/** provision Provision a service instance. */
+export const createInstance: API.OperationMethod<
+  CreateInstanceRequest,
+  CreateInstanceResponse,
+  CreateInstanceError,
+  StackitOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateInstanceRequest,
+  output: CreateInstanceResponse,
+  errors: [BadRequest, Conflict, UnknownStackitError],
+  protocol: StackitProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteCredentialsError = BadRequest | NotFound | StackitOpError;
+/** delete credentials by id Delete a service credentials. */
+export const deleteCredentials: API.OperationMethod<
+  DeleteCredentialsRequest,
+  DeleteCredentialsResponse,
+  DeleteCredentialsError,
+  StackitOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteCredentialsRequest,
+  output: DeleteCredentialsResponse,
+  errors: [BadRequest, NotFound, UnknownStackitError],
+  protocol: StackitProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteInstanceError = BadRequest | NotFound | StackitOpError;
+/** delete service instance Deprovision a service instance. */
+export const deleteInstance: API.OperationMethod<
+  DeleteInstanceRequest,
+  DeleteInstanceResponse,
+  DeleteInstanceError,
+  StackitOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteInstanceRequest,
+  output: DeleteInstanceResponse,
+  errors: [BadRequest, NotFound, UnknownStackitError],
+  protocol: StackitProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DownloadBackupError = BadRequest | NotFound | StackitOpError;
+/** download backup */
+export const downloadBackup: API.OperationMethod<
+  DownloadBackupRequest,
+  DownloadBackupResponse,
+  DownloadBackupError,
+  StackitOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DownloadBackupRequest,
+  output: DownloadBackupResponse,
+  errors: [BadRequest, NotFound, UnknownStackitError],
+  protocol: StackitProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetCredentialsError = BadRequest | NotFound | StackitOpError;
+/** get credentials by id get a service credentials by credentials id */
+export const getCredentials: API.OperationMethod<
+  GetCredentialsRequest,
+  CredentialsResponse,
+  GetCredentialsError,
+  StackitOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetCredentialsRequest,
+  output: CredentialsResponse,
+  errors: [BadRequest, NotFound, UnknownStackitError],
+  protocol: StackitProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetInstanceError = BadRequest | NotFound | StackitOpError;
+/** get a service instance get a service instance */
+export const getInstance: API.OperationMethod<
+  GetInstanceRequest,
+  Instance,
+  GetInstanceError,
+  StackitOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetInstanceRequest,
+  output: Instance,
+  errors: [BadRequest, NotFound, UnknownStackitError],
+  protocol: StackitProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetMetricsError = BadRequest | NotFound | StackitOpError;
+/** get latest metrics for cpu load, memory and disk usage */
+export const getMetrics: API.OperationMethod<
+  GetMetricsRequest,
+  GetMetricsResponse,
+  GetMetricsError,
+  StackitOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetMetricsRequest,
+  output: GetMetricsResponse,
+  errors: [BadRequest, NotFound, UnknownStackitError],
+  protocol: StackitProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListBackupsError = BadRequest | NotFound | StackitOpError;
+/** get latest backup information for provided instanceId */
+export const listBackups: API.OperationMethod<
+  ListBackupsRequest,
+  ListBackupsResponse2,
+  ListBackupsError,
+  StackitOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListBackupsRequest,
+  output: ListBackupsResponse2,
+  errors: [BadRequest, NotFound, UnknownStackitError],
+  protocol: StackitProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListCredentialsError = BadRequest | NotFound | StackitOpError;
+/** get list of credentials ids get list all credentials ids for instance */
+export const listCredentials: API.OperationMethod<
+  ListCredentialsRequest,
+  ListCredentialsResponse,
+  ListCredentialsError,
+  StackitOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListCredentialsRequest,
+  output: ListCredentialsResponse,
+  errors: [BadRequest, NotFound, UnknownStackitError],
+  protocol: StackitProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListInstancesError = BadRequest | NotFound | StackitOpError;
+/** get service instances list Get a list of available instances */
+export const listInstances: API.OperationMethod<
+  ListInstancesRequest,
+  ListInstancesResponse,
+  ListInstancesError,
+  StackitOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListInstancesRequest,
+  output: ListInstancesResponse,
+  errors: [BadRequest, NotFound, UnknownStackitError],
+  protocol: StackitProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListOfferingsError = BadRequest | NotFound | StackitOpError;
+/** get the service offerings Get the service offerings that the service broker offers. */
+export const listOfferings: API.OperationMethod<
+  ListOfferingsRequest,
+  ListOfferingsResponse,
+  ListOfferingsError,
+  StackitOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListOfferingsRequest,
+  output: ListOfferingsResponse,
+  errors: [BadRequest, NotFound, UnknownStackitError],
+  protocol: StackitProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListRestoresError = BadRequest | NotFound | StackitOpError;
+/** get latest restore information for provided instanceId */
+export const listRestores: API.OperationMethod<
+  ListRestoresRequest,
+  ListRestoresResponse,
+  ListRestoresError,
+  StackitOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListRestoresRequest,
+  output: ListRestoresResponse,
+  errors: [BadRequest, NotFound, UnknownStackitError],
+  protocol: StackitProtocol,
+  retry: Retry.Retry,
+}));
+
+export type PartialUpdateInstanceError = BadRequest | NotFound | StackitOpError;
+/** update a service instance Update a service instance. This could be a sgw acl update or a plan upgrade. */
+export const partialUpdateInstance: API.OperationMethod<
+  PartialUpdateInstanceRequest,
+  PartialUpdateInstanceResponse,
+  PartialUpdateInstanceError,
+  StackitOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PartialUpdateInstanceRequest,
+  output: PartialUpdateInstanceResponse,
+  errors: [BadRequest, NotFound, UnknownStackitError],
+  protocol: StackitProtocol,
+  retry: Retry.Retry,
+}));
+
+export type TriggerRecreateError = BadRequest | NotFound | StackitOpError;
+/** trigger a recreate */
+export const triggerRecreate: API.OperationMethod<
+  TriggerRecreateRequest,
+  CreateInstanceResponse,
+  TriggerRecreateError,
+  StackitOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: TriggerRecreateRequest,
+  output: CreateInstanceResponse,
+  errors: [BadRequest, NotFound, UnknownStackitError],
+  protocol: StackitProtocol,
+  retry: Retry.Retry,
+}));
+
+export type TriggerRestartError = BadRequest | NotFound | StackitOpError;
+/** trigger a restart */
+export const triggerRestart: API.OperationMethod<
+  TriggerRestartRequest,
+  CreateInstanceResponse,
+  TriggerRestartError,
+  StackitOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: TriggerRestartRequest,
+  output: CreateInstanceResponse,
+  errors: [BadRequest, NotFound, UnknownStackitError],
+  protocol: StackitProtocol,
+  retry: Retry.Retry,
+}));
+
+export type TriggerRestoreError = BadRequest | NotFound | StackitOpError;
+/** trigger a restore */
+export const triggerRestore: API.OperationMethod<
+  TriggerRestoreRequest,
+  TriggerRestoreResponse,
+  TriggerRestoreError,
+  StackitOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: TriggerRestoreRequest,
+  output: TriggerRestoreResponse,
+  errors: [BadRequest, NotFound, UnknownStackitError],
+  protocol: StackitProtocol,
+  retry: Retry.Retry,
+}));
+
+export type UpdateBackupsConfigError = BadRequest | NotFound | StackitOpError;
+/** backups configuration update Update the configuration for backups for your instance. */
+export const updateBackupsConfig: API.OperationMethod<
+  UpdateBackupsConfigRequest,
+  UpdateBackupsConfigResponse,
+  UpdateBackupsConfigError,
+  StackitOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: UpdateBackupsConfigRequest,
+  output: UpdateBackupsConfigResponse,
+  errors: [BadRequest, NotFound, UnknownStackitError],
+  protocol: StackitProtocol,
+  retry: Retry.Retry,
+}));