/* tslint:disable */
/* eslint-disable */
/**
 * ELEMENTS API
 * No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
 *
 * The version of the OpenAPI document: 2
 * 
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
 * https://openapi-generator.tech
 * Do not edit the class manually.
 */


import * as runtime from '../runtime';
import {
    CreatePathQuotaRequest,
    CreatePathQuotaRequestFromJSON,
    CreatePathQuotaRequestToJSON,
    CreateTemplateFolderEndpointRequest,
    CreateTemplateFolderEndpointRequestFromJSON,
    CreateTemplateFolderEndpointRequestToJSON,
    DeletedWorkspace,
    DeletedWorkspaceFromJSON,
    DeletedWorkspaceToJSON,
    FileCopyEndpointRequest,
    FileCopyEndpointRequestFromJSON,
    FileCopyEndpointRequestToJSON,
    FileDeleteEndpointRequest,
    FileDeleteEndpointRequestFromJSON,
    FileDeleteEndpointRequestToJSON,
    FileMoveEndpointRequest,
    FileMoveEndpointRequestFromJSON,
    FileMoveEndpointRequestToJSON,
    FilePartialUpdate,
    FilePartialUpdateFromJSON,
    FilePartialUpdateToJSON,
    FileSizeDistribution,
    FileSizeDistributionFromJSON,
    FileSizeDistributionToJSON,
    FileSizeEndpointResponse,
    FileSizeEndpointResponseFromJSON,
    FileSizeEndpointResponseToJSON,
    FileUnzipEndpointRequest,
    FileUnzipEndpointRequestFromJSON,
    FileUnzipEndpointRequestToJSON,
    FileUpdate,
    FileUpdateFromJSON,
    FileUpdateToJSON,
    FileZipEndpointRequest,
    FileZipEndpointRequestFromJSON,
    FileZipEndpointRequestToJSON,
    FilesystemFile,
    FilesystemFileFromJSON,
    FilesystemFileToJSON,
    FilesystemTraceEndpointRequest,
    FilesystemTraceEndpointRequestFromJSON,
    FilesystemTraceEndpointRequestToJSON,
    FilesystemTraceEndpointResponse,
    FilesystemTraceEndpointResponseFromJSON,
    FilesystemTraceEndpointResponseToJSON,
    MoveWorkspaceRequest,
    MoveWorkspaceRequestFromJSON,
    MoveWorkspaceRequestToJSON,
    PathInput,
    PathInputFromJSON,
    PathInputToJSON,
    Production,
    ProductionFromJSON,
    ProductionToJSON,
    ProductionPartialUpdate,
    ProductionPartialUpdateFromJSON,
    ProductionPartialUpdateToJSON,
    ProductionUpdate,
    ProductionUpdateFromJSON,
    ProductionUpdateToJSON,
    Quota,
    QuotaFromJSON,
    QuotaToJSON,
    Share,
    ShareFromJSON,
    ShareToJSON,
    SharePartialUpdate,
    SharePartialUpdateFromJSON,
    SharePartialUpdateToJSON,
    ShareToHomeWorkspaceEndpointRequest,
    ShareToHomeWorkspaceEndpointRequestFromJSON,
    ShareToHomeWorkspaceEndpointRequestToJSON,
    ShareUpdate,
    ShareUpdateFromJSON,
    ShareUpdateToJSON,
    Snapshot,
    SnapshotFromJSON,
    SnapshotToJSON,
    SnapshotPartialUpdate,
    SnapshotPartialUpdateFromJSON,
    SnapshotPartialUpdateToJSON,
    SnapshotUpdate,
    SnapshotUpdateFromJSON,
    SnapshotUpdateToJSON,
    StorNextConnections,
    StorNextConnectionsFromJSON,
    StorNextConnectionsToJSON,
    TaskInfo,
    TaskInfoFromJSON,
    TaskInfoToJSON,
    UpdateQuotaRequest,
    UpdateQuotaRequestFromJSON,
    UpdateQuotaRequestToJSON,
    Volume,
    VolumeFromJSON,
    VolumeToJSON,
    VolumePartialUpdate,
    VolumePartialUpdateFromJSON,
    VolumePartialUpdateToJSON,
    VolumeStats,
    VolumeStatsFromJSON,
    VolumeStatsToJSON,
    VolumeUpdate,
    VolumeUpdateFromJSON,
    VolumeUpdateToJSON,
    Workspace,
    WorkspaceFromJSON,
    WorkspaceToJSON,
    WorkspaceCheckIn,
    WorkspaceCheckInFromJSON,
    WorkspaceCheckInToJSON,
    WorkspaceDetail,
    WorkspaceDetailFromJSON,
    WorkspaceDetailToJSON,
    WorkspaceDetailPartialUpdate,
    WorkspaceDetailPartialUpdateFromJSON,
    WorkspaceDetailPartialUpdateToJSON,
    WorkspaceDetailUpdate,
    WorkspaceDetailUpdateFromJSON,
    WorkspaceDetailUpdateToJSON,
    WorkspaceMoveToRequest,
    WorkspaceMoveToRequestFromJSON,
    WorkspaceMoveToRequestToJSON,
    WorkspacePermission,
    WorkspacePermissionFromJSON,
    WorkspacePermissionToJSON,
    WorkspacePermissionPartialUpdate,
    WorkspacePermissionPartialUpdateFromJSON,
    WorkspacePermissionPartialUpdateToJSON,
    WorkspacePermissionUpdate,
    WorkspacePermissionUpdateFromJSON,
    WorkspacePermissionUpdateToJSON,
} from '../models';

export interface ApplyWorkspaceAffinityRequest {
    id: number;
}

export interface BookmarkWorkspaceRequest {
    id: number;
}

export interface CalculateDirectorySizeRequest {
    pathInput: PathInput;
}

export interface CheckInIntoWorkspaceRequest {
    id: number;
    workspaceCheckIn: WorkspaceCheckIn;
}

export interface CheckOutOfWorkspaceRequest {
    id: number;
}

export interface CopyFilesRequest {
    fileCopyEndpointRequest: FileCopyEndpointRequest;
}

export interface CreateFileRequest {
    fileUpdate: FileUpdate;
}

export interface CreatePathQuotaOperationRequest {
    id: number;
    relativePath: string;
    createPathQuotaRequest: CreatePathQuotaRequest;
}

export interface CreateProductionRequest {
    productionUpdate: ProductionUpdate;
}

export interface CreateShareRequest {
    shareUpdate: ShareUpdate;
}

export interface CreateSnapshotRequest {
    snapshotUpdate: SnapshotUpdate;
}

export interface CreateTemplateFolderRequest {
    createTemplateFolderEndpointRequest: CreateTemplateFolderEndpointRequest;
}

export interface CreateVolumeRequest {
    volumeUpdate: VolumeUpdate;
}

export interface CreateWorkspaceRequest {
    workspaceDetailUpdate: WorkspaceDetailUpdate;
}

export interface CreateWorkspacePermissionRequest {
    workspacePermissionUpdate: WorkspacePermissionUpdate;
}

export interface DeleteFileRequest {
    path: string;
}

export interface DeleteFilesRequest {
    fileDeleteEndpointRequest: FileDeleteEndpointRequest;
}

export interface DeletePathQuotaRequest {
    id: number;
    relativePath: string;
}

export interface DeleteProductionRequest {
    id: number;
}

export interface DeleteShareRequest {
    id: number;
}

export interface DeleteSnapshotRequest {
    id: number;
}

export interface DeleteWorkspaceRequest {
    id: number;
    deleteContent?: boolean;
}

export interface DeleteWorkspacePermissionRequest {
    id: number;
}

export interface GetAllDeletedWorkspacesRequest {
    isTemplate?: string;
    production?: number;
    volume?: number;
    homeFor?: number;
    volumeType?: string;
    productionName?: string;
    productionActive?: string;
    name?: string;
    isExternal?: string;
    active?: string;
    ordering?: string;
    limit?: number;
    offset?: number;
}

export interface GetAllProductionsRequest {
    active?: string;
    name?: string;
    ordering?: string;
    limit?: number;
    offset?: number;
    copyTemplateContent?: boolean;
    includeTotalSize?: boolean;
}

export interface GetAllSharesRequest {
    ordering?: string;
    limit?: number;
    offset?: number;
}

export interface GetAllSnapshotsRequest {
    workspace?: number;
    ordering?: string;
    limit?: number;
    offset?: number;
}

export interface GetAllVolumesRequest {
    isDefault?: string;
    type?: string;
    useForHomes?: string;
    useForWorkspaces?: string;
    displayName?: string;
    visualTag?: string;
    ordering?: string;
    limit?: number;
    offset?: number;
    includeStatus?: boolean;
}

export interface GetAllWorkspacePermissionsRequest {
    workspace?: number;
    user?: number;
    group?: number;
    ordering?: string;
    limit?: number;
    offset?: number;
}

export interface GetAllWorkspacesRequest {
    isTemplate?: string;
    production?: number;
    volume?: number;
    homeFor?: number;
    volumeType?: string;
    productionName?: string;
    productionActive?: string;
    name?: string;
    isExternal?: string;
    active?: string;
    ordering?: string;
    limit?: number;
    offset?: number;
    resolveAccessFor?: number;
    includeEndpoints?: boolean;
    includeQuotas?: boolean;
}

