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

package/lib/services/sfs.d.ts

@@ -0,0 +1,721 @@
+import * as API from "@distilled.cloud/core/api";
+import * as S from "@distilled.cloud/core/schema";
+import { type StackitOpError, type StackitOpContext } from "../protocol.ts";
+export type { StackitOpError, StackitOpContext };
+declare const BadRequest_base: S.Class<BadRequest, S.TaggedStruct<"BadRequest", {
+    readonly code: any;
+    readonly message: any;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        BadRequestError: true;
+    };
+});
+export declare class BadRequest extends /*@__PURE__*/ BadRequest_base {
+}
+/** 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 declare const CreateResourcePoolRequestIpAclList: S.Schema<CreateResourcePoolRequestIpAclList>;
+/** An optional object that represents the labels associated with the resource pool. */
+export type CreateResourcePoolRequestLabelsMap = {
+    [key: string]: string | undefined;
+};
+export declare const CreateResourcePoolRequestLabelsMap: 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 declare const CreateResourcePoolRequest: 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 declare const ResourcePoolIpAclList: S.Schema<ResourcePoolIpAclList>;
+export type ResourcePoolLabelsMap = {
+    [key: string]: string | undefined;
+};
+export declare const ResourcePoolLabelsMap: 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 declare const ResourcePoolPerformanceClass: S.Schema<ResourcePoolPerformanceClass>;
+export interface ResourcePoolSnapshotPolicy {
+    /** ID of the Snapshot Policy */
+    id?: string;
+    /** Name of the Snapshot Policy */
+    name?: string;
+}
+export declare const ResourcePoolSnapshotPolicy: 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 declare const ResourcePoolSpace: 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 declare const ResourcePool: S.Schema<ResourcePool>;
+export interface CreateResourcePoolResponse {
+    /** Created Resource Pool */
+    resourcePool?: ResourcePool;
+}
+export declare const CreateResourcePoolResponse: 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 declare const CreateResourcePoolSnapshotRequest: 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 declare const ResourcePoolSnapshot: S.Schema<ResourcePoolSnapshot>;
+export interface CreateResourcePoolSnapshotResponse {
+    /** Created Resource Pool Snapshot */
+    resourcePoolSnapshot?: ResourcePoolSnapshot;
+}
+export declare const CreateResourcePoolSnapshotResponse: S.Schema<CreateResourcePoolSnapshotResponse>;
+/** An optional object that represents the labels associated with the share. */
+export type CreateShareRequestLabelsMap = {
+    [key: string]: string | undefined;
+};
+export declare const CreateShareRequestLabelsMap: 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 declare const CreateShareRequest: S.Schema<CreateShareRequest>;
+/** An optional object that represents the labels associated with the share export policy. */
+export type ShareExportPolicyLabelsMap = {
+    [key: string]: string | undefined;
+};
+export declare const ShareExportPolicyLabelsMap: 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 declare const ShareExportPolicyRuleIpAclList: 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 declare const ShareExportPolicyRule: 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 declare const ShareExportPolicyRulesList: 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 declare const ShareExportPolicy: S.Schema<ShareExportPolicy>;
+/** An optional object that represents the labels associated with the share. */
+export type ShareLabelsMap = {
+    [key: string]: string | undefined;
+};
+export declare const ShareLabelsMap: 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 declare const Share: S.Schema<Share>;
+export interface CreateShareResponse {
+    /** Created Share */
+    share?: Share;
+}
+export declare const CreateShareResponse: S.Schema<CreateShareResponse>;
+/** An optional object that represents the labels associated with the share export policy. */
+export type CreateShareExportPolicyRequestLabelsMap = {
+    [key: string]: string | undefined;
+};
+export declare const CreateShareExportPolicyRequestLabelsMap: 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 declare const CreateShareExportPolicyRequestRuleIpAclList: 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 declare const CreateShareExportPolicyRequestRule: 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 declare const CreateShareExportPolicyRequestRulesList: 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 declare const CreateShareExportPolicyRequest: S.Schema<CreateShareExportPolicyRequest>;
+export interface CreateShareExportPolicyResponse {
+    /** Created Share Export Policy */
+    shareExportPolicy?: ShareExportPolicy;
+}
+export declare const CreateShareExportPolicyResponse: S.Schema<CreateShareExportPolicyResponse>;
+export interface DeleteResourcePoolRequest {
+    projectId: string;
+    region: string;
+    resourcePoolId: string;
+}
+export declare const DeleteResourcePoolRequest: S.Schema<DeleteResourcePoolRequest>;
+export type DeleteResourcePoolResponse2 = unknown;
+export declare const DeleteResourcePoolResponse2: S.Schema<DeleteResourcePoolResponse2>;
+export interface DeleteResourcePoolSnapshotRequest {
+    projectId: string;
+    region: string;
+    resourcePoolId: string;
+    snapshotName: string;
+}
+export declare const DeleteResourcePoolSnapshotRequest: S.Schema<DeleteResourcePoolSnapshotRequest>;
+export type DeleteResourcePoolSnapshotResponse2 = unknown;
+export declare const DeleteResourcePoolSnapshotResponse2: S.Schema<DeleteResourcePoolSnapshotResponse2>;
+export interface DeleteShareRequest {
+    projectId: string;
+    region: string;
+    resourcePoolId: string;
+    shareId: string;
+}
+export declare const DeleteShareRequest: S.Schema<DeleteShareRequest>;
+export type DeleteShareResponse2 = unknown;
+export declare const DeleteShareResponse2: S.Schema<DeleteShareResponse2>;
+export interface DeleteShareExportPolicyRequest {
+    projectId: string;
+    region: string;
+    policyId: string;
+}
+export declare const DeleteShareExportPolicyRequest: S.Schema<DeleteShareExportPolicyRequest>;
+export type DeleteShareExportPolicyResponse2 = unknown;
+export declare const DeleteShareExportPolicyResponse2: S.Schema<DeleteShareExportPolicyResponse2>;
+export interface DisableLockRequest {
+    region: string;
+    projectId: string;
+}
+export declare const DisableLockRequest: S.Schema<DisableLockRequest>;
+export type DisableLockResponse2 = unknown;
+export declare const DisableLockResponse2: S.Schema<DisableLockResponse2>;
+export interface EnableLockRequest {
+    region: string;
+    projectId: string;
+}
+export declare const EnableLockRequest: S.Schema<EnableLockRequest>;
+export interface EnableLockResponse {
+    lockId?: string;
+}
+export declare const EnableLockResponse: S.Schema<EnableLockResponse>;
+export interface GetLockRequest {
+    region: string;
+    projectId: string;
+}
+export declare const GetLockRequest: S.Schema<GetLockRequest>;
+export interface GetLockResponse {
+    lockId?: string;
+}
+export declare const GetLockResponse: S.Schema<GetLockResponse>;
+export interface GetResourcePoolRequest {
+    projectId: string;
+    region: string;
+    resourcePoolId: string;
+}
+export declare const GetResourcePoolRequest: S.Schema<GetResourcePoolRequest>;
+export interface GetResourcePoolResponse {
+    /** Resource Pool */
+    resourcePool?: ResourcePool;
+}
+export declare const GetResourcePoolResponse: S.Schema<GetResourcePoolResponse>;
+export interface GetResourcePoolSnapshotRequest {
+    projectId: string;
+    region: string;
+    resourcePoolId: string;
+    snapshotName: string;
+}
+export declare const GetResourcePoolSnapshotRequest: S.Schema<GetResourcePoolSnapshotRequest>;
+export interface GetResourcePoolSnapshotResponse {
+    /** Resource Pool Snapshot */
+    resourcePoolSnapshot?: ResourcePoolSnapshot;
+}
+export declare const GetResourcePoolSnapshotResponse: S.Schema<GetResourcePoolSnapshotResponse>;
+export interface GetShareRequest {
+    projectId: string;
+    region: string;
+    resourcePoolId: string;
+    shareId: string;
+}
+export declare const GetShareRequest: S.Schema<GetShareRequest>;
+export interface GetShareResponse {
+    /** Share */
+    share?: Share;
+}
+export declare const GetShareResponse: S.Schema<GetShareResponse>;
+export interface GetShareExportPolicyRequest {
+    projectId: string;
+    region: string;
+    policyId: string;
+}
+export declare const GetShareExportPolicyRequest: S.Schema<GetShareExportPolicyRequest>;
+export interface GetShareExportPolicyResponse {
+    /** Share Export Policies */
+    shareExportPolicy?: ShareExportPolicy;
+}
+export declare const GetShareExportPolicyResponse: S.Schema<GetShareExportPolicyResponse>;
+export interface GetSnapshotPolicyRequest {
+    projectId: string;
+    id: string;
+}
+export declare const GetSnapshotPolicyRequest: 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 declare const SnapshotPolicySchedule: S.Schema<SnapshotPolicySchedule>;
+/** (deprecated) associated schedules */
+export type SnapshotPolicySchedulesList = Array<SnapshotPolicySchedule>;
+export declare const SnapshotPolicySchedulesList: 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 declare const SnapshotPolicySnapshotPolicySchedule: S.Schema<SnapshotPolicySnapshotPolicySchedule>;
+/** associated schedules */
+export type SnapshotPolicySnapshotSchedulesList = Array<SnapshotPolicySnapshotPolicySchedule>;
+export declare const SnapshotPolicySnapshotSchedulesList: 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 declare const SnapshotPolicy: S.Schema<SnapshotPolicy>;
+export interface GetSnapshotPolicyResponse {
+    /** Snapshot Policy */
+    snapshotPolicy?: SnapshotPolicy;
+}
+export declare const GetSnapshotPolicyResponse: S.Schema<GetSnapshotPolicyResponse>;
+export interface ListPerformanceClassesRequest {
+}
+export declare const ListPerformanceClassesRequest: 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 declare const PerformanceClass: S.Schema<PerformanceClass>;
+/** List of Performance Classes */
+export type ListPerformanceClassesResponsePerformanceClassesList = Array<PerformanceClass>;
+export declare const ListPerformanceClassesResponsePerformanceClassesList: S.Schema<ListPerformanceClassesResponsePerformanceClassesList>;
+export interface ListPerformanceClassesResponse {
+    /** List of Performance Classes */
+    performanceClasses?: ListPerformanceClassesResponsePerformanceClassesList;
+}
+export declare const ListPerformanceClassesResponse: S.Schema<ListPerformanceClassesResponse>;
+export interface ListResourcePoolsRequest {
+    projectId: string;
+    region: string;
+}
+export declare const ListResourcePoolsRequest: S.Schema<ListResourcePoolsRequest>;
+/** List of Resource Pools */
+export type ListResourcePoolsResponseResourcePoolsList = Array<ResourcePool>;
+export declare const ListResourcePoolsResponseResourcePoolsList: S.Schema<ListResourcePoolsResponseResourcePoolsList>;
+export interface ListResourcePoolsResponse {
+    /** List of Resource Pools */
+    resourcePools?: ListResourcePoolsResponseResourcePoolsList;
+}
+export declare const ListResourcePoolsResponse: S.Schema<ListResourcePoolsResponse>;
+export interface ListResourcePoolSnapshotsRequest {
+    projectId: string;
+    region: string;
+    resourcePoolId: string;
+}
+export declare const ListResourcePoolSnapshotsRequest: S.Schema<ListResourcePoolSnapshotsRequest>;
+/** List of Resource Pool Snapshots */
+export type ListResourcePoolSnapshotsResponseResourcePoolSnapshotsList = Array<ResourcePoolSnapshot>;
+export declare const ListResourcePoolSnapshotsResponseResourcePoolSnapshotsList: S.Schema<ListResourcePoolSnapshotsResponseResourcePoolSnapshotsList>;
+export interface ListResourcePoolSnapshotsResponse {
+    /** List of Resource Pool Snapshots */
+    resourcePoolSnapshots?: ListResourcePoolSnapshotsResponseResourcePoolSnapshotsList;
+}
+export declare const ListResourcePoolSnapshotsResponse: S.Schema<ListResourcePoolSnapshotsResponse>;
+export interface ListShareExportPoliciesRequest {
+    projectId: string;
+    region: string;
+}
+export declare const ListShareExportPoliciesRequest: S.Schema<ListShareExportPoliciesRequest>;
+/** List of Share Export Policies */
+export type ListShareExportPoliciesResponseShareExportPoliciesList = Array<ShareExportPolicy>;
+export declare const ListShareExportPoliciesResponseShareExportPoliciesList: S.Schema<ListShareExportPoliciesResponseShareExportPoliciesList>;
+export interface ListShareExportPoliciesResponse {
+    /** List of Share Export Policies */
+    shareExportPolicies?: ListShareExportPoliciesResponseShareExportPoliciesList;
+}
+export declare const ListShareExportPoliciesResponse: S.Schema<ListShareExportPoliciesResponse>;
+export interface ListSharesRequest {
+    projectId: string;
+    region: string;
+    resourcePoolId: string;
+}
+export declare const ListSharesRequest: S.Schema<ListSharesRequest>;
+/** List of Shares */
+export type ListSharesResponseSharesList = Array<Share>;
+export declare const ListSharesResponseSharesList: S.Schema<ListSharesResponseSharesList>;
+export interface ListSharesResponse {
+    /** List of Shares */
+    shares?: ListSharesResponseSharesList;
+}
+export declare const ListSharesResponse: S.Schema<ListSharesResponse>;
+export interface ListSnapshotPoliciesRequest {
+    projectId: string;
+    immutable?: boolean;
+}
+export declare const ListSnapshotPoliciesRequest: S.Schema<ListSnapshotPoliciesRequest>;
+/** List of Snapshot Policies */
+export type ListSnapshotPoliciesResponseSnapshotPoliciesList = Array<SnapshotPolicy>;
+export declare const ListSnapshotPoliciesResponseSnapshotPoliciesList: S.Schema<ListSnapshotPoliciesResponseSnapshotPoliciesList>;
+export interface ListSnapshotPoliciesResponse {
+    /** List of Snapshot Policies */
+    snapshotPolicies?: ListSnapshotPoliciesResponseSnapshotPoliciesList;
+}
+export declare const ListSnapshotPoliciesResponse: 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 declare const UpdateResourcePoolRequestIpAclList: S.Schema<UpdateResourcePoolRequestIpAclList>;
+/** An optional object that represents the labels associated with the resource pool. */
+export type UpdateResourcePoolRequestLabelsMap = {
+    [key: string]: string | undefined;
+};
+export declare const UpdateResourcePoolRequestLabelsMap: 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 declare const UpdateResourcePoolRequest: S.Schema<UpdateResourcePoolRequest>;
+export interface UpdateResourcePoolResponse {
+    /** Updated Resource Pool */
+    resourcePool?: ResourcePool;
+}
+export declare const UpdateResourcePoolResponse: 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 declare const UpdateResourcePoolSnapshotRequest: S.Schema<UpdateResourcePoolSnapshotRequest>;
+export interface UpdateResourcePoolSnapshotResponse {
+    /** Updated Resource Pool Snapshot */
+    resourcePoolSnapshot?: ResourcePoolSnapshot;
+}
+export declare const UpdateResourcePoolSnapshotResponse: S.Schema<UpdateResourcePoolSnapshotResponse>;
+/** An optional object that represents the labels associated with the share. */
+export type UpdateShareRequestLabelsMap = {
+    [key: string]: string | undefined;
+};
+export declare const UpdateShareRequestLabelsMap: 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 declare const UpdateShareRequest: S.Schema<UpdateShareRequest>;
+export interface UpdateShareResponse {
+    /** Updated Share */
+    share?: Share;
+}
+export declare const UpdateShareResponse: S.Schema<UpdateShareResponse>;
+/** An optional object that represents the labels associated with the share export policy. */
+export type UpdateShareExportPolicyRequestLabelsMap = {
+    [key: string]: string | undefined;
+};
+export declare const UpdateShareExportPolicyRequestLabelsMap: 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 declare const UpdateShareExportPolicyBodyRuleIpAclList: 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 declare const UpdateShareExportPolicyBodyRule: 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 declare const UpdateShareExportPolicyRequestRulesList: 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 declare const UpdateShareExportPolicyRequest: S.Schema<UpdateShareExportPolicyRequest>;
+export interface UpdateShareExportPolicyResponse {
+    shareExportPolicy?: ShareExportPolicy;
+}
+export declare const UpdateShareExportPolicyResponse: S.Schema<UpdateShareExportPolicyResponse>;
+export type CreateResourcePoolError = BadRequest | StackitOpError;
+/** Create Resource Pool Create a Resource Pool in a project. */
+export declare const createResourcePool: API.OperationMethod<CreateResourcePoolRequest, CreateResourcePoolResponse, CreateResourcePoolError, StackitOpContext>;
+export type CreateResourcePoolSnapshotError = BadRequest | StackitOpError;
+/** Create Resource Pool Snapshot Creates a Snapshot of a Resource Pool in a project. */
+export declare const createResourcePoolSnapshot: API.OperationMethod<CreateResourcePoolSnapshotRequest, CreateResourcePoolSnapshotResponse, CreateResourcePoolSnapshotError, StackitOpContext>;
+export type CreateShareError = BadRequest | StackitOpError;
+/** Create Share Creates a Share in a Resource Pool in a project. */
+export declare const createShare: API.OperationMethod<CreateShareRequest, CreateShareResponse, CreateShareError, StackitOpContext>;
+export type CreateShareExportPolicyError = BadRequest | StackitOpError;
+/** Create Share Export Policy Creates a ShareExportPolicy in a Resource Pool in a project. */
+export declare const createShareExportPolicy: API.OperationMethod<CreateShareExportPolicyRequest, CreateShareExportPolicyResponse, CreateShareExportPolicyError, StackitOpContext>;
+export type DeleteResourcePoolError = BadRequest | StackitOpError;
+/** Delete Resource Pool Deletes a Resource Pool in a project. */
+export declare const deleteResourcePool: API.OperationMethod<DeleteResourcePoolRequest, DeleteResourcePoolResponse2, DeleteResourcePoolError, StackitOpContext>;
+export type DeleteResourcePoolSnapshotError = BadRequest | StackitOpError;
+/** Delete Resource Pool Snapshot Deletes a Snapshot from a Resource Pool in a project. */
+export declare const deleteResourcePoolSnapshot: API.OperationMethod<DeleteResourcePoolSnapshotRequest, DeleteResourcePoolSnapshotResponse2, DeleteResourcePoolSnapshotError, StackitOpContext>;
+export type DeleteShareError = BadRequest | StackitOpError;
+/** Delete Share Deletes a Shares in a Resource Pool in a project. */
+export declare const deleteShare: API.OperationMethod<DeleteShareRequest, DeleteShareResponse2, DeleteShareError, StackitOpContext>;
+export type DeleteShareExportPolicyError = BadRequest | StackitOpError;
+/** Delete Share Export Policy Deletes a ShareExportPolicies in a Resource Pool in a project. */
+export declare const deleteShareExportPolicy: API.OperationMethod<DeleteShareExportPolicyRequest, DeleteShareExportPolicyResponse2, DeleteShareExportPolicyError, StackitOpContext>;
+export type DisableLockError = StackitOpError;
+/** Clean up locks for a project so that it can be deleted successfully. */
+export declare const disableLock: API.OperationMethod<DisableLockRequest, DisableLockResponse2, DisableLockError, StackitOpContext>;
+export type EnableLockError = StackitOpError;
+/** Enable Lock for a project. Necessary for immutable snapshots and to prevent accidental deletion of resources. */
+export declare const enableLock: API.OperationMethod<EnableLockRequest, EnableLockResponse, EnableLockError, StackitOpContext>;
+export type GetLockError = StackitOpError;
+/** Get lock status for a project. */
+export declare const getLock: API.OperationMethod<GetLockRequest, GetLockResponse, GetLockError, StackitOpContext>;
+export type GetResourcePoolError = BadRequest | StackitOpError;
+/** Get Resource Pool Retrieves a Resource Pool in a project. */
+export declare const getResourcePool: API.OperationMethod<GetResourcePoolRequest, GetResourcePoolResponse, GetResourcePoolError, StackitOpContext>;
+export type GetResourcePoolSnapshotError = BadRequest | StackitOpError;
+/** Get Resource Pool Snapshot Retrieves a Snapshot from a Resource Pool in a project. */
+export declare const getResourcePoolSnapshot: API.OperationMethod<GetResourcePoolSnapshotRequest, GetResourcePoolSnapshotResponse, GetResourcePoolSnapshotError, StackitOpContext>;
+export type GetShareError = BadRequest | StackitOpError;
+/** Get Share Retrieves a Shares in a Resource Pool in a project. */
+export declare const getShare: API.OperationMethod<GetShareRequest, GetShareResponse, GetShareError, StackitOpContext>;
+export type GetShareExportPolicyError = BadRequest | StackitOpError;
+/** Get Share Export Policy Retrieves a ShareExportPolicies in a Resource Pool in a project. */
+export declare const getShareExportPolicy: API.OperationMethod<GetShareExportPolicyRequest, GetShareExportPolicyResponse, GetShareExportPolicyError, StackitOpContext>;
+export type GetSnapshotPolicyError = StackitOpError;
+/** Get Snapshot Policy */
+export declare const getSnapshotPolicy: API.OperationMethod<GetSnapshotPolicyRequest, GetSnapshotPolicyResponse, GetSnapshotPolicyError, StackitOpContext>;
+export type ListPerformanceClassesError = BadRequest | StackitOpError;
+/** List Resource Performance Classes Lists all performances classes available */
+export declare const listPerformanceClasses: API.OperationMethod<ListPerformanceClassesRequest, ListPerformanceClassesResponse, ListPerformanceClassesError, StackitOpContext>;
+export type ListResourcePoolsError = BadRequest | StackitOpError;
+/** List Resource Pools Lists Resource Pools in a project. */
+export declare const listResourcePools: API.OperationMethod<ListResourcePoolsRequest, ListResourcePoolsResponse, ListResourcePoolsError, StackitOpContext>;
+export type ListResourcePoolSnapshotsError = BadRequest | StackitOpError;
+/** List Resource Pool Snapshots Lists the Snapshots of a Resource Pool in a project. */
+export declare const listResourcePoolSnapshots: API.OperationMethod<ListResourcePoolSnapshotsRequest, ListResourcePoolSnapshotsResponse, ListResourcePoolSnapshotsError, StackitOpContext>;
+export type ListShareExportPoliciesError = BadRequest | StackitOpError;
+/** List Share Export Policies Lists ShareExportPolicies in a Resource Pool in a project. */
+export declare const listShareExportPolicies: API.OperationMethod<ListShareExportPoliciesRequest, ListShareExportPoliciesResponse, ListShareExportPoliciesError, StackitOpContext>;
+export type ListSharesError = BadRequest | StackitOpError;
+/** List Shares Lists Shares in a Resource Pool in a project. */
+export declare const listShares: API.OperationMethod<ListSharesRequest, ListSharesResponse, ListSharesError, StackitOpContext>;
+export type ListSnapshotPoliciesError = StackitOpError;
+/** List Snapshot Policies */
+export declare const listSnapshotPolicies: API.OperationMethod<ListSnapshotPoliciesRequest, ListSnapshotPoliciesResponse, ListSnapshotPoliciesError, StackitOpContext>;
+export type UpdateResourcePoolError = BadRequest | StackitOpError;
+/** Update Resource Pool Updates a Resource Pool in a project. */
+export declare const updateResourcePool: API.OperationMethod<UpdateResourcePoolRequest, UpdateResourcePoolResponse, UpdateResourcePoolError, StackitOpContext>;
+export type UpdateResourcePoolSnapshotError = BadRequest | StackitOpError;
+/** Update Resource Pool Snapshot Updates a Snapshot from a Resource Pool in a project. */
+export declare const updateResourcePoolSnapshot: API.OperationMethod<UpdateResourcePoolSnapshotRequest, UpdateResourcePoolSnapshotResponse, UpdateResourcePoolSnapshotError, StackitOpContext>;
+export type UpdateShareError = BadRequest | StackitOpError;
+/** Update Share Updates a Shares in a Resource Pool in a project. */
+export declare const updateShare: API.OperationMethod<UpdateShareRequest, UpdateShareResponse, UpdateShareError, StackitOpContext>;
+export type UpdateShareExportPolicyError = BadRequest | StackitOpError;
+/** Update Share Export Policy Updates a ShareExportPolicies in a Resource Pool in a project. */
+export declare const updateShareExportPolicy: API.OperationMethod<UpdateShareExportPolicyRequest, UpdateShareExportPolicyResponse, UpdateShareExportPolicyError, StackitOpContext>;
+//# sourceMappingURL=sfs.d.ts.map