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

package/src/services/sfs.ts

@@ -0,0 +1,1831 @@
+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 }],
+  ) {}
+
+/** List of IPs that can mount the Resource Pool in read-only; IPs must have a subnet mask (e.g. "172.16.0.0/24" for a range of IPs, or "172.16.0.250/32" for a specific IP) */
+export type CreateResourcePoolRequestIpAclList = Array<string>;
+export const CreateResourcePoolRequestIpAclList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<CreateResourcePoolRequestIpAclList>;
+
+/** An optional object that represents the labels associated with the resource pool. */
+export type CreateResourcePoolRequestLabelsMap = { [key: string]: string | undefined };
+export const CreateResourcePoolRequestLabelsMap = /*@__PURE__*/ S.Record(
+  S.String,
+  S.String,
+) as any as S.Schema<CreateResourcePoolRequestLabelsMap>;
+
+export interface CreateResourcePoolRequest {
+  projectId: string;
+  region: string;
+  /** Availability zone */
+  availabilityZone: string;
+  /** List of IPs that can mount the Resource Pool in read-only; IPs must have a subnet mask (e.g. "172.16.0.0/24" for a range of IPs, or "172.16.0.250/32" for a specific IP) */
+  ipAcl: CreateResourcePoolRequestIpAclList;
+  /** An optional object that represents the labels associated with the resource pool. */
+  labels?: CreateResourcePoolRequestLabelsMap;
+  /** Name of the Resource Pool */
+  name: string;
+  /** Name of the performance class */
+  performanceClass: string;
+  /** Size of the Resource Pool (unit: gibibytes) */
+  sizeGigabytes: number;
+  /** (optional) Id of the Snapshot Policy to use */
+  snapshotPolicyId?: string;
+  /** Whether the .snapshot directory is visible when mounting the resource pool. Setting this value to false might prevent you from accessing the snapshots (e.g. for security reasons). Additionally, the access to the snapshots is always controlled by the export policy of the resource pool. That means, if snapshots are visible and the export policy allows for reading the resource pool, then it also allows reading the snapshot of all shares. */
+  snapshotsAreVisible?: boolean;
+}
+export const CreateResourcePoolRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    projectId: S.String.pipe(T.Label()),
+    region: S.String.pipe(T.Label()),
+    availabilityZone: S.String,
+    ipAcl: CreateResourcePoolRequestIpAclList,
+    labels: S.optional(CreateResourcePoolRequestLabelsMap),
+    name: S.String,
+    performanceClass: S.String,
+    sizeGigabytes: S.Number,
+    snapshotPolicyId: S.optional(S.String),
+    snapshotsAreVisible: S.optional(S.Boolean),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/v1/projects/{projectId}/regions/{region}/resourcePools",
+      code: 200,
+      baseUrl: "https://sfs.api.stackit.cloud",
+    }),
+  ),
+).annotate({
+  identifier: "CreateResourcePoolRequest",
+}) as any as S.Schema<CreateResourcePoolRequest>;
+
+/** List of IPs that can mount the Resource Pool in read-only; IPs must have a subnet mask (e.g. "172.16.0.0/24" for a range of IPs, or "172.16.0.250/32" for a specific IP) */
+export type ResourcePoolIpAclList = Array<string>;
+export const ResourcePoolIpAclList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<ResourcePoolIpAclList>;
+
+export type ResourcePoolLabelsMap = { [key: string]: string | undefined };
+export const ResourcePoolLabelsMap = /*@__PURE__*/ S.Record(
+  S.String,
+  S.String,
+) as any as S.Schema<ResourcePoolLabelsMap>;
+
+export interface ResourcePoolPerformanceClass {
+  /** Name of the performance class */
+  name?: string;
+  /** Max. IOPS of the Resource Pool. This is shared between every Share in the Resource Pool. */
+  peakIops?: number;
+  /** Throughput of the Resource Pool. */
+  throughput?: number;
+}
+export const ResourcePoolPerformanceClass = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    name: S.optional(S.String),
+    peakIops: S.optional(S.Number),
+    throughput: S.optional(S.Number),
+  }),
+).annotate({
+  identifier: "ResourcePoolPerformanceClass",
+}) as any as S.Schema<ResourcePoolPerformanceClass>;
+
+export interface ResourcePoolSnapshotPolicy {
+  /** ID of the Snapshot Policy */
+  id?: string;
+  /** Name of the Snapshot Policy */
+  name?: string;
+}
+export const ResourcePoolSnapshotPolicy = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    id: S.optional(S.String),
+    name: S.optional(S.String),
+  }),
+).annotate({
+  identifier: "ResourcePoolSnapshotPolicy",
+}) as any as S.Schema<ResourcePoolSnapshotPolicy>;
+
+export interface ResourcePoolSpace {
+  /** Available space of the Resource Pool (only available when retrieving a single Resource Pool by ID) */
+  availableGigabytes?: number | null;
+  /** Size of the Resource Pool in Gibibytes. */
+  sizeGigabytes?: number;
+  /** Used space by snapshots (only available when retrieving a single Resource Pool by ID) */
+  usedBySnapshotsGigabytes?: number | null;
+  /** Used space of the Resource Pool (only available when retrieving a single Resource Pool by ID) */
+  usedGigabytes?: number | null;
+}
+export const ResourcePoolSpace = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    availableGigabytes: S.optional(S.NullOr(S.Number)),
+    sizeGigabytes: S.optional(S.Number),
+    usedBySnapshotsGigabytes: S.optional(S.NullOr(S.Number)),
+    usedGigabytes: S.optional(S.NullOr(S.Number)),
+  }),
+).annotate({ identifier: "ResourcePoolSpace" }) as any as S.Schema<ResourcePoolSpace>;
+
+export interface ResourcePool {
+  /** Name of the respective availability zone */
+  availabilityZone?: string;
+  /** Number of Shares in the Resource Pool */
+  countShares?: number;
+  createdAt?: string;
+  /** ID of the Resource Pool */
+  id?: string;
+  /** List of IPs that can mount the Resource Pool in read-only; IPs must have a subnet mask (e.g. "172.16.0.0/24" for a range of IPs, or "172.16.0.250/32" for a specific IP) */
+  ipAcl?: ResourcePoolIpAclList;
+  labels?: ResourcePoolLabelsMap;
+  /** Mount path of the Resource Pool, used to mount the Resource Pool Note that a Resource Pool can only be mounted in read-only */
+  mountPath?: string;
+  /** Name of the Resource Pool */
+  name?: string;
+  /** Information about the performance class */
+  performanceClass?: ResourcePoolPerformanceClass;
+  /** Time when the performance class can be downgraded again. */
+  performanceClassDowngradableAt?: string;
+  /** Time when the size can be reduced again. */
+  sizeReducibleAt?: string;
+  /** (optional) Snapshot Policy */
+  snapshotPolicy?: ResourcePoolSnapshotPolicy | null;
+  /** Whether the .snapshot directory is visible when mounting the resource pool. Setting this value to false might prevent you from accessing the snapshots (e.g. for security reasons). Additionally, the access to the snapshots is always controlled by the export policy of the resource pool. That means, if snapshots are visible and the export policy allows for reading the resource pool, then it also allows reading the snapshot of all shares. */
+  snapshotsAreVisible?: boolean;
+  /** Space information */
+  space?: ResourcePoolSpace;
+  /** State of the Resource Pool (possible values: ["pending", "creating", "created", "updating", "error", "deleting"]) */
+  state?: string;
+}
+export const ResourcePool = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    availabilityZone: S.optional(S.String),
+    countShares: S.optional(S.Number),
+    createdAt: S.optional(S.String),
+    id: S.optional(S.String),
+    ipAcl: S.optional(ResourcePoolIpAclList),
+    labels: S.optional(ResourcePoolLabelsMap),
+    mountPath: S.optional(S.String),
+    name: S.optional(S.String),
+    performanceClass: S.optional(ResourcePoolPerformanceClass),
+    performanceClassDowngradableAt: S.optional(S.String),
+    sizeReducibleAt: S.optional(S.String),
+    snapshotPolicy: S.optional(S.NullOr(ResourcePoolSnapshotPolicy)),
+    snapshotsAreVisible: S.optional(S.Boolean),
+    space: S.optional(ResourcePoolSpace),
+    state: S.optional(S.String),
+  }),
+).annotate({ identifier: "ResourcePool" }) as any as S.Schema<ResourcePool>;
+
+export interface CreateResourcePoolResponse {
+  /** Created Resource Pool */
+  resourcePool?: ResourcePool;
+}
+export const CreateResourcePoolResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    resourcePool: S.optional(ResourcePool),
+  }),
+).annotate({
+  identifier: "CreateResourcePoolResponse",
+}) as any as S.Schema<CreateResourcePoolResponse>;
+
+export interface CreateResourcePoolSnapshotRequest {
+  projectId: string;
+  region: string;
+  resourcePoolId: string;
+  /** (optional) A comment to add more information about a snapshot */
+  comment?: string | null;
+  /** Name of the Resource Pool Snapshot */
+  name?: string;
+  /** (optional) Time in hours after which snaplock on the snapshot expires */
+  snaplockRetentionHours?: number | null;
+}
+export const CreateResourcePoolSnapshotRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    projectId: S.String.pipe(T.Label()),
+    region: S.String.pipe(T.Label()),
+    resourcePoolId: S.String.pipe(T.Label()),
+    comment: S.optional(S.NullOr(S.String)),
+    name: S.optional(S.String),
+    snaplockRetentionHours: S.optional(S.NullOr(S.Number)),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/v1/projects/{projectId}/regions/{region}/resourcePools/{resourcePoolId}/snapshots",
+      code: 200,
+      baseUrl: "https://sfs.api.stackit.cloud",
+    }),
+  ),
+).annotate({
+  identifier: "CreateResourcePoolSnapshotRequest",
+}) as any as S.Schema<CreateResourcePoolSnapshotRequest>;
+
+export interface ResourcePoolSnapshot {
+  /** (optional) A comment to add more information about a snapshot */
+  comment?: string | null;
+  createdAt?: string;
+  /** Represents the user-visible data size at the time of the snapshot in Gibibytes (e.g. what’s in the snapshot) */
+  logicalSizeGigabytes?: number;
+  /** ID of the Resource Pool of the Snapshot */
+  resourcePoolId?: string;
+  /** Reflects the actual storage footprint in the backend at snapshot time in Gibibytes (e.g. how much storage from the Resource Pool does it use). */
+  sizeGigabytes?: number;
+  /** Represents the snaplock expiry time if snaplock is enabled for the resource pool */
+  snaplockExpiryTime?: string | null;
+  /** Name of the Resource Pool Snapshot */
+  snapshotName?: string;
+}
+export const ResourcePoolSnapshot = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    comment: S.optional(S.NullOr(S.String)),
+    createdAt: S.optional(S.String),
+    logicalSizeGigabytes: S.optional(S.Number),
+    resourcePoolId: S.optional(S.String),
+    sizeGigabytes: S.optional(S.Number),
+    snaplockExpiryTime: S.optional(S.NullOr(S.String)),
+    snapshotName: S.optional(S.String),
+  }),
+).annotate({ identifier: "ResourcePoolSnapshot" }) as any as S.Schema<ResourcePoolSnapshot>;
+
+export interface CreateResourcePoolSnapshotResponse {
+  /** Created Resource Pool Snapshot */
+  resourcePoolSnapshot?: ResourcePoolSnapshot;
+}
+export const CreateResourcePoolSnapshotResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    resourcePoolSnapshot: S.optional(ResourcePoolSnapshot),
+  }),
+).annotate({
+  identifier: "CreateResourcePoolSnapshotResponse",
+}) as any as S.Schema<CreateResourcePoolSnapshotResponse>;
+
+/** An optional object that represents the labels associated with the share. */
+export type CreateShareRequestLabelsMap = { [key: string]: string | undefined };
+export const CreateShareRequestLabelsMap = /*@__PURE__*/ S.Record(
+  S.String,
+  S.String,
+) as any as S.Schema<CreateShareRequestLabelsMap>;
+
+export interface CreateShareRequest {
+  projectId: string;
+  region: string;
+  resourcePoolId: string;
+  /** Name of the Share Export Policy to use in the Share. Note that if this is not set, the Share can only be mounted in read only by clients with IPs matching the IP ACL of the Resource Pool hosting this Share. You can also assign a Share Export Policy after creating the Share */
+  exportPolicyName?: string | null;
+  /** An optional object that represents the labels associated with the share. */
+  labels?: CreateShareRequestLabelsMap;
+  /** Name of the Share */
+  name: string;
+  /** Space hard limit for the Share. If zero, the Share will have access to the full space of the Resource Pool it lives in. (unit: gibibytes) */
+  spaceHardLimitGigabytes: number;
+}
+export const CreateShareRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    projectId: S.String.pipe(T.Label()),
+    region: S.String.pipe(T.Label()),
+    resourcePoolId: S.String.pipe(T.Label()),
+    exportPolicyName: S.optional(S.NullOr(S.String)),
+    labels: S.optional(CreateShareRequestLabelsMap),
+    name: S.String,
+    spaceHardLimitGigabytes: S.Number,
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/v1/projects/{projectId}/regions/{region}/resourcePools/{resourcePoolId}/shares",
+      code: 200,
+      baseUrl: "https://sfs.api.stackit.cloud",
+    }),
+  ),
+).annotate({ identifier: "CreateShareRequest" }) as any as S.Schema<CreateShareRequest>;
+
+/** An optional object that represents the labels associated with the share export policy. */
+export type ShareExportPolicyLabelsMap = { [key: string]: string | undefined };
+export const ShareExportPolicyLabelsMap = /*@__PURE__*/ S.Record(
+  S.String,
+  S.String,
+) as any as S.Schema<ShareExportPolicyLabelsMap>;
+
+/** IP access control list, where IPs must have a subnet mask (e.g. "172.16.0.0/24" for a range of IPs, or "172.16.0.251/32" for a specific IP) This array cannot be empty */
+export type ShareExportPolicyRuleIpAclList = Array<string>;
+export const ShareExportPolicyRuleIpAclList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<ShareExportPolicyRuleIpAclList>;
+
+export interface ShareExportPolicyRule {
+  createdAt?: string;
+  /** Description of the Rule (optional) */
+  description?: string | null;
+  /** ID of the Share Export Policy Rule */
+  id?: string;
+  /** IP access control list, where IPs must have a subnet mask (e.g. "172.16.0.0/24" for a range of IPs, or "172.16.0.251/32" for a specific IP) This array cannot be empty */
+  ipAcl?: ShareExportPolicyRuleIpAclList;
+  /** Order of the rule within a Share Export Policy. The order is used so that when a client IP matches multiple rules, the first rule is applied This field must be set */
+  order?: number;
+  /** Flag to indicate if client IPs matching this rule can only mount the share in read only mode Default: false */
+  readOnly?: boolean;
+  /** Flag to honor set UUID Default: false */
+  setUuid?: boolean;
+  /** Flag to indicate if client IPs matching this rule have root access on the Share Default: true */
+  superUser?: boolean;
+}
+export const ShareExportPolicyRule = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    createdAt: S.optional(S.String),
+    description: S.optional(S.NullOr(S.String)),
+    id: S.optional(S.String),
+    ipAcl: S.optional(ShareExportPolicyRuleIpAclList),
+    order: S.optional(S.Number),
+    readOnly: S.optional(S.Boolean),
+    setUuid: S.optional(S.Boolean),
+    superUser: S.optional(S.Boolean),
+  }),
+).annotate({ identifier: "ShareExportPolicyRule" }) as any as S.Schema<ShareExportPolicyRule>;
+
+/** List of rules of the Share Export Policy. The order of the rules within the array does not matter - what matters is the field "order" within each rule */
+export type ShareExportPolicyRulesList = Array<ShareExportPolicyRule>;
+export const ShareExportPolicyRulesList = /*@__PURE__*/ S.Array(
+  ShareExportPolicyRule,
+) as any as S.Schema<ShareExportPolicyRulesList>;
+
+export interface ShareExportPolicy {
+  createdAt?: string;
+  /** ID of the Share Export Policy */
+  id?: string;
+  /** An optional object that represents the labels associated with the share export policy. */
+  labels?: ShareExportPolicyLabelsMap;
+  /** Name of the Share Export Policy */
+  name?: string;
+  /** List of rules of the Share Export Policy. The order of the rules within the array does not matter - what matters is the field "order" within each rule */
+  rules?: ShareExportPolicyRulesList;
+  /** Number of Shares using this Share Export Policy */
+  sharesUsingExportPolicy?: number;
+}
+export const ShareExportPolicy = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    createdAt: S.optional(S.String),
+    id: S.optional(S.String),
+    labels: S.optional(ShareExportPolicyLabelsMap),
+    name: S.optional(S.String),
+    rules: S.optional(ShareExportPolicyRulesList),
+    sharesUsingExportPolicy: S.optional(S.Number),
+  }),
+).annotate({ identifier: "ShareExportPolicy" }) as any as S.Schema<ShareExportPolicy>;
+
+/** An optional object that represents the labels associated with the share. */
+export type ShareLabelsMap = { [key: string]: string | undefined };
+export const ShareLabelsMap = /*@__PURE__*/ S.Record(
+  S.String,
+  S.String,
+) as any as S.Schema<ShareLabelsMap>;
+
+export interface Share {
+  createdAt?: string;
+  /** Details of the Share Export Policy to use in the Share. Note that if this is not set, the Share can only be mounted in read only by clients with IPs matching the IP ACL of the Resource Pool hosting this Share */
+  exportPolicy?: ShareExportPolicy | null;
+  /** ID of the Share */
+  id?: string;
+  /** An optional object that represents the labels associated with the share. */
+  labels?: ShareLabelsMap;
+  /** Mount path of the Share, used to mount the Share */
+  mountPath?: string;
+  /** Name of the Share */
+  name?: string;
+  /** Space hard limit for the Share. If zero, the Share will have access to the full space of the Resource Pool it lives in. (unit: gibibytes) */
+  spaceHardLimitGigabytes?: number;
+  /** State of the Resource Pool Snapshot (possible values: ["pending", "creating", "created", "error", "deleting"]) */
+  state?: string;
+}
+export const Share = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    createdAt: S.optional(S.String),
+    exportPolicy: S.optional(S.NullOr(ShareExportPolicy)),
+    id: S.optional(S.String),
+    labels: S.optional(ShareLabelsMap),
+    mountPath: S.optional(S.String),
+    name: S.optional(S.String),
+    spaceHardLimitGigabytes: S.optional(S.Number),
+    state: S.optional(S.String),
+  }),
+).annotate({ identifier: "Share" }) as any as S.Schema<Share>;
+
+export interface CreateShareResponse {
+  /** Created Share */
+  share?: Share;
+}
+export const CreateShareResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    share: S.optional(Share),
+  }),
+).annotate({ identifier: "CreateShareResponse" }) as any as S.Schema<CreateShareResponse>;
+
+/** An optional object that represents the labels associated with the share export policy. */
+export type CreateShareExportPolicyRequestLabelsMap = { [key: string]: string | undefined };
+export const CreateShareExportPolicyRequestLabelsMap = /*@__PURE__*/ S.Record(
+  S.String,
+  S.String,
+) as any as S.Schema<CreateShareExportPolicyRequestLabelsMap>;
+
+/** IP access control list, where IPs must have a subnet mask (e.g. "172.16.0.0/24" for a range of IPs, or "172.16.0.250/32" for a specific IP) This array cannot be empty */
+export type CreateShareExportPolicyRequestRuleIpAclList = Array<string>;
+export const CreateShareExportPolicyRequestRuleIpAclList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<CreateShareExportPolicyRequestRuleIpAclList>;
+
+export interface CreateShareExportPolicyRequestRule {
+  /** Description of the Rule (optional) */
+  description?: string | null;
+  /** IP access control list, where IPs must have a subnet mask (e.g. "172.16.0.0/24" for a range of IPs, or "172.16.0.250/32" for a specific IP) This array cannot be empty */
+  ipAcl?: CreateShareExportPolicyRequestRuleIpAclList;
+  /** Order of the rule within a Share Export Policy. The order is used so that when a client IP matches multiple rules, the first rule is applied This field must be set */
+  order?: number;
+  /** Flag to indicate if client IPs matching this rule can only mount the share in read only mode Default: false */
+  readOnly?: boolean;
+  /** Flag to honor set UUID Default: false */
+  setUuid?: boolean;
+  /** Flag to indicate if client IPs matching this rule have root access on the Share Default: true */
+  superUser?: boolean;
+}
+export const CreateShareExportPolicyRequestRule = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    description: S.optional(S.NullOr(S.String)),
+    ipAcl: S.optional(CreateShareExportPolicyRequestRuleIpAclList),
+    order: S.optional(S.Number),
+    readOnly: S.optional(S.Boolean),
+    setUuid: S.optional(S.Boolean),
+    superUser: S.optional(S.Boolean),
+  }),
+).annotate({
+  identifier: "CreateShareExportPolicyRequestRule",
+}) as any as S.Schema<CreateShareExportPolicyRequestRule>;
+
+/** List of rules of the Share Export Policy. The order of the rules within the array does not matter - what matters is the field "order" within each rule */
+export type CreateShareExportPolicyRequestRulesList = Array<CreateShareExportPolicyRequestRule>;
+export const CreateShareExportPolicyRequestRulesList = /*@__PURE__*/ S.Array(
+  CreateShareExportPolicyRequestRule,
+) as any as S.Schema<CreateShareExportPolicyRequestRulesList>;
+
+export interface CreateShareExportPolicyRequest {
+  projectId: string;
+  region: string;
+  /** An optional object that represents the labels associated with the share export policy. */
+  labels?: CreateShareExportPolicyRequestLabelsMap;
+  /** Name of the Share Export Policy */
+  name: string;
+  /** List of rules of the Share Export Policy. The order of the rules within the array does not matter - what matters is the field "order" within each rule */
+  rules?: CreateShareExportPolicyRequestRulesList;
+}
+export const CreateShareExportPolicyRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    projectId: S.String.pipe(T.Label()),
+    region: S.String.pipe(T.Label()),
+    labels: S.optional(CreateShareExportPolicyRequestLabelsMap),
+    name: S.String,
+    rules: S.optional(CreateShareExportPolicyRequestRulesList),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/v1/projects/{projectId}/regions/{region}/shareExportPolicies",
+      code: 200,
+      baseUrl: "https://sfs.api.stackit.cloud",
+    }),
+  ),
+).annotate({
+  identifier: "CreateShareExportPolicyRequest",
+}) as any as S.Schema<CreateShareExportPolicyRequest>;
+
+export interface CreateShareExportPolicyResponse {
+  /** Created Share Export Policy */
+  shareExportPolicy?: ShareExportPolicy;
+}
+export const CreateShareExportPolicyResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    shareExportPolicy: S.optional(ShareExportPolicy),
+  }),
+).annotate({
+  identifier: "CreateShareExportPolicyResponse",
+}) as any as S.Schema<CreateShareExportPolicyResponse>;
+
+export interface DeleteResourcePoolRequest {
+  projectId: string;
+  region: string;
+  resourcePoolId: string;
+}
+export const DeleteResourcePoolRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    projectId: S.String.pipe(T.Label()),
+    region: S.String.pipe(T.Label()),
+    resourcePoolId: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "DELETE",
+      uri: "/v1/projects/{projectId}/regions/{region}/resourcePools/{resourcePoolId}",
+      code: 200,
+      baseUrl: "https://sfs.api.stackit.cloud",
+    }),
+  ),
+).annotate({
+  identifier: "DeleteResourcePoolRequest",
+}) as any as S.Schema<DeleteResourcePoolRequest>;
+
+export type DeleteResourcePoolResponse2 = unknown;
+export const DeleteResourcePoolResponse2 = /*@__PURE__*/ S.suspend(() =>
+  S.Unknown.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "DeleteResourcePoolResponse2",
+}) as any as S.Schema<DeleteResourcePoolResponse2>;
+
+export interface DeleteResourcePoolSnapshotRequest {
+  projectId: string;
+  region: string;
+  resourcePoolId: string;
+  snapshotName: string;
+}
+export const DeleteResourcePoolSnapshotRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    projectId: S.String.pipe(T.Label()),
+    region: S.String.pipe(T.Label()),
+    resourcePoolId: S.String.pipe(T.Label()),
+    snapshotName: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "DELETE",
+      uri: "/v1/projects/{projectId}/regions/{region}/resourcePools/{resourcePoolId}/snapshots/{snapshotName}",
+      code: 200,
+      baseUrl: "https://sfs.api.stackit.cloud",
+    }),
+  ),
+).annotate({
+  identifier: "DeleteResourcePoolSnapshotRequest",
+}) as any as S.Schema<DeleteResourcePoolSnapshotRequest>;
+
+export type DeleteResourcePoolSnapshotResponse2 = unknown;
+export const DeleteResourcePoolSnapshotResponse2 = /*@__PURE__*/ S.suspend(() =>
+  S.Unknown.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "DeleteResourcePoolSnapshotResponse2",
+}) as any as S.Schema<DeleteResourcePoolSnapshotResponse2>;
+
+export interface DeleteShareRequest {
+  projectId: string;
+  region: string;
+  resourcePoolId: string;
+  shareId: string;
+}
+export const DeleteShareRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    projectId: S.String.pipe(T.Label()),
+    region: S.String.pipe(T.Label()),
+    resourcePoolId: S.String.pipe(T.Label()),
+    shareId: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "DELETE",
+      uri: "/v1/projects/{projectId}/regions/{region}/resourcePools/{resourcePoolId}/shares/{shareId}",
+      code: 200,
+      baseUrl: "https://sfs.api.stackit.cloud",
+    }),
+  ),
+).annotate({ identifier: "DeleteShareRequest" }) as any as S.Schema<DeleteShareRequest>;
+
+export type DeleteShareResponse2 = unknown;
+export const DeleteShareResponse2 = /*@__PURE__*/ S.suspend(() =>
+  S.Unknown.pipe(T.RawResponseRoot()),
+).annotate({ identifier: "DeleteShareResponse2" }) as any as S.Schema<DeleteShareResponse2>;
+
+export interface DeleteShareExportPolicyRequest {
+  projectId: string;
+  region: string;
+  policyId: string;
+}
+export const DeleteShareExportPolicyRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    projectId: S.String.pipe(T.Label()),
+    region: S.String.pipe(T.Label()),
+    policyId: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "DELETE",
+      uri: "/v1/projects/{projectId}/regions/{region}/shareExportPolicies/{policyId}",
+      code: 200,
+      baseUrl: "https://sfs.api.stackit.cloud",
+    }),
+  ),
+).annotate({
+  identifier: "DeleteShareExportPolicyRequest",
+}) as any as S.Schema<DeleteShareExportPolicyRequest>;
+
+export type DeleteShareExportPolicyResponse2 = unknown;
+export const DeleteShareExportPolicyResponse2 = /*@__PURE__*/ S.suspend(() =>
+  S.Unknown.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "DeleteShareExportPolicyResponse2",
+}) as any as S.Schema<DeleteShareExportPolicyResponse2>;
+
+export interface DisableLockRequest {
+  region: string;
+  projectId: string;
+}
+export const DisableLockRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    region: S.String.pipe(T.Label()),
+    projectId: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "DELETE",
+      uri: "/v1/regions/{region}/project/{projectId}/locks",
+      code: 200,
+      baseUrl: "https://sfs.api.stackit.cloud",
+    }),
+  ),
+).annotate({ identifier: "DisableLockRequest" }) as any as S.Schema<DisableLockRequest>;
+
+export type DisableLockResponse2 = unknown;
+export const DisableLockResponse2 = /*@__PURE__*/ S.suspend(() =>
+  S.Unknown.pipe(T.RawResponseRoot()),
+).annotate({ identifier: "DisableLockResponse2" }) as any as S.Schema<DisableLockResponse2>;
+
+export interface EnableLockRequest {
+  region: string;
+  projectId: string;
+}
+export const EnableLockRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    region: S.String.pipe(T.Label()),
+    projectId: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/v1/regions/{region}/project/{projectId}/locks",
+      code: 200,
+      baseUrl: "https://sfs.api.stackit.cloud",
+    }),
+  ),
+).annotate({ identifier: "EnableLockRequest" }) as any as S.Schema<EnableLockRequest>;
+
+export interface EnableLockResponse {
+  lockId?: string;
+}
+export const EnableLockResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    lockId: S.optional(S.String),
+  }),
+).annotate({ identifier: "EnableLockResponse" }) as any as S.Schema<EnableLockResponse>;
+
+export interface GetLockRequest {
+  region: string;
+  projectId: string;
+}
+export const GetLockRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    region: S.String.pipe(T.Label()),
+    projectId: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/v1/regions/{region}/project/{projectId}/locks",
+      code: 200,
+      baseUrl: "https://sfs.api.stackit.cloud",
+    }),
+  ),
+).annotate({ identifier: "GetLockRequest" }) as any as S.Schema<GetLockRequest>;
+
+export interface GetLockResponse {
+  lockId?: string;
+}
+export const GetLockResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    lockId: S.optional(S.String),
+  }),
+).annotate({ identifier: "GetLockResponse" }) as any as S.Schema<GetLockResponse>;
+
+export interface GetResourcePoolRequest {
+  projectId: string;
+  region: string;
+  resourcePoolId: string;
+}
+export const GetResourcePoolRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    projectId: S.String.pipe(T.Label()),
+    region: S.String.pipe(T.Label()),
+    resourcePoolId: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/v1/projects/{projectId}/regions/{region}/resourcePools/{resourcePoolId}",
+      code: 200,
+      baseUrl: "https://sfs.api.stackit.cloud",
+    }),
+  ),
+).annotate({ identifier: "GetResourcePoolRequest" }) as any as S.Schema<GetResourcePoolRequest>;
+
+export interface GetResourcePoolResponse {
+  /** Resource Pool */
+  resourcePool?: ResourcePool;
+}
+export const GetResourcePoolResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    resourcePool: S.optional(ResourcePool),
+  }),
+).annotate({ identifier: "GetResourcePoolResponse" }) as any as S.Schema<GetResourcePoolResponse>;
+
+export interface GetResourcePoolSnapshotRequest {
+  projectId: string;
+  region: string;
+  resourcePoolId: string;
+  snapshotName: string;
+}
+export const GetResourcePoolSnapshotRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    projectId: S.String.pipe(T.Label()),
+    region: S.String.pipe(T.Label()),
+    resourcePoolId: S.String.pipe(T.Label()),
+    snapshotName: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/v1/projects/{projectId}/regions/{region}/resourcePools/{resourcePoolId}/snapshots/{snapshotName}",
+      code: 200,
+      baseUrl: "https://sfs.api.stackit.cloud",
+    }),
+  ),
+).annotate({
+  identifier: "GetResourcePoolSnapshotRequest",
+}) as any as S.Schema<GetResourcePoolSnapshotRequest>;
+
+export interface GetResourcePoolSnapshotResponse {
+  /** Resource Pool Snapshot */
+  resourcePoolSnapshot?: ResourcePoolSnapshot;
+}
+export const GetResourcePoolSnapshotResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    resourcePoolSnapshot: S.optional(ResourcePoolSnapshot),
+  }),
+).annotate({
+  identifier: "GetResourcePoolSnapshotResponse",
+}) as any as S.Schema<GetResourcePoolSnapshotResponse>;
+
+export interface GetShareRequest {
+  projectId: string;
+  region: string;
+  resourcePoolId: string;
+  shareId: string;
+}
+export const GetShareRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    projectId: S.String.pipe(T.Label()),
+    region: S.String.pipe(T.Label()),
+    resourcePoolId: S.String.pipe(T.Label()),
+    shareId: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/v1/projects/{projectId}/regions/{region}/resourcePools/{resourcePoolId}/shares/{shareId}",
+      code: 200,
+      baseUrl: "https://sfs.api.stackit.cloud",
+    }),
+  ),
+).annotate({ identifier: "GetShareRequest" }) as any as S.Schema<GetShareRequest>;
+
+export interface GetShareResponse {
+  /** Share */
+  share?: Share;
+}
+export const GetShareResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    share: S.optional(Share),
+  }),
+).annotate({ identifier: "GetShareResponse" }) as any as S.Schema<GetShareResponse>;
+
+export interface GetShareExportPolicyRequest {
+  projectId: string;
+  region: string;
+  policyId: string;
+}
+export const GetShareExportPolicyRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    projectId: S.String.pipe(T.Label()),
+    region: S.String.pipe(T.Label()),
+    policyId: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/v1/projects/{projectId}/regions/{region}/shareExportPolicies/{policyId}",
+      code: 200,
+      baseUrl: "https://sfs.api.stackit.cloud",
+    }),
+  ),
+).annotate({
+  identifier: "GetShareExportPolicyRequest",
+}) as any as S.Schema<GetShareExportPolicyRequest>;
+
+export interface GetShareExportPolicyResponse {
+  /** Share Export Policies */
+  shareExportPolicy?: ShareExportPolicy;
+}
+export const GetShareExportPolicyResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    shareExportPolicy: S.optional(ShareExportPolicy),
+  }),
+).annotate({
+  identifier: "GetShareExportPolicyResponse",
+}) as any as S.Schema<GetShareExportPolicyResponse>;
+
+export interface GetSnapshotPolicyRequest {
+  projectId: string;
+  id: string;
+}
+export const GetSnapshotPolicyRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    projectId: S.String.pipe(T.Label()),
+    id: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/v1/projects/{projectId}/snapshotPolicies/{id}",
+      code: 200,
+      baseUrl: "https://sfs.api.stackit.cloud",
+    }),
+  ),
+).annotate({ identifier: "GetSnapshotPolicyRequest" }) as any as S.Schema<GetSnapshotPolicyRequest>;
+
+export interface SnapshotPolicySchedule {
+  /** Retention Count */
+  count?: number;
+  /** Interval of the Schedule (follows the cron schedule expression in Unix-like systems) */
+  interval?: string;
+  /** Prefix used for the snapshots created by this policy */
+  prefix?: string;
+  /** Retention Period (ISO 8601 format or "infinite") */
+  retentionPeriod?: string;
+  /** ID of the Schedule */
+  scheduleId?: string;
+}
+export const SnapshotPolicySchedule = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    count: S.optional(S.Number),
+    interval: S.optional(S.String),
+    prefix: S.optional(S.String),
+    retentionPeriod: S.optional(S.String),
+    scheduleId: S.optional(S.String),
+  }),
+).annotate({ identifier: "SnapshotPolicySchedule" }) as any as S.Schema<SnapshotPolicySchedule>;
+
+/** (deprecated) associated schedules */
+export type SnapshotPolicySchedulesList = Array<SnapshotPolicySchedule>;
+export const SnapshotPolicySchedulesList = /*@__PURE__*/ S.Array(
+  SnapshotPolicySchedule,
+) as any as S.Schema<SnapshotPolicySchedulesList>;
+
+export interface SnapshotPolicySnapshotPolicySchedule {
+  createdAt?: string;
+  /** ID of the Schedule */
+  id?: string;
+  /** Interval of the Schedule (follows the cron schedule expression in Unix-like systems) */
+  interval?: string;
+  /** Name of the Schedule */
+  name?: string;
+  /** Prefix used for the snapshots created by this policy */
+  prefix?: string;
+  /** Retention Count */
+  retentionCount?: number;
+  /** Retention Period (ISO 8601 format or "infinite") */
+  retentionPeriod?: string;
+}
+export const SnapshotPolicySnapshotPolicySchedule = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    createdAt: S.optional(S.String),
+    id: S.optional(S.String),
+    interval: S.optional(S.String),
+    name: S.optional(S.String),
+    prefix: S.optional(S.String),
+    retentionCount: S.optional(S.Number),
+    retentionPeriod: S.optional(S.String),
+  }),
+).annotate({
+  identifier: "SnapshotPolicySnapshotPolicySchedule",
+}) as any as S.Schema<SnapshotPolicySnapshotPolicySchedule>;
+
+/** associated schedules */
+export type SnapshotPolicySnapshotSchedulesList = Array<SnapshotPolicySnapshotPolicySchedule>;
+export const SnapshotPolicySnapshotSchedulesList = /*@__PURE__*/ S.Array(
+  SnapshotPolicySnapshotPolicySchedule,
+) as any as S.Schema<SnapshotPolicySnapshotSchedulesList>;
+
+export interface SnapshotPolicy {
+  /** Comment of the Snapshot Policy */
+  comment?: string;
+  /** created at timestamp */
+  createdAt?: string;
+  /** Wether the Snapshot Policy is enabled */
+  enabled?: boolean;
+  /** ID of the Snapshot Policy */
+  id?: string;
+  /** Name of the Snapshot Policy */
+  name?: string;
+  /** (deprecated) associated schedules */
+  schedules?: SnapshotPolicySchedulesList;
+  /** associated schedules */
+  snapshotSchedules?: SnapshotPolicySnapshotSchedulesList;
+}
+export const SnapshotPolicy = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    comment: S.optional(S.String),
+    createdAt: S.optional(S.String),
+    enabled: S.optional(S.Boolean),
+    id: S.optional(S.String),
+    name: S.optional(S.String),
+    schedules: S.optional(SnapshotPolicySchedulesList),
+    snapshotSchedules: S.optional(SnapshotPolicySnapshotSchedulesList),
+  }),
+).annotate({ identifier: "SnapshotPolicy" }) as any as S.Schema<SnapshotPolicy>;
+
+export interface GetSnapshotPolicyResponse {
+  /** Snapshot Policy */
+  snapshotPolicy?: SnapshotPolicy;
+}
+export const GetSnapshotPolicyResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    snapshotPolicy: S.optional(SnapshotPolicy),
+  }),
+).annotate({
+  identifier: "GetSnapshotPolicyResponse",
+}) as any as S.Schema<GetSnapshotPolicyResponse>;
+
+export interface ListPerformanceClassesRequest {}
+export const ListPerformanceClassesRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/v1/resourcePoolPerformanceClasses",
+      code: 200,
+      baseUrl: "https://sfs.api.stackit.cloud",
+    }),
+  ),
+).annotate({
+  identifier: "ListPerformanceClassesRequest",
+}) as any as S.Schema<ListPerformanceClassesRequest>;
+
+export interface PerformanceClass {
+  /** IOPS of the Performance Class */
+  iops?: number;
+  /** Name of the Performance Class */
+  name?: string;
+  /** Throughput of the Performance Class */
+  throughput?: number;
+}
+export const PerformanceClass = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    iops: S.optional(S.Number),
+    name: S.optional(S.String),
+    throughput: S.optional(S.Number),
+  }),
+).annotate({ identifier: "PerformanceClass" }) as any as S.Schema<PerformanceClass>;
+
+/** List of Performance Classes */
+export type ListPerformanceClassesResponsePerformanceClassesList = Array<PerformanceClass>;
+export const ListPerformanceClassesResponsePerformanceClassesList = /*@__PURE__*/ S.Array(
+  PerformanceClass,
+) as any as S.Schema<ListPerformanceClassesResponsePerformanceClassesList>;
+
+export interface ListPerformanceClassesResponse {
+  /** List of Performance Classes */
+  performanceClasses?: ListPerformanceClassesResponsePerformanceClassesList;
+}
+export const ListPerformanceClassesResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    performanceClasses: S.optional(ListPerformanceClassesResponsePerformanceClassesList),
+  }),
+).annotate({
+  identifier: "ListPerformanceClassesResponse",
+}) as any as S.Schema<ListPerformanceClassesResponse>;
+
+export interface ListResourcePoolsRequest {
+  projectId: string;
+  region: string;
+}
+export const ListResourcePoolsRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    projectId: S.String.pipe(T.Label()),
+    region: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/v1/projects/{projectId}/regions/{region}/resourcePools",
+      code: 200,
+      baseUrl: "https://sfs.api.stackit.cloud",
+    }),
+  ),
+).annotate({ identifier: "ListResourcePoolsRequest" }) as any as S.Schema<ListResourcePoolsRequest>;
+
+/** List of Resource Pools */
+export type ListResourcePoolsResponseResourcePoolsList = Array<ResourcePool>;
+export const ListResourcePoolsResponseResourcePoolsList = /*@__PURE__*/ S.Array(
+  ResourcePool,
+) as any as S.Schema<ListResourcePoolsResponseResourcePoolsList>;
+
+export interface ListResourcePoolsResponse {
+  /** List of Resource Pools */
+  resourcePools?: ListResourcePoolsResponseResourcePoolsList;
+}
+export const ListResourcePoolsResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    resourcePools: S.optional(ListResourcePoolsResponseResourcePoolsList),
+  }),
+).annotate({
+  identifier: "ListResourcePoolsResponse",
+}) as any as S.Schema<ListResourcePoolsResponse>;
+
+export interface ListResourcePoolSnapshotsRequest {
+  projectId: string;
+  region: string;
+  resourcePoolId: string;
+}
+export const ListResourcePoolSnapshotsRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    projectId: S.String.pipe(T.Label()),
+    region: S.String.pipe(T.Label()),
+    resourcePoolId: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/v1/projects/{projectId}/regions/{region}/resourcePools/{resourcePoolId}/snapshots",
+      code: 200,
+      baseUrl: "https://sfs.api.stackit.cloud",
+    }),
+  ),
+).annotate({
+  identifier: "ListResourcePoolSnapshotsRequest",
+}) as any as S.Schema<ListResourcePoolSnapshotsRequest>;
+
+/** List of Resource Pool Snapshots */
+export type ListResourcePoolSnapshotsResponseResourcePoolSnapshotsList =
+  Array<ResourcePoolSnapshot>;
+export const ListResourcePoolSnapshotsResponseResourcePoolSnapshotsList = /*@__PURE__*/ S.Array(
+  ResourcePoolSnapshot,
+) as any as S.Schema<ListResourcePoolSnapshotsResponseResourcePoolSnapshotsList>;
+
+export interface ListResourcePoolSnapshotsResponse {
+  /** List of Resource Pool Snapshots */
+  resourcePoolSnapshots?: ListResourcePoolSnapshotsResponseResourcePoolSnapshotsList;
+}
+export const ListResourcePoolSnapshotsResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    resourcePoolSnapshots: S.optional(ListResourcePoolSnapshotsResponseResourcePoolSnapshotsList),
+  }),
+).annotate({
+  identifier: "ListResourcePoolSnapshotsResponse",
+}) as any as S.Schema<ListResourcePoolSnapshotsResponse>;
+
+export interface ListShareExportPoliciesRequest {
+  projectId: string;
+  region: string;
+}
+export const ListShareExportPoliciesRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    projectId: S.String.pipe(T.Label()),
+    region: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/v1/projects/{projectId}/regions/{region}/shareExportPolicies",
+      code: 200,
+      baseUrl: "https://sfs.api.stackit.cloud",
+    }),
+  ),
+).annotate({
+  identifier: "ListShareExportPoliciesRequest",
+}) as any as S.Schema<ListShareExportPoliciesRequest>;
+
+/** List of Share Export Policies */
+export type ListShareExportPoliciesResponseShareExportPoliciesList = Array<ShareExportPolicy>;
+export const ListShareExportPoliciesResponseShareExportPoliciesList = /*@__PURE__*/ S.Array(
+  ShareExportPolicy,
+) as any as S.Schema<ListShareExportPoliciesResponseShareExportPoliciesList>;
+
+export interface ListShareExportPoliciesResponse {
+  /** List of Share Export Policies */
+  shareExportPolicies?: ListShareExportPoliciesResponseShareExportPoliciesList;
+}
+export const ListShareExportPoliciesResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    shareExportPolicies: S.optional(ListShareExportPoliciesResponseShareExportPoliciesList),
+  }),
+).annotate({
+  identifier: "ListShareExportPoliciesResponse",
+}) as any as S.Schema<ListShareExportPoliciesResponse>;
+
+export interface ListSharesRequest {
+  projectId: string;
+  region: string;
+  resourcePoolId: string;
+}
+export const ListSharesRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    projectId: S.String.pipe(T.Label()),
+    region: S.String.pipe(T.Label()),
+    resourcePoolId: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/v1/projects/{projectId}/regions/{region}/resourcePools/{resourcePoolId}/shares",
+      code: 200,
+      baseUrl: "https://sfs.api.stackit.cloud",
+    }),
+  ),
+).annotate({ identifier: "ListSharesRequest" }) as any as S.Schema<ListSharesRequest>;
+
+/** List of Shares */
+export type ListSharesResponseSharesList = Array<Share>;
+export const ListSharesResponseSharesList = /*@__PURE__*/ S.Array(
+  Share,
+) as any as S.Schema<ListSharesResponseSharesList>;
+
+export interface ListSharesResponse {
+  /** List of Shares */
+  shares?: ListSharesResponseSharesList;
+}
+export const ListSharesResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    shares: S.optional(ListSharesResponseSharesList),
+  }),
+).annotate({ identifier: "ListSharesResponse" }) as any as S.Schema<ListSharesResponse>;
+
+export interface ListSnapshotPoliciesRequest {
+  projectId: string;
+  immutable?: boolean;
+}
+export const ListSnapshotPoliciesRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    projectId: S.String.pipe(T.Label()),
+    immutable: S.optional(S.Boolean.pipe(T.Query())),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/v1/projects/{projectId}/snapshotPolicies",
+      code: 200,
+      baseUrl: "https://sfs.api.stackit.cloud",
+    }),
+  ),
+).annotate({
+  identifier: "ListSnapshotPoliciesRequest",
+}) as any as S.Schema<ListSnapshotPoliciesRequest>;
+
+/** List of Snapshot Policies */
+export type ListSnapshotPoliciesResponseSnapshotPoliciesList = Array<SnapshotPolicy>;
+export const ListSnapshotPoliciesResponseSnapshotPoliciesList = /*@__PURE__*/ S.Array(
+  SnapshotPolicy,
+) as any as S.Schema<ListSnapshotPoliciesResponseSnapshotPoliciesList>;
+
+export interface ListSnapshotPoliciesResponse {
+  /** List of Snapshot Policies */
+  snapshotPolicies?: ListSnapshotPoliciesResponseSnapshotPoliciesList;
+}
+export const ListSnapshotPoliciesResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    snapshotPolicies: S.optional(ListSnapshotPoliciesResponseSnapshotPoliciesList),
+  }),
+).annotate({
+  identifier: "ListSnapshotPoliciesResponse",
+}) as any as S.Schema<ListSnapshotPoliciesResponse>;
+
+/** (optional) List of IPs that can mount the Resource Pool in read-only; IPs must have a subnet mask (e.g. "172.16.0.0/24" for a range of IPs, or "172.16.0.250/32" for a specific IP) */
+export type UpdateResourcePoolRequestIpAclList = Array<string>;
+export const UpdateResourcePoolRequestIpAclList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<UpdateResourcePoolRequestIpAclList>;
+
+/** An optional object that represents the labels associated with the resource pool. */
+export type UpdateResourcePoolRequestLabelsMap = { [key: string]: string | undefined };
+export const UpdateResourcePoolRequestLabelsMap = /*@__PURE__*/ S.Record(
+  S.String,
+  S.String,
+) as any as S.Schema<UpdateResourcePoolRequestLabelsMap>;
+
+export interface UpdateResourcePoolRequest {
+  projectId: string;
+  region: string;
+  resourcePoolId: string;
+  /** (optional) List of IPs that can mount the Resource Pool in read-only; IPs must have a subnet mask (e.g. "172.16.0.0/24" for a range of IPs, or "172.16.0.250/32" for a specific IP) */
+  ipAcl?: UpdateResourcePoolRequestIpAclList;
+  /** An optional object that represents the labels associated with the resource pool. */
+  labels?: UpdateResourcePoolRequestLabelsMap;
+  /** (optional) Name of the performance class */
+  performanceClass?: string;
+  /** (optional) Size of the Resource Pool (unit: gigabytes) */
+  sizeGigabytes?: number | null;
+  /** (optional) Id of the Snapshot Policy to use If not set, the Snapshot Policy is not updated If set to an empty string, the Snapshot Policy is removed */
+  snapshotPolicyId?: string | null;
+  /** Whether the .snapshot directory is visible when mounting the resource pool. Setting this value to false might prevent you from accessing the snapshots (e.g. for security reasons). Additionally, the access to the snapshots is always controlled by the export policy of the resource pool. That means, if snapshots are visible and the export policy allows for reading the resource pool, then it also allows reading the snapshot of all shares. */
+  snapshotsAreVisible?: boolean;
+}
+export const UpdateResourcePoolRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    projectId: S.String.pipe(T.Label()),
+    region: S.String.pipe(T.Label()),
+    resourcePoolId: S.String.pipe(T.Label()),
+    ipAcl: S.optional(UpdateResourcePoolRequestIpAclList),
+    labels: S.optional(UpdateResourcePoolRequestLabelsMap),
+    performanceClass: S.optional(S.String),
+    sizeGigabytes: S.optional(S.NullOr(S.Number)),
+    snapshotPolicyId: S.optional(S.NullOr(S.String)),
+    snapshotsAreVisible: S.optional(S.Boolean),
+  }).pipe(
+    T.Http({
+      method: "PATCH",
+      uri: "/v1/projects/{projectId}/regions/{region}/resourcePools/{resourcePoolId}",
+      code: 200,
+      baseUrl: "https://sfs.api.stackit.cloud",
+    }),
+  ),
+).annotate({
+  identifier: "UpdateResourcePoolRequest",
+}) as any as S.Schema<UpdateResourcePoolRequest>;
+
+export interface UpdateResourcePoolResponse {
+  /** Updated Resource Pool */
+  resourcePool?: ResourcePool;
+}
+export const UpdateResourcePoolResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    resourcePool: S.optional(ResourcePool),
+  }),
+).annotate({
+  identifier: "UpdateResourcePoolResponse",
+}) as any as S.Schema<UpdateResourcePoolResponse>;
+
+export interface UpdateResourcePoolSnapshotRequest {
+  projectId: string;
+  region: string;
+  resourcePoolId: string;
+  snapshotName: string;
+  /** (optional) A comment to add more information about a snapshot */
+  comment?: string | null;
+  /** (optional) name of the Resource Pool Snapshot */
+  name?: string | null;
+}
+export const UpdateResourcePoolSnapshotRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    projectId: S.String.pipe(T.Label()),
+    region: S.String.pipe(T.Label()),
+    resourcePoolId: S.String.pipe(T.Label()),
+    snapshotName: S.String.pipe(T.Label()),
+    comment: S.optional(S.NullOr(S.String)),
+    name: S.optional(S.NullOr(S.String)),
+  }).pipe(
+    T.Http({
+      method: "PATCH",
+      uri: "/v1/projects/{projectId}/regions/{region}/resourcePools/{resourcePoolId}/snapshots/{snapshotName}",
+      code: 200,
+      baseUrl: "https://sfs.api.stackit.cloud",
+    }),
+  ),
+).annotate({
+  identifier: "UpdateResourcePoolSnapshotRequest",
+}) as any as S.Schema<UpdateResourcePoolSnapshotRequest>;
+
+export interface UpdateResourcePoolSnapshotResponse {
+  /** Updated Resource Pool Snapshot */
+  resourcePoolSnapshot?: ResourcePoolSnapshot;
+}
+export const UpdateResourcePoolSnapshotResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    resourcePoolSnapshot: S.optional(ResourcePoolSnapshot),
+  }),
+).annotate({
+  identifier: "UpdateResourcePoolSnapshotResponse",
+}) as any as S.Schema<UpdateResourcePoolSnapshotResponse>;
+
+/** An optional object that represents the labels associated with the share. */
+export type UpdateShareRequestLabelsMap = { [key: string]: string | undefined };
+export const UpdateShareRequestLabelsMap = /*@__PURE__*/ S.Record(
+  S.String,
+  S.String,
+) as any as S.Schema<UpdateShareRequestLabelsMap>;
+
+export interface UpdateShareRequest {
+  projectId: string;
+  region: string;
+  resourcePoolId: string;
+  shareId: string;
+  /** Name of the Share Export Policy to use in the Share. The behavior depends on the value: - If not set (null): Keep the existing export policy (if any) - If set to empty string (""): Remove the existing export policy - If set to a policy name: Update to use the specified policy, creating a new association if none exists */
+  exportPolicyName?: string | null;
+  /** An optional object that represents the labels associated with the share. */
+  labels?: UpdateShareRequestLabelsMap;
+  /** Space hard limit for the Share. If zero, the Share will have access to the full space of the Resource Pool it lives in. (unit: gibibytes) */
+  spaceHardLimitGigabytes?: number | null;
+}
+export const UpdateShareRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    projectId: S.String.pipe(T.Label()),
+    region: S.String.pipe(T.Label()),
+    resourcePoolId: S.String.pipe(T.Label()),
+    shareId: S.String.pipe(T.Label()),
+    exportPolicyName: S.optional(S.NullOr(S.String)),
+    labels: S.optional(UpdateShareRequestLabelsMap),
+    spaceHardLimitGigabytes: S.optional(S.NullOr(S.Number)),
+  }).pipe(
+    T.Http({
+      method: "PATCH",
+      uri: "/v1/projects/{projectId}/regions/{region}/resourcePools/{resourcePoolId}/shares/{shareId}",
+      code: 200,
+      baseUrl: "https://sfs.api.stackit.cloud",
+    }),
+  ),
+).annotate({ identifier: "UpdateShareRequest" }) as any as S.Schema<UpdateShareRequest>;
+
+export interface UpdateShareResponse {
+  /** Updated Share */
+  share?: Share;
+}
+export const UpdateShareResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    share: S.optional(Share),
+  }),
+).annotate({ identifier: "UpdateShareResponse" }) as any as S.Schema<UpdateShareResponse>;
+
+/** An optional object that represents the labels associated with the share export policy. */
+export type UpdateShareExportPolicyRequestLabelsMap = { [key: string]: string | undefined };
+export const UpdateShareExportPolicyRequestLabelsMap = /*@__PURE__*/ S.Record(
+  S.String,
+  S.String,
+) as any as S.Schema<UpdateShareExportPolicyRequestLabelsMap>;
+
+/** IP access control list, where IPs must have a subnet mask (e.g. "172.16.0.0/24" for a range of IPs, or "172.16.0.250/32" for a specific IP) This array cannot be empty */
+export type UpdateShareExportPolicyBodyRuleIpAclList = Array<string>;
+export const UpdateShareExportPolicyBodyRuleIpAclList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<UpdateShareExportPolicyBodyRuleIpAclList>;
+
+export interface UpdateShareExportPolicyBodyRule {
+  /** Description of the Rule (optional) */
+  description?: string | null;
+  /** IP access control list, where IPs must have a subnet mask (e.g. "172.16.0.0/24" for a range of IPs, or "172.16.0.250/32" for a specific IP) This array cannot be empty */
+  ipAcl?: UpdateShareExportPolicyBodyRuleIpAclList;
+  /** Order of the rule within a Share Export Policy. The order is used so that when a client IP matches multiple rules, the first rule is applied This field must be set */
+  order?: number;
+  /** Flag to indicate if client IPs matching this rule can only mount the share in read only mode Default: false */
+  readOnly?: boolean;
+  /** Flag to honor set UUID Default: false */
+  setUuid?: boolean;
+  /** Flag to indicate if client IPs matching this rule have root access on the Share Default: true */
+  superUser?: boolean;
+}
+export const UpdateShareExportPolicyBodyRule = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    description: S.optional(S.NullOr(S.String)),
+    ipAcl: S.optional(UpdateShareExportPolicyBodyRuleIpAclList),
+    order: S.optional(S.Number),
+    readOnly: S.optional(S.Boolean),
+    setUuid: S.optional(S.Boolean),
+    superUser: S.optional(S.Boolean),
+  }),
+).annotate({
+  identifier: "UpdateShareExportPolicyBodyRule",
+}) as any as S.Schema<UpdateShareExportPolicyBodyRule>;
+
+/** List of rules of the Share Export Policy. The order of the rules within the array does not matter - what matters is the field "order" within each rule. The whole set of rules needs to be sent in the same request, e.g. if 1 rule is sent, the share export policy will have just that 1 rule, as opposed to extending the existing set of rules with the 1 rule that was sent Important note: the array of rules passed always overwrites the rule array (i.e. sending an empty array removes all rules) */
+export type UpdateShareExportPolicyRequestRulesList = Array<UpdateShareExportPolicyBodyRule>;
+export const UpdateShareExportPolicyRequestRulesList = /*@__PURE__*/ S.Array(
+  UpdateShareExportPolicyBodyRule,
+) as any as S.Schema<UpdateShareExportPolicyRequestRulesList>;
+
+export interface UpdateShareExportPolicyRequest {
+  projectId: string;
+  region: string;
+  policyId: string;
+  /** An optional object that represents the labels associated with the share export policy. */
+  labels?: UpdateShareExportPolicyRequestLabelsMap;
+  /** List of rules of the Share Export Policy. The order of the rules within the array does not matter - what matters is the field "order" within each rule. The whole set of rules needs to be sent in the same request, e.g. if 1 rule is sent, the share export policy will have just that 1 rule, as opposed to extending the existing set of rules with the 1 rule that was sent Important note: the array of rules passed always overwrites the rule array (i.e. sending an empty array removes all rules) */
+  rules?: UpdateShareExportPolicyRequestRulesList | null;
+}
+export const UpdateShareExportPolicyRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    projectId: S.String.pipe(T.Label()),
+    region: S.String.pipe(T.Label()),
+    policyId: S.String.pipe(T.Label()),
+    labels: S.optional(UpdateShareExportPolicyRequestLabelsMap),
+    rules: S.optional(S.NullOr(UpdateShareExportPolicyRequestRulesList)),
+  }).pipe(
+    T.Http({
+      method: "PATCH",
+      uri: "/v1/projects/{projectId}/regions/{region}/shareExportPolicies/{policyId}",
+      code: 200,
+      baseUrl: "https://sfs.api.stackit.cloud",
+    }),
+  ),
+).annotate({
+  identifier: "UpdateShareExportPolicyRequest",
+}) as any as S.Schema<UpdateShareExportPolicyRequest>;
+
+export interface UpdateShareExportPolicyResponse {
+  shareExportPolicy?: ShareExportPolicy;
+}
+export const UpdateShareExportPolicyResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    shareExportPolicy: S.optional(ShareExportPolicy),
+  }),
+).annotate({
+  identifier: "UpdateShareExportPolicyResponse",
+}) as any as S.Schema<UpdateShareExportPolicyResponse>;
+
+export type CreateResourcePoolError = BadRequest | StackitOpError;
+/** Create Resource Pool Create a Resource Pool in a project. */
+export const createResourcePool: API.OperationMethod<
+  CreateResourcePoolRequest,
+  CreateResourcePoolResponse,
+  CreateResourcePoolError,
+  StackitOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateResourcePoolRequest,
+  output: CreateResourcePoolResponse,
+  errors: [BadRequest, UnknownStackitError],
+  protocol: StackitProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateResourcePoolSnapshotError = BadRequest | StackitOpError;
+/** Create Resource Pool Snapshot Creates a Snapshot of a Resource Pool in a project. */
+export const createResourcePoolSnapshot: API.OperationMethod<
+  CreateResourcePoolSnapshotRequest,
+  CreateResourcePoolSnapshotResponse,
+  CreateResourcePoolSnapshotError,
+  StackitOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateResourcePoolSnapshotRequest,
+  output: CreateResourcePoolSnapshotResponse,
+  errors: [BadRequest, UnknownStackitError],
+  protocol: StackitProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateShareError = BadRequest | StackitOpError;
+/** Create Share Creates a Share in a Resource Pool in a project. */
+export const createShare: API.OperationMethod<
+  CreateShareRequest,
+  CreateShareResponse,
+  CreateShareError,
+  StackitOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateShareRequest,
+  output: CreateShareResponse,
+  errors: [BadRequest, UnknownStackitError],
+  protocol: StackitProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateShareExportPolicyError = BadRequest | StackitOpError;
+/** Create Share Export Policy Creates a ShareExportPolicy in a Resource Pool in a project. */
+export const createShareExportPolicy: API.OperationMethod<
+  CreateShareExportPolicyRequest,
+  CreateShareExportPolicyResponse,
+  CreateShareExportPolicyError,
+  StackitOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateShareExportPolicyRequest,
+  output: CreateShareExportPolicyResponse,
+  errors: [BadRequest, UnknownStackitError],
+  protocol: StackitProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteResourcePoolError = BadRequest | StackitOpError;
+/** Delete Resource Pool Deletes a Resource Pool in a project. */
+export const deleteResourcePool: API.OperationMethod<
+  DeleteResourcePoolRequest,
+  DeleteResourcePoolResponse2,
+  DeleteResourcePoolError,
+  StackitOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteResourcePoolRequest,
+  output: DeleteResourcePoolResponse2,
+  errors: [BadRequest, UnknownStackitError],
+  protocol: StackitProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteResourcePoolSnapshotError = BadRequest | StackitOpError;
+/** Delete Resource Pool Snapshot Deletes a Snapshot from a Resource Pool in a project. */
+export const deleteResourcePoolSnapshot: API.OperationMethod<
+  DeleteResourcePoolSnapshotRequest,
+  DeleteResourcePoolSnapshotResponse2,
+  DeleteResourcePoolSnapshotError,
+  StackitOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteResourcePoolSnapshotRequest,
+  output: DeleteResourcePoolSnapshotResponse2,
+  errors: [BadRequest, UnknownStackitError],
+  protocol: StackitProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteShareError = BadRequest | StackitOpError;
+/** Delete Share Deletes a Shares in a Resource Pool in a project. */
+export const deleteShare: API.OperationMethod<
+  DeleteShareRequest,
+  DeleteShareResponse2,
+  DeleteShareError,
+  StackitOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteShareRequest,
+  output: DeleteShareResponse2,
+  errors: [BadRequest, UnknownStackitError],
+  protocol: StackitProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteShareExportPolicyError = BadRequest | StackitOpError;
+/** Delete Share Export Policy Deletes a ShareExportPolicies in a Resource Pool in a project. */
+export const deleteShareExportPolicy: API.OperationMethod<
+  DeleteShareExportPolicyRequest,
+  DeleteShareExportPolicyResponse2,
+  DeleteShareExportPolicyError,
+  StackitOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteShareExportPolicyRequest,
+  output: DeleteShareExportPolicyResponse2,
+  errors: [BadRequest, UnknownStackitError],
+  protocol: StackitProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DisableLockError = StackitOpError;
+/** Clean up locks for a project so that it can be deleted successfully. */
+export const disableLock: API.OperationMethod<
+  DisableLockRequest,
+  DisableLockResponse2,
+  DisableLockError,
+  StackitOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DisableLockRequest,
+  output: DisableLockResponse2,
+  errors: [UnknownStackitError],
+  protocol: StackitProtocol,
+  retry: Retry.Retry,
+}));
+
+export type EnableLockError = StackitOpError;
+/** Enable Lock for a project. Necessary for immutable snapshots and to prevent accidental deletion of resources. */
+export const enableLock: API.OperationMethod<
+  EnableLockRequest,
+  EnableLockResponse,
+  EnableLockError,
+  StackitOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: EnableLockRequest,
+  output: EnableLockResponse,
+  errors: [UnknownStackitError],
+  protocol: StackitProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetLockError = StackitOpError;
+/** Get lock status for a project. */
+export const getLock: API.OperationMethod<
+  GetLockRequest,
+  GetLockResponse,
+  GetLockError,
+  StackitOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetLockRequest,
+  output: GetLockResponse,
+  errors: [UnknownStackitError],
+  protocol: StackitProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetResourcePoolError = BadRequest | StackitOpError;
+/** Get Resource Pool Retrieves a Resource Pool in a project. */
+export const getResourcePool: API.OperationMethod<
+  GetResourcePoolRequest,
+  GetResourcePoolResponse,
+  GetResourcePoolError,
+  StackitOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetResourcePoolRequest,
+  output: GetResourcePoolResponse,
+  errors: [BadRequest, UnknownStackitError],
+  protocol: StackitProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetResourcePoolSnapshotError = BadRequest | StackitOpError;
+/** Get Resource Pool Snapshot Retrieves a Snapshot from a Resource Pool in a project. */
+export const getResourcePoolSnapshot: API.OperationMethod<
+  GetResourcePoolSnapshotRequest,
+  GetResourcePoolSnapshotResponse,
+  GetResourcePoolSnapshotError,
+  StackitOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetResourcePoolSnapshotRequest,
+  output: GetResourcePoolSnapshotResponse,
+  errors: [BadRequest, UnknownStackitError],
+  protocol: StackitProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetShareError = BadRequest | StackitOpError;
+/** Get Share Retrieves a Shares in a Resource Pool in a project. */
+export const getShare: API.OperationMethod<
+  GetShareRequest,
+  GetShareResponse,
+  GetShareError,
+  StackitOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetShareRequest,
+  output: GetShareResponse,
+  errors: [BadRequest, UnknownStackitError],
+  protocol: StackitProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetShareExportPolicyError = BadRequest | StackitOpError;
+/** Get Share Export Policy Retrieves a ShareExportPolicies in a Resource Pool in a project. */
+export const getShareExportPolicy: API.OperationMethod<
+  GetShareExportPolicyRequest,
+  GetShareExportPolicyResponse,
+  GetShareExportPolicyError,
+  StackitOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetShareExportPolicyRequest,
+  output: GetShareExportPolicyResponse,
+  errors: [BadRequest, UnknownStackitError],
+  protocol: StackitProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetSnapshotPolicyError = StackitOpError;
+/** Get Snapshot Policy */
+export const getSnapshotPolicy: API.OperationMethod<
+  GetSnapshotPolicyRequest,
+  GetSnapshotPolicyResponse,
+  GetSnapshotPolicyError,
+  StackitOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetSnapshotPolicyRequest,
+  output: GetSnapshotPolicyResponse,
+  errors: [UnknownStackitError],
+  protocol: StackitProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListPerformanceClassesError = BadRequest | StackitOpError;
+/** List Resource Performance Classes Lists all performances classes available */
+export const listPerformanceClasses: API.OperationMethod<
+  ListPerformanceClassesRequest,
+  ListPerformanceClassesResponse,
+  ListPerformanceClassesError,
+  StackitOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListPerformanceClassesRequest,
+  output: ListPerformanceClassesResponse,
+  errors: [BadRequest, UnknownStackitError],
+  protocol: StackitProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListResourcePoolsError = BadRequest | StackitOpError;
+/** List Resource Pools Lists Resource Pools in a project. */
+export const listResourcePools: API.OperationMethod<
+  ListResourcePoolsRequest,
+  ListResourcePoolsResponse,
+  ListResourcePoolsError,
+  StackitOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListResourcePoolsRequest,
+  output: ListResourcePoolsResponse,
+  errors: [BadRequest, UnknownStackitError],
+  protocol: StackitProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListResourcePoolSnapshotsError = BadRequest | StackitOpError;
+/** List Resource Pool Snapshots Lists the Snapshots of a Resource Pool in a project. */
+export const listResourcePoolSnapshots: API.OperationMethod<
+  ListResourcePoolSnapshotsRequest,
+  ListResourcePoolSnapshotsResponse,
+  ListResourcePoolSnapshotsError,
+  StackitOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListResourcePoolSnapshotsRequest,
+  output: ListResourcePoolSnapshotsResponse,
+  errors: [BadRequest, UnknownStackitError],
+  protocol: StackitProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListShareExportPoliciesError = BadRequest | StackitOpError;
+/** List Share Export Policies Lists ShareExportPolicies in a Resource Pool in a project. */
+export const listShareExportPolicies: API.OperationMethod<
+  ListShareExportPoliciesRequest,
+  ListShareExportPoliciesResponse,
+  ListShareExportPoliciesError,
+  StackitOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListShareExportPoliciesRequest,
+  output: ListShareExportPoliciesResponse,
+  errors: [BadRequest, UnknownStackitError],
+  protocol: StackitProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListSharesError = BadRequest | StackitOpError;
+/** List Shares Lists Shares in a Resource Pool in a project. */
+export const listShares: API.OperationMethod<
+  ListSharesRequest,
+  ListSharesResponse,
+  ListSharesError,
+  StackitOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListSharesRequest,
+  output: ListSharesResponse,
+  errors: [BadRequest, UnknownStackitError],
+  protocol: StackitProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListSnapshotPoliciesError = StackitOpError;
+/** List Snapshot Policies */
+export const listSnapshotPolicies: API.OperationMethod<
+  ListSnapshotPoliciesRequest,
+  ListSnapshotPoliciesResponse,
+  ListSnapshotPoliciesError,
+  StackitOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListSnapshotPoliciesRequest,
+  output: ListSnapshotPoliciesResponse,
+  errors: [UnknownStackitError],
+  protocol: StackitProtocol,
+  retry: Retry.Retry,
+}));
+
+export type UpdateResourcePoolError = BadRequest | StackitOpError;
+/** Update Resource Pool Updates a Resource Pool in a project. */
+export const updateResourcePool: API.OperationMethod<
+  UpdateResourcePoolRequest,
+  UpdateResourcePoolResponse,
+  UpdateResourcePoolError,
+  StackitOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: UpdateResourcePoolRequest,
+  output: UpdateResourcePoolResponse,
+  errors: [BadRequest, UnknownStackitError],
+  protocol: StackitProtocol,
+  retry: Retry.Retry,
+}));
+
+export type UpdateResourcePoolSnapshotError = BadRequest | StackitOpError;
+/** Update Resource Pool Snapshot Updates a Snapshot from a Resource Pool in a project. */
+export const updateResourcePoolSnapshot: API.OperationMethod<
+  UpdateResourcePoolSnapshotRequest,
+  UpdateResourcePoolSnapshotResponse,
+  UpdateResourcePoolSnapshotError,
+  StackitOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: UpdateResourcePoolSnapshotRequest,
+  output: UpdateResourcePoolSnapshotResponse,
+  errors: [BadRequest, UnknownStackitError],
+  protocol: StackitProtocol,
+  retry: Retry.Retry,
+}));
+
+export type UpdateShareError = BadRequest | StackitOpError;
+/** Update Share Updates a Shares in a Resource Pool in a project. */
+export const updateShare: API.OperationMethod<
+  UpdateShareRequest,
+  UpdateShareResponse,
+  UpdateShareError,
+  StackitOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: UpdateShareRequest,
+  output: UpdateShareResponse,
+  errors: [BadRequest, UnknownStackitError],
+  protocol: StackitProtocol,
+  retry: Retry.Retry,
+}));
+
+export type UpdateShareExportPolicyError = BadRequest | StackitOpError;
+/** Update Share Export Policy Updates a ShareExportPolicies in a Resource Pool in a project. */
+export const updateShareExportPolicy: API.OperationMethod<
+  UpdateShareExportPolicyRequest,
+  UpdateShareExportPolicyResponse,
+  UpdateShareExportPolicyError,
+  StackitOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: UpdateShareExportPolicyRequest,
+  output: UpdateShareExportPolicyResponse,
+  errors: [BadRequest, UnknownStackitError],
+  protocol: StackitProtocol,
+  retry: Retry.Retry,
+}));