export interface GetFileRequest {
    path: string;
    maxDepth?: number;
    bundle?: boolean;
}

export interface GetGroupQuotaRequest {
    groupId: string;
    id: number;
}

export interface GetMyWorkspacesRequest {
    isTemplate?: string;
    production?: number;
    volume?: number;
    homeFor?: number;
    volumeType?: string;
    productionName?: string;
    productionActive?: string;
    name?: string;
    isExternal?: string;
    active?: string;
    ordering?: string;
    limit?: number;
    offset?: number;
}

export interface GetPathQuotaRequest {
    id: number;
    relativePath: string;
}

export interface GetProductionRequest {
    id: number;
    copyTemplateContent?: boolean;
    includeTotalSize?: boolean;
}

export interface GetRootDirectoryRequest {
    ordering?: string;
    limit?: number;
    offset?: number;
}

export interface GetShareRequest {
    id: number;
}

export interface GetSnapshotRequest {
    id: number;
}

export interface GetUserQuotaRequest {
    id: number;
    userId: string;
}

export interface GetVolumeRequest {
    id: number;
    includeStatus?: boolean;
}

export interface GetVolumeActiveConnectionsRequest {
    id: number;
}

export interface GetVolumeFileSizeDistributionRequest {
    id: number;
}

export interface GetVolumeStatsRequest {
    id: number;
}

export interface GetWorkspaceRequest {
    id: number;
}

export interface GetWorkspacePermissionRequest {
    id: number;
}

export interface MoveFilesRequest {
    fileMoveEndpointRequest: FileMoveEndpointRequest;
}

export interface MoveWorkspaceOperationRequest {
    id: number;
    moveWorkspaceRequest: MoveWorkspaceRequest;
}

export interface MoveWorkspaceToProductionRequest {
    id: number;
    workspaceMoveToRequest: WorkspaceMoveToRequest;
}

export interface PatchFileRequest {
    path: string;
    filePartialUpdate: FilePartialUpdate;
    maxDepth?: number;
    bundle?: boolean;
}

export interface PatchProductionRequest {
    id: number;
    productionPartialUpdate: ProductionPartialUpdate;
}

export interface PatchShareRequest {
    id: number;
    sharePartialUpdate: SharePartialUpdate;
}

export interface PatchSnapshotRequest {
    id: number;
    snapshotPartialUpdate: SnapshotPartialUpdate;
}

export interface PatchVolumeRequest {
    id: number;
    volumePartialUpdate: VolumePartialUpdate;
}

export interface PatchWorkspaceRequest {
    id: number;
    workspaceDetailPartialUpdate: WorkspaceDetailPartialUpdate;
}

export interface PatchWorkspacePermissionRequest {
    id: number;
    workspacePermissionPartialUpdate: WorkspacePermissionPartialUpdate;
}

export interface RecordStorageTraceRequest {
    filesystemTraceEndpointRequest: FilesystemTraceEndpointRequest;
}

export interface RepairWorkspacePermissionsRequest {
    id: number;
}

export interface ShareToHomeWorkspaceRequest {
    shareToHomeWorkspaceEndpointRequest: ShareToHomeWorkspaceEndpointRequest;
}

export interface UnbookmarkWorkspaceRequest {
    id: number;
}

export interface UnzipFileRequest {
    fileUnzipEndpointRequest: FileUnzipEndpointRequest;
}

export interface UpdateGroupQuotaRequest {
    groupId: string;
    id: number;
    updateQuotaRequest: UpdateQuotaRequest;
}

export interface UpdatePathQuotaRequest {
    id: number;
    relativePath: string;
    updateQuotaRequest: UpdateQuotaRequest;
}

export interface UpdateProductionRequest {
    id: number;
    productionUpdate: ProductionUpdate;
}

export interface UpdateShareRequest {
    id: number;
    shareUpdate: ShareUpdate;
}

export interface UpdateSnapshotRequest {
    id: number;
    snapshotUpdate: SnapshotUpdate;
}

export interface UpdateUserQuotaRequest {
    id: number;
    userId: string;
    updateQuotaRequest: UpdateQuotaRequest;
}

export interface UpdateVolumeRequest {
    id: number;
    volumeUpdate: VolumeUpdate;
}

export interface UpdateWorkspaceRequest {
    id: number;
    workspaceDetailUpdate: WorkspaceDetailUpdate;
}

export interface UpdateWorkspacePermissionRequest {
    id: number;
    workspacePermissionUpdate: WorkspacePermissionUpdate;
}

export interface ZipFilesRequest {
    fileZipEndpointRequest: FileZipEndpointRequest;
}

/**
 * 
 */
export class StorageApi extends runtime.BaseAPI {

    /**
     * ### Required permissions    * User account permission: `projects:manage` 
     */
    async applyWorkspaceAffinityRaw(requestParameters: ApplyWorkspaceAffinityRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling applyWorkspaceAffinity.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/workspaces/{id}/apply-affinity`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * ### Required permissions    * User account permission: `projects:manage` 
     */
    async applyWorkspaceAffinity(requestParameters: ApplyWorkspaceAffinityRequest, initOverrides?: RequestInit): Promise<void> {
        await this.applyWorkspaceAffinityRaw(requestParameters, initOverrides);
    }

    /**
     * ### Required permissions    * Authenticated user 
     */
    async bookmarkWorkspaceRaw(requestParameters: BookmarkWorkspaceRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling bookmarkWorkspace.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/workspaces/{id}/bookmark`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * ### Required permissions    * Authenticated user 
     */
    async bookmarkWorkspace(requestParameters: BookmarkWorkspaceRequest, initOverrides?: RequestInit): Promise<void> {
        await this.bookmarkWorkspaceRaw(requestParameters, initOverrides);
    }

    /**
     * ### Required permissions    * Authenticated user 
     */
    async calculateDirectorySizeRaw(requestParameters: CalculateDirectorySizeRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<FileSizeEndpointResponse>> {
        if (requestParameters.pathInput === null || requestParameters.pathInput === undefined) {
            throw new runtime.RequiredError('pathInput','Required parameter requestParameters.pathInput was null or undefined when calling calculateDirectorySize.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/filesystem/calculate-directory-size`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: PathInputToJSON(requestParameters.pathInput),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => FileSizeEndpointResponseFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * Authenticated user 
     */
    async calculateDirectorySize(requestParameters: CalculateDirectorySizeRequest, initOverrides?: RequestInit): Promise<FileSizeEndpointResponse> {
        const response = await this.calculateDirectorySizeRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * Authenticated user 
     */
    async checkInIntoWorkspaceRaw(requestParameters: CheckInIntoWorkspaceRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling checkInIntoWorkspace.');
        }

        if (requestParameters.workspaceCheckIn === null || requestParameters.workspaceCheckIn === undefined) {
            throw new runtime.RequiredError('workspaceCheckIn','Required parameter requestParameters.workspaceCheckIn was null or undefined when calling checkInIntoWorkspace.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/workspaces/{id}/check-in`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: WorkspaceCheckInToJSON(requestParameters.workspaceCheckIn),
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * ### Required permissions    * Authenticated user 
     */
    async checkInIntoWorkspace(requestParameters: CheckInIntoWorkspaceRequest, initOverrides?: RequestInit): Promise<void> {
        await this.checkInIntoWorkspaceRaw(requestParameters, initOverrides);
    }

    /**
     * ### Required permissions    * Authenticated user 
     */
    async checkOutOfWorkspaceRaw(requestParameters: CheckOutOfWorkspaceRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling checkOutOfWorkspace.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/workspaces/{id}/check-out`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * ### Required permissions    * Authenticated user 
     */
    async checkOutOfWorkspace(requestParameters: CheckOutOfWorkspaceRequest, initOverrides?: RequestInit): Promise<void> {
        await this.checkOutOfWorkspaceRaw(requestParameters, initOverrides);
    }

    /**
     * ### Required permissions    * Authenticated user 
     */
    async copyFilesRaw(requestParameters: CopyFilesRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<TaskInfo>> {
        if (requestParameters.fileCopyEndpointRequest === null || requestParameters.fileCopyEndpointRequest === undefined) {
            throw new runtime.RequiredError('fileCopyEndpointRequest','Required parameter requestParameters.fileCopyEndpointRequest was null or undefined when calling copyFiles.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/filesystem/copy`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: FileCopyEndpointRequestToJSON(requestParameters.fileCopyEndpointRequest),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => TaskInfoFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * Authenticated user 
     */
    async copyFiles(requestParameters: CopyFilesRequest, initOverrides?: RequestInit): Promise<TaskInfo> {
        const response = await this.copyFilesRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * Authenticated user 
     */
    async createFileRaw(requestParameters: CreateFileRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<FilesystemFile>> {
        if (requestParameters.fileUpdate === null || requestParameters.fileUpdate === undefined) {
            throw new runtime.RequiredError('fileUpdate','Required parameter requestParameters.fileUpdate was null or undefined when calling createFile.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/files`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: FileUpdateToJSON(requestParameters.fileUpdate),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => FilesystemFileFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * Authenticated user 
     */
    async createFile(requestParameters: CreateFileRequest, initOverrides?: RequestInit): Promise<FilesystemFile> {
        const response = await this.createFileRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * Authenticated user 
     */
    async createPathQuotaRaw(requestParameters: CreatePathQuotaOperationRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling createPathQuota.');
        }

        if (requestParameters.relativePath === null || requestParameters.relativePath === undefined) {
            throw new runtime.RequiredError('relativePath','Required parameter requestParameters.relativePath was null or undefined when calling createPathQuota.');
        }

        if (requestParameters.createPathQuotaRequest === null || requestParameters.createPathQuotaRequest === undefined) {
            throw new runtime.RequiredError('createPathQuotaRequest','Required parameter requestParameters.createPathQuotaRequest was null or undefined when calling createPathQuota.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/volumes/{id}/quotas/path/{relative_path}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))).replace(`{${"relative_path"}}`, encodeURIComponent(String(requestParameters.relativePath))),
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: CreatePathQuotaRequestToJSON(requestParameters.createPathQuotaRequest),
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * ### Required permissions    * Authenticated user 
     */
    async createPathQuota(requestParameters: CreatePathQuotaOperationRequest, initOverrides?: RequestInit): Promise<void> {
        await this.createPathQuotaRaw(requestParameters, initOverrides);
    }

    /**
     * ### Required permissions    * User account permission: `projects:view` (read) / `projects:manage` (write) 
     */
    async createProductionRaw(requestParameters: CreateProductionRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Production>> {
        if (requestParameters.productionUpdate === null || requestParameters.productionUpdate === undefined) {
            throw new runtime.RequiredError('productionUpdate','Required parameter requestParameters.productionUpdate was null or undefined when calling createProduction.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/productions`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: ProductionUpdateToJSON(requestParameters.productionUpdate),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => ProductionFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `projects:view` (read) / `projects:manage` (write) 
     */
    async createProduction(requestParameters: CreateProductionRequest, initOverrides?: RequestInit): Promise<Production> {
        const response = await this.createProductionRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `shares:view` (read) / `shares:manage` (write) 
     */
    async createShareRaw(requestParameters: CreateShareRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Share>> {
        if (requestParameters.shareUpdate === null || requestParameters.shareUpdate === undefined) {
            throw new runtime.RequiredError('shareUpdate','Required parameter requestParameters.shareUpdate was null or undefined when calling createShare.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/shares`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: ShareUpdateToJSON(requestParameters.shareUpdate),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => ShareFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `shares:view` (read) / `shares:manage` (write) 
     */
    async createShare(requestParameters: CreateShareRequest, initOverrides?: RequestInit): Promise<Share> {
        const response = await this.createShareRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `projects:view` (read) / `projects:manage` (write) 
     */
    async createSnapshotRaw(requestParameters: CreateSnapshotRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Snapshot>> {
        if (requestParameters.snapshotUpdate === null || requestParameters.snapshotUpdate === undefined) {
            throw new runtime.RequiredError('snapshotUpdate','Required parameter requestParameters.snapshotUpdate was null or undefined when calling createSnapshot.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/snapshots`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: SnapshotUpdateToJSON(requestParameters.snapshotUpdate),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => SnapshotFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `projects:view` (read) / `projects:manage` (write) 
     */
    async createSnapshot(requestParameters: CreateSnapshotRequest, initOverrides?: RequestInit): Promise<Snapshot> {
        const response = await this.createSnapshotRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `folder_templates:manage` 
     */
    async createTemplateFolderRaw(requestParameters: CreateTemplateFolderRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.createTemplateFolderEndpointRequest === null || requestParameters.createTemplateFolderEndpointRequest === undefined) {
            throw new runtime.RequiredError('createTemplateFolderEndpointRequest','Required parameter requestParameters.createTemplateFolderEndpointRequest was null or undefined when calling createTemplateFolder.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/private/create-template-folder`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: CreateTemplateFolderEndpointRequestToJSON(requestParameters.createTemplateFolderEndpointRequest),
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * ### Required permissions    * User account permission: `folder_templates:manage` 
     */
    async createTemplateFolder(requestParameters: CreateTemplateFolderRequest, initOverrides?: RequestInit): Promise<void> {
        await this.createTemplateFolderRaw(requestParameters, initOverrides);
    }

    /**
     * ### Required permissions    * User account permission: `None` (read) / `system:admin-access` (write) 
     */
    async createVolumeRaw(requestParameters: CreateVolumeRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Volume>> {
        if (requestParameters.volumeUpdate === null || requestParameters.volumeUpdate === undefined) {
            throw new runtime.RequiredError('volumeUpdate','Required parameter requestParameters.volumeUpdate was null or undefined when calling createVolume.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/volumes`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: VolumeUpdateToJSON(requestParameters.volumeUpdate),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => VolumeFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `None` (read) / `system:admin-access` (write) 
     */
    async createVolume(requestParameters: CreateVolumeRequest, initOverrides?: RequestInit): Promise<Volume> {
        const response = await this.createVolumeRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `None` (read) / `projects:manage` (write) 
     */
    async createWorkspaceRaw(requestParameters: CreateWorkspaceRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<WorkspaceDetail>> {
        if (requestParameters.workspaceDetailUpdate === null || requestParameters.workspaceDetailUpdate === undefined) {
            throw new runtime.RequiredError('workspaceDetailUpdate','Required parameter requestParameters.workspaceDetailUpdate was null or undefined when calling createWorkspace.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/workspaces`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: WorkspaceDetailUpdateToJSON(requestParameters.workspaceDetailUpdate),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => WorkspaceDetailFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `None` (read) / `projects:manage` (write) 
     */
    async createWorkspace(requestParameters: CreateWorkspaceRequest, initOverrides?: RequestInit): Promise<WorkspaceDetail> {
        const response = await this.createWorkspaceRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `projects:view` (read) / `projects:manage` (write) 
     */
    async createWorkspacePermissionRaw(requestParameters: CreateWorkspacePermissionRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<WorkspacePermission>> {
        if (requestParameters.workspacePermissionUpdate === null || requestParameters.workspacePermissionUpdate === undefined) {
            throw new runtime.RequiredError('workspacePermissionUpdate','Required parameter requestParameters.workspacePermissionUpdate was null or undefined when calling createWorkspacePermission.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/workspace-permissions`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: WorkspacePermissionUpdateToJSON(requestParameters.workspacePermissionUpdate),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => WorkspacePermissionFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `projects:view` (read) / `projects:manage` (write) 
     */
    async createWorkspacePermission(requestParameters: CreateWorkspacePermissionRequest, initOverrides?: RequestInit): Promise<WorkspacePermission> {
        const response = await this.createWorkspacePermissionRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * Authenticated user 
     */
    async deleteFileRaw(requestParameters: DeleteFileRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.path === null || requestParameters.path === undefined) {
            throw new runtime.RequiredError('path','Required parameter requestParameters.path was null or undefined when calling deleteFile.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/files/{path}`.replace(`{${"path"}}`, encodeURIComponent(String(requestParameters.path))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * ### Required permissions    * Authenticated user 
     */
    async deleteFile(requestParameters: DeleteFileRequest, initOverrides?: RequestInit): Promise<void> {
        await this.deleteFileRaw(requestParameters, initOverrides);
    }

    /**
     * ### Required permissions    * Authenticated user 
     */
    async deleteFilesRaw(requestParameters: DeleteFilesRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<TaskInfo>> {
        if (requestParameters.fileDeleteEndpointRequest === null || requestParameters.fileDeleteEndpointRequest === undefined) {
            throw new runtime.RequiredError('fileDeleteEndpointRequest','Required parameter requestParameters.fileDeleteEndpointRequest was null or undefined when calling deleteFiles.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/filesystem/delete`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: FileDeleteEndpointRequestToJSON(requestParameters.fileDeleteEndpointRequest),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => TaskInfoFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * Authenticated user 
     */
    async deleteFiles(requestParameters: DeleteFilesRequest, initOverrides?: RequestInit): Promise<TaskInfo> {
        const response = await this.deleteFilesRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * Authenticated user 
     */
    async deletePathQuotaRaw(requestParameters: DeletePathQuotaRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling deletePathQuota.');
        }

        if (requestParameters.relativePath === null || requestParameters.relativePath === undefined) {
            throw new runtime.RequiredError('relativePath','Required parameter requestParameters.relativePath was null or undefined when calling deletePathQuota.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/volumes/{id}/quotas/path/{relative_path}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))).replace(`{${"relative_path"}}`, encodeURIComponent(String(requestParameters.relativePath))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * ### Required permissions    * Authenticated user 
     */
    async deletePathQuota(requestParameters: DeletePathQuotaRequest, initOverrides?: RequestInit): Promise<void> {
        await this.deletePathQuotaRaw(requestParameters, initOverrides);
    }

    /**
     * ### Required permissions    * User account permission: `projects:view` (read) / `projects:manage` (write) 
     */
    async deleteProductionRaw(requestParameters: DeleteProductionRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling deleteProduction.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/productions/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * ### Required permissions    * User account permission: `projects:view` (read) / `projects:manage` (write) 
     */
    async deleteProduction(requestParameters: DeleteProductionRequest, initOverrides?: RequestInit): Promise<void> {
        await this.deleteProductionRaw(requestParameters, initOverrides);
    }

    /**
     * ### Required permissions    * User account permission: `shares:view` (read) / `shares:manage` (write) 
     */
    async deleteShareRaw(requestParameters: DeleteShareRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling deleteShare.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/shares/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * ### Required permissions    * User account permission: `shares:view` (read) / `shares:manage` (write) 
     */
    async deleteShare(requestParameters: DeleteShareRequest, initOverrides?: RequestInit): Promise<void> {
        await this.deleteShareRaw(requestParameters, initOverrides);
    }

    /**
     * ### Required permissions    * User account permission: `projects:view` (read) / `projects:manage` (write) 
     */
    async deleteSnapshotRaw(requestParameters: DeleteSnapshotRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling deleteSnapshot.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/snapshots/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * ### Required permissions    * User account permission: `projects:view` (read) / `projects:manage` (write) 
     */
    async deleteSnapshot(requestParameters: DeleteSnapshotRequest, initOverrides?: RequestInit): Promise<void> {
        await this.deleteSnapshotRaw(requestParameters, initOverrides);
    }

    /**
     * ### Required permissions    * User account permission: `None` (read) / `projects:manage` (write) 
     */
    async deleteWorkspaceRaw(requestParameters: DeleteWorkspaceRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling deleteWorkspace.');
        }

        const queryParameters: any = {};

        if (requestParameters.deleteContent !== undefined) {
            queryParameters['delete_content'] = requestParameters.deleteContent;
        }

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/workspaces/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * ### Required permissions    * User account permission: `None` (read) / `projects:manage` (write) 
     */
    async deleteWorkspace(requestParameters: DeleteWorkspaceRequest, initOverrides?: RequestInit): Promise<void> {
        await this.deleteWorkspaceRaw(requestParameters, initOverrides);
    }

    /**
     * ### Required permissions    * User account permission: `projects:view` (read) / `projects:manage` (write) 
     */
    async deleteWorkspacePermissionRaw(requestParameters: DeleteWorkspacePermissionRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling deleteWorkspacePermission.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/workspace-permissions/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * ### Required permissions    * User account permission: `projects:view` (read) / `projects:manage` (write) 
     */
    async deleteWorkspacePermission(requestParameters: DeleteWorkspacePermissionRequest, initOverrides?: RequestInit): Promise<void> {
        await this.deleteWorkspacePermissionRaw(requestParameters, initOverrides);
    }

    /**
     * ### Required permissions    * User account permission: `projects:view` 
     */
    async getAllDeletedWorkspacesRaw(requestParameters: GetAllDeletedWorkspacesRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Array<DeletedWorkspace>>> {
        const queryParameters: any = {};

        if (requestParameters.isTemplate !== undefined) {
            queryParameters['is_template'] = requestParameters.isTemplate;
        }

        if (requestParameters.production !== undefined) {
            queryParameters['production'] = requestParameters.production;
        }

        if (requestParameters.volume !== undefined) {
            queryParameters['volume'] = requestParameters.volume;
        }

        if (requestParameters.homeFor !== undefined) {
            queryParameters['home_for'] = requestParameters.homeFor;
        }

        if (requestParameters.volumeType !== undefined) {
            queryParameters['volume__type'] = requestParameters.volumeType;
        }

        if (requestParameters.productionName !== undefined) {
            queryParameters['production__name'] = requestParameters.productionName;
        }

        if (requestParameters.productionActive !== undefined) {
            queryParameters['production__active'] = requestParameters.productionActive;
        }

        if (requestParameters.name !== undefined) {
            queryParameters['name'] = requestParameters.name;
        }

        if (requestParameters.isExternal !== undefined) {
            queryParameters['is_external'] = requestParameters.isExternal;
        }

        if (requestParameters.active !== undefined) {
            queryParameters['active'] = requestParameters.active;
        }

        if (requestParameters.ordering !== undefined) {
            queryParameters['ordering'] = requestParameters.ordering;
        }

        if (requestParameters.limit !== undefined) {
            queryParameters['limit'] = requestParameters.limit;
        }

        if (requestParameters.offset !== undefined) {
            queryParameters['offset'] = requestParameters.offset;
        }

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/workspaces/deleted`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(DeletedWorkspaceFromJSON));
    }

    /**
     * ### Required permissions    * User account permission: `projects:view` 
     */
    async getAllDeletedWorkspaces(requestParameters: GetAllDeletedWorkspacesRequest, initOverrides?: RequestInit): Promise<Array<DeletedWorkspace>> {
        const response = await this.getAllDeletedWorkspacesRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `projects:view` (read) / `projects:manage` (write) 
     */
    async getAllProductionsRaw(requestParameters: GetAllProductionsRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Array<Production>>> {
        const queryParameters: any = {};

        if (requestParameters.active !== undefined) {
            queryParameters['active'] = requestParameters.active;
        }

        if (requestParameters.name !== undefined) {
            queryParameters['name'] = requestParameters.name;
        }

        if (requestParameters.ordering !== undefined) {
            queryParameters['ordering'] = requestParameters.ordering;
        }

        if (requestParameters.limit !== undefined) {
            queryParameters['limit'] = requestParameters.limit;
        }

        if (requestParameters.offset !== undefined) {
            queryParameters['offset'] = requestParameters.offset;
        }

        if (requestParameters.copyTemplateContent !== undefined) {
            queryParameters['copy_template_content'] = requestParameters.copyTemplateContent;
        }

        if (requestParameters.includeTotalSize !== undefined) {
            queryParameters['include_total_size'] = requestParameters.includeTotalSize;
        }

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/productions`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(ProductionFromJSON));
    }

    /**
     * ### Required permissions    * User account permission: `projects:view` (read) / `projects:manage` (write) 
     */
    async getAllProductions(requestParameters: GetAllProductionsRequest, initOverrides?: RequestInit): Promise<Array<Production>> {
        const response = await this.getAllProductionsRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `shares:view` (read) / `shares:manage` (write) 
     */
    async getAllSharesRaw(requestParameters: GetAllSharesRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Array<Share>>> {
        const queryParameters: any = {};

        if (requestParameters.ordering !== undefined) {
            queryParameters['ordering'] = requestParameters.ordering;
        }

        if (requestParameters.limit !== undefined) {
            queryParameters['limit'] = requestParameters.limit;
        }

        if (requestParameters.offset !== undefined) {
            queryParameters['offset'] = requestParameters.offset;
        }

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/shares`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(ShareFromJSON));
    }

    /**
     * ### Required permissions    * User account permission: `shares:view` (read) / `shares:manage` (write) 
     */
    async getAllShares(requestParameters: GetAllSharesRequest, initOverrides?: RequestInit): Promise<Array<Share>> {
        const response = await this.getAllSharesRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `projects:view` (read) / `projects:manage` (write) 
     */
    async getAllSnapshotsRaw(requestParameters: GetAllSnapshotsRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Array<Snapshot>>> {
        const queryParameters: any = {};

        if (requestParameters.workspace !== undefined) {
            queryParameters['workspace'] = requestParameters.workspace;
        }

        if (requestParameters.ordering !== undefined) {
            queryParameters['ordering'] = requestParameters.ordering;
        }

        if (requestParameters.limit !== undefined) {
            queryParameters['limit'] = requestParameters.limit;
        }

        if (requestParameters.offset !== undefined) {
            queryParameters['offset'] = requestParameters.offset;
        }

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/snapshots`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(SnapshotFromJSON));
    }

    /**
     * ### Required permissions    * User account permission: `projects:view` (read) / `projects:manage` (write) 
     */
    async getAllSnapshots(requestParameters: GetAllSnapshotsRequest, initOverrides?: RequestInit): Promise<Array<Snapshot>> {
        const response = await this.getAllSnapshotsRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `None` (read) / `system:admin-access` (write) 
     */
    async getAllVolumesRaw(requestParameters: GetAllVolumesRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Array<Volume>>> {
        const queryParameters: any = {};

        if (requestParameters.isDefault !== undefined) {
            queryParameters['is_default'] = requestParameters.isDefault;
        }

        if (requestParameters.type !== undefined) {
            queryParameters['type'] = requestParameters.type;
        }

        if (requestParameters.useForHomes !== undefined) {
            queryParameters['use_for_homes'] = requestParameters.useForHomes;
        }

        if (requestParameters.useForWorkspaces !== undefined) {
            queryParameters['use_for_workspaces'] = requestParameters.useForWorkspaces;
        }

        if (requestParameters.displayName !== undefined) {
            queryParameters['display_name'] = requestParameters.displayName;
        }

        if (requestParameters.visualTag !== undefined) {
            queryParameters['visual_tag'] = requestParameters.visualTag;
        }

        if (requestParameters.ordering !== undefined) {
            queryParameters['ordering'] = requestParameters.ordering;
        }

        if (requestParameters.limit !== undefined) {
            queryParameters['limit'] = requestParameters.limit;
        }

        if (requestParameters.offset !== undefined) {
            queryParameters['offset'] = requestParameters.offset;
        }

        if (requestParameters.includeStatus !== undefined) {
            queryParameters['include_status'] = requestParameters.includeStatus;
        }

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/volumes`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(VolumeFromJSON));
    }

    /**
     * ### Required permissions    * User account permission: `None` (read) / `system:admin-access` (write) 
     */
    async getAllVolumes(requestParameters: GetAllVolumesRequest, initOverrides?: RequestInit): Promise<Array<Volume>> {
        const response = await this.getAllVolumesRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `projects:view` (read) / `projects:manage` (write) 
     */
    async getAllWorkspacePermissionsRaw(requestParameters: GetAllWorkspacePermissionsRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Array<WorkspacePermission>>> {
        const queryParameters: any = {};

        if (requestParameters.workspace !== undefined) {
            queryParameters['workspace'] = requestParameters.workspace;
        }

        if (requestParameters.user !== undefined) {
            queryParameters['user'] = requestParameters.user;
        }

        if (requestParameters.group !== undefined) {
            queryParameters['group'] = requestParameters.group;
        }

        if (requestParameters.ordering !== undefined) {
            queryParameters['ordering'] = requestParameters.ordering;
        }

        if (requestParameters.limit !== undefined) {
            queryParameters['limit'] = requestParameters.limit;
        }

        if (requestParameters.offset !== undefined) {
            queryParameters['offset'] = requestParameters.offset;
        }

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/workspace-permissions`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(WorkspacePermissionFromJSON));
    }

    /**
     * ### Required permissions    * User account permission: `projects:view` (read) / `projects:manage` (write) 
     */
    async getAllWorkspacePermissions(requestParameters: GetAllWorkspacePermissionsRequest, initOverrides?: RequestInit): Promise<Array<WorkspacePermission>> {
        const response = await this.getAllWorkspacePermissionsRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `None` (read) / `projects:manage` (write) 
     */
    async getAllWorkspacesRaw(requestParameters: GetAllWorkspacesRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Array<Workspace>>> {
        const queryParameters: any = {};

        if (requestParameters.isTemplate !== undefined) {
            queryParameters['is_template'] = requestParameters.isTemplate;
        }

        if (requestParameters.production !== undefined) {
            queryParameters['production'] = requestParameters.production;
        }

        if (requestParameters.volume !== undefined) {
            queryParameters['volume'] = requestParameters.volume;
        }

        if (requestParameters.homeFor !== undefined) {
            queryParameters['home_for'] = requestParameters.homeFor;
        }

        if (requestParameters.volumeType !== undefined) {
            queryParameters['volume__type'] = requestParameters.volumeType;
        }

        if (requestParameters.productionName !== undefined) {
            queryParameters['production__name'] = requestParameters.productionName;
        }

        if (requestParameters.productionActive !== undefined) {
            queryParameters['production__active'] = requestParameters.productionActive;
        }

        if (requestParameters.name !== undefined) {
            queryParameters['name'] = requestParameters.name;
        }

        if (requestParameters.isExternal !== undefined) {
            queryParameters['is_external'] = requestParameters.isExternal;
        }

        if (requestParameters.active !== undefined) {
            queryParameters['active'] = requestParameters.active;
        }

        if (requestParameters.ordering !== undefined) {
            queryParameters['ordering'] = requestParameters.ordering;
        }

        if (requestParameters.limit !== undefined) {
            queryParameters['limit'] = requestParameters.limit;
        }

        if (requestParameters.offset !== undefined) {
            queryParameters['offset'] = requestParameters.offset;
        }

        if (requestParameters.resolveAccessFor !== undefined) {
            queryParameters['resolve_access_for'] = requestParameters.resolveAccessFor;
        }

        if (requestParameters.includeEndpoints !== undefined) {
            queryParameters['include_endpoints'] = requestParameters.includeEndpoints;
        }

        if (requestParameters.includeQuotas !== undefined) {
            queryParameters['include_quotas'] = requestParameters.includeQuotas;
        }

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/workspaces`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(WorkspaceFromJSON));
    }

    /**
     * ### Required permissions    * User account permission: `None` (read) / `projects:manage` (write) 
     */
    async getAllWorkspaces(requestParameters: GetAllWorkspacesRequest, initOverrides?: RequestInit): Promise<Array<Workspace>> {
        const response = await this.getAllWorkspacesRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * Authenticated user 
     */
    async getFileRaw(requestParameters: GetFileRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<FilesystemFile>> {
        if (requestParameters.path === null || requestParameters.path === undefined) {
            throw new runtime.RequiredError('path','Required parameter requestParameters.path was null or undefined when calling getFile.');
        }

        const queryParameters: any = {};

        if (requestParameters.maxDepth !== undefined) {
            queryParameters['max_depth'] = requestParameters.maxDepth;
        }

        if (requestParameters.bundle !== undefined) {
            queryParameters['bundle'] = requestParameters.bundle;
        }

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/files/{path}`.replace(`{${"path"}}`, encodeURIComponent(String(requestParameters.path))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => FilesystemFileFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * Authenticated user 
     */
    async getFile(requestParameters: GetFileRequest, initOverrides?: RequestInit): Promise<FilesystemFile> {
        const response = await this.getFileRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `users:manage` 
     */
    async getGroupQuotaRaw(requestParameters: GetGroupQuotaRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Quota>> {
        if (requestParameters.groupId === null || requestParameters.groupId === undefined) {
            throw new runtime.RequiredError('groupId','Required parameter requestParameters.groupId was null or undefined when calling getGroupQuota.');
        }

        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling getGroupQuota.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/volumes/{id}/quotas/group/{group_id}`.replace(`{${"group_id"}}`, encodeURIComponent(String(requestParameters.groupId))).replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => QuotaFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `users:manage` 
     */
    async getGroupQuota(requestParameters: GetGroupQuotaRequest, initOverrides?: RequestInit): Promise<Quota> {
        const response = await this.getGroupQuotaRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `None` (read) / `projects:manage` (write) 
     */
    async getMyWorkspacesRaw(requestParameters: GetMyWorkspacesRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Array<Workspace>>> {
        const queryParameters: any = {};

        if (requestParameters.isTemplate !== undefined) {
            queryParameters['is_template'] = requestParameters.isTemplate;
        }

        if (requestParameters.production !== undefined) {
            queryParameters['production'] = requestParameters.production;
        }

        if (requestParameters.volume !== undefined) {
            queryParameters['volume'] = requestParameters.volume;
        }

        if (requestParameters.homeFor !== undefined) {
            queryParameters['home_for'] = requestParameters.homeFor;
        }

        if (requestParameters.volumeType !== undefined) {
            queryParameters['volume__type'] = requestParameters.volumeType;
        }

        if (requestParameters.productionName !== undefined) {
            queryParameters['production__name'] = requestParameters.productionName;
        }

        if (requestParameters.productionActive !== undefined) {
            queryParameters['production__active'] = requestParameters.productionActive;
        }

        if (requestParameters.name !== undefined) {
            queryParameters['name'] = requestParameters.name;
        }

        if (requestParameters.isExternal !== undefined) {
            queryParameters['is_external'] = requestParameters.isExternal;
        }

        if (requestParameters.active !== undefined) {
            queryParameters['active'] = requestParameters.active;
        }

        if (requestParameters.ordering !== undefined) {
            queryParameters['ordering'] = requestParameters.ordering;
        }

        if (requestParameters.limit !== undefined) {
            queryParameters['limit'] = requestParameters.limit;
        }

        if (requestParameters.offset !== undefined) {
            queryParameters['offset'] = requestParameters.offset;
        }

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/workspaces/mine`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(WorkspaceFromJSON));
    }

    /**
     * ### Required permissions    * User account permission: `None` (read) / `projects:manage` (write) 
     */
    async getMyWorkspaces(requestParameters: GetMyWorkspacesRequest, initOverrides?: RequestInit): Promise<Array<Workspace>> {
        const response = await this.getMyWorkspacesRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * Authenticated user 
     */
    async getPathQuotaRaw(requestParameters: GetPathQuotaRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Quota>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling getPathQuota.');
        }

        if (requestParameters.relativePath === null || requestParameters.relativePath === undefined) {
            throw new runtime.RequiredError('relativePath','Required parameter requestParameters.relativePath was null or undefined when calling getPathQuota.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/volumes/{id}/quotas/path/{relative_path}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))).replace(`{${"relative_path"}}`, encodeURIComponent(String(requestParameters.relativePath))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => QuotaFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * Authenticated user 
     */
    async getPathQuota(requestParameters: GetPathQuotaRequest, initOverrides?: RequestInit): Promise<Quota> {
        const response = await this.getPathQuotaRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `projects:view` (read) / `projects:manage` (write) 
     */
    async getProductionRaw(requestParameters: GetProductionRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Production>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling getProduction.');
        }

        const queryParameters: any = {};

        if (requestParameters.copyTemplateContent !== undefined) {
            queryParameters['copy_template_content'] = requestParameters.copyTemplateContent;
        }

        if (requestParameters.includeTotalSize !== undefined) {
            queryParameters['include_total_size'] = requestParameters.includeTotalSize;
        }

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/productions/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => ProductionFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `projects:view` (read) / `projects:manage` (write) 
     */
    async getProduction(requestParameters: GetProductionRequest, initOverrides?: RequestInit): Promise<Production> {
        const response = await this.getProductionRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * Authenticated user 
     */
    async getRootDirectoryRaw(requestParameters: GetRootDirectoryRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<void>> {
        const queryParameters: any = {};

        if (requestParameters.ordering !== undefined) {
            queryParameters['ordering'] = requestParameters.ordering;
        }

        if (requestParameters.limit !== undefined) {
            queryParameters['limit'] = requestParameters.limit;
        }

        if (requestParameters.offset !== undefined) {
            queryParameters['offset'] = requestParameters.offset;
        }

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/files`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * ### Required permissions    * Authenticated user 
     */
    async getRootDirectory(requestParameters: GetRootDirectoryRequest, initOverrides?: RequestInit): Promise<void> {
        await this.getRootDirectoryRaw(requestParameters, initOverrides);
    }

    /**
     * ### Required permissions    * localhost only 
     */
    async getSambaDfreeStringRaw(initOverrides?: RequestInit): Promise<runtime.ApiResponse<void>> {
        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/private/dfree`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * ### Required permissions    * localhost only 
     */
    async getSambaDfreeString(initOverrides?: RequestInit): Promise<void> {
        await this.getSambaDfreeStringRaw(initOverrides);
    }

    /**
     * ### Required permissions    * User account permission: `shares:view` (read) / `shares:manage` (write) 
     */
    async getShareRaw(requestParameters: GetShareRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Share>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling getShare.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/shares/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => ShareFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `shares:view` (read) / `shares:manage` (write) 
     */
    async getShare(requestParameters: GetShareRequest, initOverrides?: RequestInit): Promise<Share> {
        const response = await this.getShareRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `projects:view` (read) / `projects:manage` (write) 
     */
    async getSnapshotRaw(requestParameters: GetSnapshotRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Snapshot>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling getSnapshot.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/snapshots/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => SnapshotFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `projects:view` (read) / `projects:manage` (write) 
     */
    async getSnapshot(requestParameters: GetSnapshotRequest, initOverrides?: RequestInit): Promise<Snapshot> {
        const response = await this.getSnapshotRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `users:manage` 
     */
    async getUserQuotaRaw(requestParameters: GetUserQuotaRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Quota>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling getUserQuota.');
        }

        if (requestParameters.userId === null || requestParameters.userId === undefined) {
            throw new runtime.RequiredError('userId','Required parameter requestParameters.userId was null or undefined when calling getUserQuota.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/volumes/{id}/quotas/user/{user_id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))).replace(`{${"user_id"}}`, encodeURIComponent(String(requestParameters.userId))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => QuotaFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `users:manage` 
     */
    async getUserQuota(requestParameters: GetUserQuotaRequest, initOverrides?: RequestInit): Promise<Quota> {
        const response = await this.getUserQuotaRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `None` (read) / `system:admin-access` (write) 
     */
    async getVolumeRaw(requestParameters: GetVolumeRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Volume>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling getVolume.');
        }

        const queryParameters: any = {};

        if (requestParameters.includeStatus !== undefined) {
            queryParameters['include_status'] = requestParameters.includeStatus;
        }

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/volumes/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => VolumeFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `None` (read) / `system:admin-access` (write) 
     */
    async getVolume(requestParameters: GetVolumeRequest, initOverrides?: RequestInit): Promise<Volume> {
        const response = await this.getVolumeRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `system:status:view` 
     */
    async getVolumeActiveConnectionsRaw(requestParameters: GetVolumeActiveConnectionsRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<StorNextConnections>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling getVolumeActiveConnections.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/volumes/{id}/connections`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => StorNextConnectionsFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `system:status:view` 
     */
    async getVolumeActiveConnections(requestParameters: GetVolumeActiveConnectionsRequest, initOverrides?: RequestInit): Promise<StorNextConnections> {
        const response = await this.getVolumeActiveConnectionsRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `system:status:view` 
     */
    async getVolumeFileSizeDistributionRaw(requestParameters: GetVolumeFileSizeDistributionRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<FileSizeDistribution>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling getVolumeFileSizeDistribution.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/volumes/{id}/file-size-distribution`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => FileSizeDistributionFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `system:status:view` 
     */
    async getVolumeFileSizeDistribution(requestParameters: GetVolumeFileSizeDistributionRequest, initOverrides?: RequestInit): Promise<FileSizeDistribution> {
        const response = await this.getVolumeFileSizeDistributionRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `system:status:view` 
     */
    async getVolumeStatsRaw(requestParameters: GetVolumeStatsRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<VolumeStats>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling getVolumeStats.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/volumes/{id}/stats`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => VolumeStatsFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `system:status:view` 
     */
    async getVolumeStats(requestParameters: GetVolumeStatsRequest, initOverrides?: RequestInit): Promise<VolumeStats> {
        const response = await this.getVolumeStatsRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `None` (read) / `projects:manage` (write) 
     */
    async getWorkspaceRaw(requestParameters: GetWorkspaceRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<WorkspaceDetail>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling getWorkspace.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/workspaces/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => WorkspaceDetailFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `None` (read) / `projects:manage` (write) 
     */
    async getWorkspace(requestParameters: GetWorkspaceRequest, initOverrides?: RequestInit): Promise<WorkspaceDetail> {
        const response = await this.getWorkspaceRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `projects:view` (read) / `projects:manage` (write) 
     */
    async getWorkspacePermissionRaw(requestParameters: GetWorkspacePermissionRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<WorkspacePermission>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling getWorkspacePermission.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/workspace-permissions/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => WorkspacePermissionFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `projects:view` (read) / `projects:manage` (write) 
     */
    async getWorkspacePermission(requestParameters: GetWorkspacePermissionRequest, initOverrides?: RequestInit): Promise<WorkspacePermission> {
        const response = await this.getWorkspacePermissionRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * Authenticated user 
     */
    async moveFilesRaw(requestParameters: MoveFilesRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<TaskInfo>> {
        if (requestParameters.fileMoveEndpointRequest === null || requestParameters.fileMoveEndpointRequest === undefined) {
            throw new runtime.RequiredError('fileMoveEndpointRequest','Required parameter requestParameters.fileMoveEndpointRequest was null or undefined when calling moveFiles.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/filesystem/move`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: FileMoveEndpointRequestToJSON(requestParameters.fileMoveEndpointRequest),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => TaskInfoFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * Authenticated user 
     */
    async moveFiles(requestParameters: MoveFilesRequest, initOverrides?: RequestInit): Promise<TaskInfo> {
        const response = await this.moveFilesRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `projects:manage` 
     */
    async moveWorkspaceRaw(requestParameters: MoveWorkspaceOperationRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<TaskInfo>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling moveWorkspace.');
        }

        if (requestParameters.moveWorkspaceRequest === null || requestParameters.moveWorkspaceRequest === undefined) {
            throw new runtime.RequiredError('moveWorkspaceRequest','Required parameter requestParameters.moveWorkspaceRequest was null or undefined when calling moveWorkspace.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/workspaces/{id}/move`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: MoveWorkspaceRequestToJSON(requestParameters.moveWorkspaceRequest),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => TaskInfoFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `projects:manage` 
     */
    async moveWorkspace(requestParameters: MoveWorkspaceOperationRequest, initOverrides?: RequestInit): Promise<TaskInfo> {
        const response = await this.moveWorkspaceRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `projects:manage` 
     */
    async moveWorkspaceToProductionRaw(requestParameters: MoveWorkspaceToProductionRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling moveWorkspaceToProduction.');
        }

        if (requestParameters.workspaceMoveToRequest === null || requestParameters.workspaceMoveToRequest === undefined) {
            throw new runtime.RequiredError('workspaceMoveToRequest','Required parameter requestParameters.workspaceMoveToRequest was null or undefined when calling moveWorkspaceToProduction.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/workspaces/{id}/move-to`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: WorkspaceMoveToRequestToJSON(requestParameters.workspaceMoveToRequest),
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * ### Required permissions    * User account permission: `projects:manage` 
     */
    async moveWorkspaceToProduction(requestParameters: MoveWorkspaceToProductionRequest, initOverrides?: RequestInit): Promise<void> {
        await this.moveWorkspaceToProductionRaw(requestParameters, initOverrides);
    }

    /**
     * ### Required permissions    * Authenticated user 
     */
    async patchFileRaw(requestParameters: PatchFileRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<FilesystemFile>> {
        if (requestParameters.path === null || requestParameters.path === undefined) {
            throw new runtime.RequiredError('path','Required parameter requestParameters.path was null or undefined when calling patchFile.');
        }

        if (requestParameters.filePartialUpdate === null || requestParameters.filePartialUpdate === undefined) {
            throw new runtime.RequiredError('filePartialUpdate','Required parameter requestParameters.filePartialUpdate was null or undefined when calling patchFile.');
        }

        const queryParameters: any = {};

        if (requestParameters.maxDepth !== undefined) {
            queryParameters['max_depth'] = requestParameters.maxDepth;
        }

        if (requestParameters.bundle !== undefined) {
            queryParameters['bundle'] = requestParameters.bundle;
        }

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/files/{path}`.replace(`{${"path"}}`, encodeURIComponent(String(requestParameters.path))),
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
            body: FilePartialUpdateToJSON(requestParameters.filePartialUpdate),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => FilesystemFileFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * Authenticated user 
     */
    async patchFile(requestParameters: PatchFileRequest, initOverrides?: RequestInit): Promise<FilesystemFile> {
        const response = await this.patchFileRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `projects:view` (read) / `projects:manage` (write) 
     */
    async patchProductionRaw(requestParameters: PatchProductionRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Production>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling patchProduction.');
        }

        if (requestParameters.productionPartialUpdate === null || requestParameters.productionPartialUpdate === undefined) {
            throw new runtime.RequiredError('productionPartialUpdate','Required parameter requestParameters.productionPartialUpdate was null or undefined when calling patchProduction.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/productions/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
            body: ProductionPartialUpdateToJSON(requestParameters.productionPartialUpdate),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => ProductionFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `projects:view` (read) / `projects:manage` (write) 
     */
    async patchProduction(requestParameters: PatchProductionRequest, initOverrides?: RequestInit): Promise<Production> {
        const response = await this.patchProductionRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `shares:view` (read) / `shares:manage` (write) 
     */
    async patchShareRaw(requestParameters: PatchShareRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Share>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling patchShare.');
        }

        if (requestParameters.sharePartialUpdate === null || requestParameters.sharePartialUpdate === undefined) {
            throw new runtime.RequiredError('sharePartialUpdate','Required parameter requestParameters.sharePartialUpdate was null or undefined when calling patchShare.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/shares/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
            body: SharePartialUpdateToJSON(requestParameters.sharePartialUpdate),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => ShareFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `shares:view` (read) / `shares:manage` (write) 
     */
    async patchShare(requestParameters: PatchShareRequest, initOverrides?: RequestInit): Promise<Share> {
        const response = await this.patchShareRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `projects:view` (read) / `projects:manage` (write) 
     */
    async patchSnapshotRaw(requestParameters: PatchSnapshotRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Snapshot>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling patchSnapshot.');
        }

        if (requestParameters.snapshotPartialUpdate === null || requestParameters.snapshotPartialUpdate === undefined) {
            throw new runtime.RequiredError('snapshotPartialUpdate','Required parameter requestParameters.snapshotPartialUpdate was null or undefined when calling patchSnapshot.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/snapshots/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
            body: SnapshotPartialUpdateToJSON(requestParameters.snapshotPartialUpdate),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => SnapshotFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `projects:view` (read) / `projects:manage` (write) 
     */
    async patchSnapshot(requestParameters: PatchSnapshotRequest, initOverrides?: RequestInit): Promise<Snapshot> {
        const response = await this.patchSnapshotRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `None` (read) / `system:admin-access` (write) 
     */
    async patchVolumeRaw(requestParameters: PatchVolumeRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Volume>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling patchVolume.');
        }

        if (requestParameters.volumePartialUpdate === null || requestParameters.volumePartialUpdate === undefined) {
            throw new runtime.RequiredError('volumePartialUpdate','Required parameter requestParameters.volumePartialUpdate was null or undefined when calling patchVolume.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/volumes/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
            body: VolumePartialUpdateToJSON(requestParameters.volumePartialUpdate),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => VolumeFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `None` (read) / `system:admin-access` (write) 
     */
    async patchVolume(requestParameters: PatchVolumeRequest, initOverrides?: RequestInit): Promise<Volume> {
        const response = await this.patchVolumeRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `None` (read) / `projects:manage` (write) 
     */
    async patchWorkspaceRaw(requestParameters: PatchWorkspaceRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<WorkspaceDetail>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling patchWorkspace.');
        }

        if (requestParameters.workspaceDetailPartialUpdate === null || requestParameters.workspaceDetailPartialUpdate === undefined) {
            throw new runtime.RequiredError('workspaceDetailPartialUpdate','Required parameter requestParameters.workspaceDetailPartialUpdate was null or undefined when calling patchWorkspace.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/workspaces/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
            body: WorkspaceDetailPartialUpdateToJSON(requestParameters.workspaceDetailPartialUpdate),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => WorkspaceDetailFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `None` (read) / `projects:manage` (write) 
     */
    async patchWorkspace(requestParameters: PatchWorkspaceRequest, initOverrides?: RequestInit): Promise<WorkspaceDetail> {
        const response = await this.patchWorkspaceRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `projects:view` (read) / `projects:manage` (write) 
     */
    async patchWorkspacePermissionRaw(requestParameters: PatchWorkspacePermissionRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<WorkspacePermission>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling patchWorkspacePermission.');
        }

        if (requestParameters.workspacePermissionPartialUpdate === null || requestParameters.workspacePermissionPartialUpdate === undefined) {
            throw new runtime.RequiredError('workspacePermissionPartialUpdate','Required parameter requestParameters.workspacePermissionPartialUpdate was null or undefined when calling patchWorkspacePermission.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/workspace-permissions/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
            body: WorkspacePermissionPartialUpdateToJSON(requestParameters.workspacePermissionPartialUpdate),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => WorkspacePermissionFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `projects:view` (read) / `projects:manage` (write) 
     */
    async patchWorkspacePermission(requestParameters: PatchWorkspacePermissionRequest, initOverrides?: RequestInit): Promise<WorkspacePermission> {
        const response = await this.patchWorkspacePermissionRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `system:admin-access` 
     */
    async recordStorageTraceRaw(requestParameters: RecordStorageTraceRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<FilesystemTraceEndpointResponse>> {
        if (requestParameters.filesystemTraceEndpointRequest === null || requestParameters.filesystemTraceEndpointRequest === undefined) {
            throw new runtime.RequiredError('filesystemTraceEndpointRequest','Required parameter requestParameters.filesystemTraceEndpointRequest was null or undefined when calling recordStorageTrace.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/filesystem/trace`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: FilesystemTraceEndpointRequestToJSON(requestParameters.filesystemTraceEndpointRequest),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => FilesystemTraceEndpointResponseFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `system:admin-access` 
     */
    async recordStorageTrace(requestParameters: RecordStorageTraceRequest, initOverrides?: RequestInit): Promise<FilesystemTraceEndpointResponse> {
        const response = await this.recordStorageTraceRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `projects:manage` 
     */
    async repairWorkspacePermissionsRaw(requestParameters: RepairWorkspacePermissionsRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<TaskInfo>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling repairWorkspacePermissions.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/workspaces/{id}/repair-permissions`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => TaskInfoFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `projects:manage` 
     */
    async repairWorkspacePermissions(requestParameters: RepairWorkspacePermissionsRequest, initOverrides?: RequestInit): Promise<TaskInfo> {
        const response = await this.repairWorkspacePermissionsRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * Authenticated user 
     */
    async shareToHomeWorkspaceRaw(requestParameters: ShareToHomeWorkspaceRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.shareToHomeWorkspaceEndpointRequest === null || requestParameters.shareToHomeWorkspaceEndpointRequest === undefined) {
            throw new runtime.RequiredError('shareToHomeWorkspaceEndpointRequest','Required parameter requestParameters.shareToHomeWorkspaceEndpointRequest was null or undefined when calling shareToHomeWorkspace.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/share-to-home-workspace`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: ShareToHomeWorkspaceEndpointRequestToJSON(requestParameters.shareToHomeWorkspaceEndpointRequest),
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * ### Required permissions    * Authenticated user 
     */
    async shareToHomeWorkspace(requestParameters: ShareToHomeWorkspaceRequest, initOverrides?: RequestInit): Promise<void> {
        await this.shareToHomeWorkspaceRaw(requestParameters, initOverrides);
    }

    /**
     * ### Required permissions    * Authenticated user 
     */
    async unbookmarkWorkspaceRaw(requestParameters: UnbookmarkWorkspaceRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling unbookmarkWorkspace.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/workspaces/{id}/bookmark`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * ### Required permissions    * Authenticated user 
     */
    async unbookmarkWorkspace(requestParameters: UnbookmarkWorkspaceRequest, initOverrides?: RequestInit): Promise<void> {
        await this.unbookmarkWorkspaceRaw(requestParameters, initOverrides);
    }

    /**
     * ### Required permissions    * Authenticated user 
     */
    async unzipFileRaw(requestParameters: UnzipFileRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<TaskInfo>> {
        if (requestParameters.fileUnzipEndpointRequest === null || requestParameters.fileUnzipEndpointRequest === undefined) {
            throw new runtime.RequiredError('fileUnzipEndpointRequest','Required parameter requestParameters.fileUnzipEndpointRequest was null or undefined when calling unzipFile.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/filesystem/unzip`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: FileUnzipEndpointRequestToJSON(requestParameters.fileUnzipEndpointRequest),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => TaskInfoFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * Authenticated user 
     */
    async unzipFile(requestParameters: UnzipFileRequest, initOverrides?: RequestInit): Promise<TaskInfo> {
        const response = await this.unzipFileRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `users:manage` 
     */
    async updateGroupQuotaRaw(requestParameters: UpdateGroupQuotaRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.groupId === null || requestParameters.groupId === undefined) {
            throw new runtime.RequiredError('groupId','Required parameter requestParameters.groupId was null or undefined when calling updateGroupQuota.');
        }

        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling updateGroupQuota.');
        }

        if (requestParameters.updateQuotaRequest === null || requestParameters.updateQuotaRequest === undefined) {
            throw new runtime.RequiredError('updateQuotaRequest','Required parameter requestParameters.updateQuotaRequest was null or undefined when calling updateGroupQuota.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/volumes/{id}/quotas/group/{group_id}`.replace(`{${"group_id"}}`, encodeURIComponent(String(requestParameters.groupId))).replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: UpdateQuotaRequestToJSON(requestParameters.updateQuotaRequest),
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * ### Required permissions    * User account permission: `users:manage` 
     */
    async updateGroupQuota(requestParameters: UpdateGroupQuotaRequest, initOverrides?: RequestInit): Promise<void> {
        await this.updateGroupQuotaRaw(requestParameters, initOverrides);
    }

    /**
     * ### Required permissions    * Authenticated user 
     */
    async updatePathQuotaRaw(requestParameters: UpdatePathQuotaRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling updatePathQuota.');
        }

        if (requestParameters.relativePath === null || requestParameters.relativePath === undefined) {
            throw new runtime.RequiredError('relativePath','Required parameter requestParameters.relativePath was null or undefined when calling updatePathQuota.');
        }

        if (requestParameters.updateQuotaRequest === null || requestParameters.updateQuotaRequest === undefined) {
            throw new runtime.RequiredError('updateQuotaRequest','Required parameter requestParameters.updateQuotaRequest was null or undefined when calling updatePathQuota.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/volumes/{id}/quotas/path/{relative_path}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))).replace(`{${"relative_path"}}`, encodeURIComponent(String(requestParameters.relativePath))),
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: UpdateQuotaRequestToJSON(requestParameters.updateQuotaRequest),
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * ### Required permissions    * Authenticated user 
     */
    async updatePathQuota(requestParameters: UpdatePathQuotaRequest, initOverrides?: RequestInit): Promise<void> {
        await this.updatePathQuotaRaw(requestParameters, initOverrides);
    }

    /**
     * ### Required permissions    * User account permission: `projects:view` (read) / `projects:manage` (write) 
     */
    async updateProductionRaw(requestParameters: UpdateProductionRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Production>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling updateProduction.');
        }

        if (requestParameters.productionUpdate === null || requestParameters.productionUpdate === undefined) {
            throw new runtime.RequiredError('productionUpdate','Required parameter requestParameters.productionUpdate was null or undefined when calling updateProduction.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/productions/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: ProductionUpdateToJSON(requestParameters.productionUpdate),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => ProductionFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `projects:view` (read) / `projects:manage` (write) 
     */
    async updateProduction(requestParameters: UpdateProductionRequest, initOverrides?: RequestInit): Promise<Production> {
        const response = await this.updateProductionRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `shares:view` (read) / `shares:manage` (write) 
     */
    async updateShareRaw(requestParameters: UpdateShareRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Share>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling updateShare.');
        }

        if (requestParameters.shareUpdate === null || requestParameters.shareUpdate === undefined) {
            throw new runtime.RequiredError('shareUpdate','Required parameter requestParameters.shareUpdate was null or undefined when calling updateShare.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/shares/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: ShareUpdateToJSON(requestParameters.shareUpdate),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => ShareFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `shares:view` (read) / `shares:manage` (write) 
     */
    async updateShare(requestParameters: UpdateShareRequest, initOverrides?: RequestInit): Promise<Share> {
        const response = await this.updateShareRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `projects:view` (read) / `projects:manage` (write) 
     */
    async updateSnapshotRaw(requestParameters: UpdateSnapshotRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Snapshot>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling updateSnapshot.');
        }

        if (requestParameters.snapshotUpdate === null || requestParameters.snapshotUpdate === undefined) {
            throw new runtime.RequiredError('snapshotUpdate','Required parameter requestParameters.snapshotUpdate was null or undefined when calling updateSnapshot.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/snapshots/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: SnapshotUpdateToJSON(requestParameters.snapshotUpdate),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => SnapshotFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `projects:view` (read) / `projects:manage` (write) 
     */
    async updateSnapshot(requestParameters: UpdateSnapshotRequest, initOverrides?: RequestInit): Promise<Snapshot> {
        const response = await this.updateSnapshotRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `users:manage` 
     */
    async updateUserQuotaRaw(requestParameters: UpdateUserQuotaRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling updateUserQuota.');
        }

        if (requestParameters.userId === null || requestParameters.userId === undefined) {
            throw new runtime.RequiredError('userId','Required parameter requestParameters.userId was null or undefined when calling updateUserQuota.');
        }

        if (requestParameters.updateQuotaRequest === null || requestParameters.updateQuotaRequest === undefined) {
            throw new runtime.RequiredError('updateQuotaRequest','Required parameter requestParameters.updateQuotaRequest was null or undefined when calling updateUserQuota.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/volumes/{id}/quotas/user/{user_id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))).replace(`{${"user_id"}}`, encodeURIComponent(String(requestParameters.userId))),
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: UpdateQuotaRequestToJSON(requestParameters.updateQuotaRequest),
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * ### Required permissions    * User account permission: `users:manage` 
     */
    async updateUserQuota(requestParameters: UpdateUserQuotaRequest, initOverrides?: RequestInit): Promise<void> {
        await this.updateUserQuotaRaw(requestParameters, initOverrides);
    }

    /**
     * ### Required permissions    * User account permission: `None` (read) / `system:admin-access` (write) 
     */
    async updateVolumeRaw(requestParameters: UpdateVolumeRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Volume>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling updateVolume.');
        }

        if (requestParameters.volumeUpdate === null || requestParameters.volumeUpdate === undefined) {
            throw new runtime.RequiredError('volumeUpdate','Required parameter requestParameters.volumeUpdate was null or undefined when calling updateVolume.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/volumes/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: VolumeUpdateToJSON(requestParameters.volumeUpdate),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => VolumeFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `None` (read) / `system:admin-access` (write) 
     */
    async updateVolume(requestParameters: UpdateVolumeRequest, initOverrides?: RequestInit): Promise<Volume> {
        const response = await this.updateVolumeRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `None` (read) / `projects:manage` (write) 
     */
    async updateWorkspaceRaw(requestParameters: UpdateWorkspaceRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<WorkspaceDetail>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling updateWorkspace.');
        }

        if (requestParameters.workspaceDetailUpdate === null || requestParameters.workspaceDetailUpdate === undefined) {
            throw new runtime.RequiredError('workspaceDetailUpdate','Required parameter requestParameters.workspaceDetailUpdate was null or undefined when calling updateWorkspace.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/workspaces/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: WorkspaceDetailUpdateToJSON(requestParameters.workspaceDetailUpdate),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => WorkspaceDetailFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `None` (read) / `projects:manage` (write) 
     */
    async updateWorkspace(requestParameters: UpdateWorkspaceRequest, initOverrides?: RequestInit): Promise<WorkspaceDetail> {
        const response = await this.updateWorkspaceRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `projects:view` (read) / `projects:manage` (write) 
     */
    async updateWorkspacePermissionRaw(requestParameters: UpdateWorkspacePermissionRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<WorkspacePermission>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling updateWorkspacePermission.');
        }

        if (requestParameters.workspacePermissionUpdate === null || requestParameters.workspacePermissionUpdate === undefined) {
            throw new runtime.RequiredError('workspacePermissionUpdate','Required parameter requestParameters.workspacePermissionUpdate was null or undefined when calling updateWorkspacePermission.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/workspace-permissions/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: WorkspacePermissionUpdateToJSON(requestParameters.workspacePermissionUpdate),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => WorkspacePermissionFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `projects:view` (read) / `projects:manage` (write) 
     */
    async updateWorkspacePermission(requestParameters: UpdateWorkspacePermissionRequest, initOverrides?: RequestInit): Promise<WorkspacePermission> {
        const response = await this.updateWorkspacePermissionRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * Authenticated user 
     */
    async zipFilesRaw(requestParameters: ZipFilesRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<TaskInfo>> {
        if (requestParameters.fileZipEndpointRequest === null || requestParameters.fileZipEndpointRequest === undefined) {
            throw new runtime.RequiredError('fileZipEndpointRequest','Required parameter requestParameters.fileZipEndpointRequest was null or undefined when calling zipFiles.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/filesystem/zip`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: FileZipEndpointRequestToJSON(requestParameters.fileZipEndpointRequest),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => TaskInfoFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * Authenticated user 
     */
    async zipFiles(requestParameters: ZipFilesRequest, initOverrides?: RequestInit): Promise<TaskInfo> {
        const response = await this.zipFilesRaw(requestParameters, initOverrides);
        return await response.value();
    }

}