/* 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 {
    Certificate,
    CertificateFromJSON,
    CertificateToJSON,
    CertificateUpdate,
    CertificateUpdateFromJSON,
    CertificateUpdateToJSON,
    ChangeOwnPasswordRequest,
    ChangeOwnPasswordRequestFromJSON,
    ChangeOwnPasswordRequestToJSON,
    ChangePasswordRequest,
    ChangePasswordRequestFromJSON,
    ChangePasswordRequestToJSON,
    CheckConnectivityEndpointResponse,
    CheckConnectivityEndpointResponseFromJSON,
    CheckConnectivityEndpointResponseToJSON,
    ClientSession,
    ClientSessionFromJSON,
    ClientSessionToJSON,
    ClientsEndpointResponse,
    ClientsEndpointResponseFromJSON,
    ClientsEndpointResponseToJSON,
    CloudAccount,
    CloudAccountFromJSON,
    CloudAccountToJSON,
    CloudAccountPartialUpdate,
    CloudAccountPartialUpdateFromJSON,
    CloudAccountPartialUpdateToJSON,
    CloudAccountUpdate,
    CloudAccountUpdateFromJSON,
    CloudAccountUpdateToJSON,
    CreateDownloadArchive,
    CreateDownloadArchiveFromJSON,
    CreateDownloadArchiveToJSON,
    CreateHomeWorkspaceRequest,
    CreateHomeWorkspaceRequestFromJSON,
    CreateHomeWorkspaceRequestToJSON,
    Download,
    DownloadFromJSON,
    DownloadToJSON,
    DownloadArchive,
    DownloadArchiveFromJSON,
    DownloadArchiveToJSON,
    DownloadArchivePartialUpdate,
    DownloadArchivePartialUpdateFromJSON,
    DownloadArchivePartialUpdateToJSON,
    DownloadArchiveUpdate,
    DownloadArchiveUpdateFromJSON,
    DownloadArchiveUpdateToJSON,
    ElementsGroup,
    ElementsGroupFromJSON,
    ElementsGroupToJSON,
    ElementsGroupDetail,
    ElementsGroupDetailFromJSON,
    ElementsGroupDetailToJSON,
    ElementsGroupDetailPartialUpdate,
    ElementsGroupDetailPartialUpdateFromJSON,
    ElementsGroupDetailPartialUpdateToJSON,
    ElementsGroupDetailUpdate,
    ElementsGroupDetailUpdateFromJSON,
    ElementsGroupDetailUpdateToJSON,
    ElementsUser,
    ElementsUserFromJSON,
    ElementsUserToJSON,
    ElementsUserDetail,
    ElementsUserDetailFromJSON,
    ElementsUserDetailToJSON,
    ElementsUserDetailPartialUpdate,
    ElementsUserDetailPartialUpdateFromJSON,
    ElementsUserDetailPartialUpdateToJSON,
    ElementsUserDetailUpdate,
    ElementsUserDetailUpdateFromJSON,
    ElementsUserDetailUpdateToJSON,
    ElementsUserProfile,
    ElementsUserProfileFromJSON,
    ElementsUserProfileToJSON,
    ElementsUserProfilePartialUpdate,
    ElementsUserProfilePartialUpdateFromJSON,
    ElementsUserProfilePartialUpdateToJSON,
    ElementsUserProfileUpdate,
    ElementsUserProfileUpdateFromJSON,
    ElementsUserProfileUpdateToJSON,
    EmailPreview,
    EmailPreviewFromJSON,
    EmailPreviewToJSON,
    EnableTOTPRequest,
    EnableTOTPRequestFromJSON,
    EnableTOTPRequestToJSON,
    FilesystemPermission,
    FilesystemPermissionFromJSON,
    FilesystemPermissionToJSON,
    FilesystemPermissionPartialUpdate,
    FilesystemPermissionPartialUpdateFromJSON,
    FilesystemPermissionPartialUpdateToJSON,
    FilesystemPermissionUpdate,
    FilesystemPermissionUpdateFromJSON,
    FilesystemPermissionUpdateToJSON,
    FinishUploadEndpointRequest,
    FinishUploadEndpointRequestFromJSON,
    FinishUploadEndpointRequestToJSON,
    Ipmi,
    IpmiFromJSON,
    IpmiToJSON,
    LDAPServer,
    LDAPServerFromJSON,
    LDAPServerToJSON,
    LDAPServerGroups,
    LDAPServerGroupsFromJSON,
    LDAPServerGroupsToJSON,
    LDAPServerUsers,
    LDAPServerUsersFromJSON,
    LDAPServerUsersToJSON,
    License,
    LicenseFromJSON,
    LicenseToJSON,
    NTPServer,
    NTPServerFromJSON,
    NTPServerToJSON,
    NTPServerPartialUpdate,
    NTPServerPartialUpdateFromJSON,
    NTPServerPartialUpdateToJSON,
    NTPServerUpdate,
    NTPServerUpdateFromJSON,
    NTPServerUpdateToJSON,
    Parameters,
    ParametersFromJSON,
    ParametersToJSON,
    ParametersUpdate,
    ParametersUpdateFromJSON,
    ParametersUpdateToJSON,
    Path,
    PathFromJSON,
    PathToJSON,
    RegisterUploadEndpointRequest,
    RegisterUploadEndpointRequestFromJSON,
    RegisterUploadEndpointRequestToJSON,
    RegisterUploadMetadataEndpointRequest,
    RegisterUploadMetadataEndpointRequestFromJSON,
    RegisterUploadMetadataEndpointRequestToJSON,
    ReleaseNotesEndpointResponse,
    ReleaseNotesEndpointResponseFromJSON,
    ReleaseNotesEndpointResponseToJSON,
    SMTPConfiguration,
    SMTPConfigurationFromJSON,
    SMTPConfigurationToJSON,
    SMTPConfigurationUpdate,
    SMTPConfigurationUpdateFromJSON,
    SMTPConfigurationUpdateToJSON,
    Sensors,
    SensorsFromJSON,
    SensorsToJSON,
    ServiceStatus,
    ServiceStatusFromJSON,
    ServiceStatusToJSON,
    SolrReindexEndpointResponse,
    SolrReindexEndpointResponseFromJSON,
    SolrReindexEndpointResponseToJSON,
    Stats,
    StatsFromJSON,
    StatsToJSON,
    StorNextLicenseCheckEndpointResponse,
    StorNextLicenseCheckEndpointResponseFromJSON,
    StorNextLicenseCheckEndpointResponseToJSON,
    StorNextLicenseEndpointResponse,
    StorNextLicenseEndpointResponseFromJSON,
    StorNextLicenseEndpointResponseToJSON,
    StorageNode,
    StorageNodeFromJSON,
    StorageNodeToJSON,
    StorageRoot,
    StorageRootFromJSON,
    StorageRootToJSON,
    StornextLicense,
    StornextLicenseFromJSON,
    StornextLicenseToJSON,
    SyncTOTP,
    SyncTOTPFromJSON,
    SyncTOTPToJSON,
    SyncTOTPRequest,
    SyncTOTPRequestFromJSON,
    SyncTOTPRequestToJSON,
    SystemInfoEndpointResponse,
    SystemInfoEndpointResponseFromJSON,
    SystemInfoEndpointResponseToJSON,
    TaskInfo,
    TaskInfoFromJSON,
    TaskInfoToJSON,
    TestCloudAccountCredentialsRequest,
    TestCloudAccountCredentialsRequestFromJSON,
    TestCloudAccountCredentialsRequestToJSON,
    TestCloudAccountCredentialsResponse,
    TestCloudAccountCredentialsResponseFromJSON,
    TestCloudAccountCredentialsResponseToJSON,
    TestSMTP,
    TestSMTPFromJSON,
    TestSMTPToJSON,
    TimeEndpointRequest,
    TimeEndpointRequestFromJSON,
    TimeEndpointRequestToJSON,
    TimeEndpointResponse,
    TimeEndpointResponseFromJSON,
    TimeEndpointResponseToJSON,
    TimeSyncEndpointRequest,
    TimeSyncEndpointRequestFromJSON,
    TimeSyncEndpointRequestToJSON,
    TimeSyncEndpointResponse,
    TimeSyncEndpointResponseFromJSON,
    TimeSyncEndpointResponseToJSON,
    UploadChunkEndpointRequest,
    UploadChunkEndpointRequestFromJSON,
    UploadChunkEndpointRequestToJSON,
    UserPreviewRequest,
    UserPreviewRequestFromJSON,
    UserPreviewRequestToJSON,
    UserPreviewResponse,
    UserPreviewResponseFromJSON,
    UserPreviewResponseToJSON,
    Workspace,
    WorkspaceFromJSON,
    WorkspaceToJSON,
    Workstation,
    WorkstationFromJSON,
    WorkstationToJSON,
    WorkstationPartialUpdate,
    WorkstationPartialUpdateFromJSON,
    WorkstationPartialUpdateToJSON,
    WorkstationUpdate,
    WorkstationUpdateFromJSON,
    WorkstationUpdateToJSON,
} from '../models';

export interface CheckCertificateRequest {
    certificate: Certificate;
}

export interface CheckChunkUploadedRequest {
    uploadId?: string;
    chunkNumber?: string;
}

export interface CheckStorNextLicenseRequest {
    stornextLicense: StornextLicense;
}

export interface CreateArchiveRequest {
    createDownloadArchive: CreateDownloadArchive;
}

export interface CreateCloudAccountRequest {
    cloudAccountUpdate: CloudAccountUpdate;
}

export interface CreateFilesystemPermissionRequest {
    filesystemPermissionUpdate: FilesystemPermissionUpdate;
}

export interface CreateGroupRequest {
    elementsGroupDetailUpdate: ElementsGroupDetailUpdate;
}

export interface CreateHomeWorkspaceOperationRequest {
    id: number;
    createHomeWorkspaceRequest: CreateHomeWorkspaceRequest;
}

export interface CreateNTPServerRequest {
    nTPServerUpdate: NTPServerUpdate;
}

export interface CreateUserRequest {
    elementsUserDetailUpdate: ElementsUserDetailUpdate;
}

export interface CreateWorkstationRequest {
    workstationUpdate: WorkstationUpdate;
}

export interface DeleteCloudAccountRequest {
    id: number;
}

export interface DeleteDownloadArchiveRequest {
    id: string;
}

export interface DeleteFilesystemPermissionRequest {
    id: number;
}

export interface DeleteGroupRequest {
    id: number;
}

export interface DeleteHomeWorkspaceRequest {
    id: number;
}

export interface DeleteNTPServerRequest {
    id: number;
}

export interface DeleteUserRequest {
    id: number;
}

export interface DeleteWorkstationRequest {
    id: string;
}

export interface DisableUserTOTPRequest {
    id: number;
}

export interface EnableUserTOTPRequest {
    id: number;
    enableTOTPRequest: EnableTOTPRequest;
}

export interface FinishUploadRequest {
    finishUploadEndpointRequest: FinishUploadEndpointRequest;
}

export interface FixLDAPGroupMembershipsRequest {
    id: number;
}

export interface GetAllClientSessionsRequest {
    user?: number;
    mountedWorkspacesMountNode?: number;
    workstation?: string;
    ordering?: string;
    limit?: number;
    offset?: number;
}

export interface GetAllCloudAccountsRequest {
    name?: string;
    provider?: string;
    ordering?: string;
    limit?: number;
    offset?: number;
}

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

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

export interface GetAllFilesystemPermissionsRequest {
    user?: number;
    group?: number;
    ordering?: string;
    limit?: number;
    offset?: number;
    forUser?: number;
}

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

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

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

export interface GetAllStorageNodesRequest {
    type?: string;
    backend?: string;
    name?: string;
    address?: string;
    ordering?: string;
    limit?: number;
    offset?: number;
    includeStatus?: boolean;
}

export interface GetAllUsersRequest {
    username?: string;
    home?: string;
    fullName?: string;
    ordering?: string;
    limit?: number;
    offset?: number;
    includeAllowedFsPaths?: boolean;
}

export interface GetAllWorkstationsRequest {
    hostname?: string;
    name?: string;
    ordering?: string;
    limit?: number;
    offset?: number;
}

export interface GetClientDownloadFileRequest {
    file: string;
}

export interface GetClientSessionRequest {
    id: number;
}

export interface GetCloudAccountRequest {
    id: number;
}

export interface GetCloudAccountStorageRootsRequest {
    id: number;
}

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

export interface GetDownloadRequest {
    id: number;
}

export interface GetDownloadArchiveRequest {
    id: string;
}

export interface GetDownloadArchiveFileRequest {
    id: string;
}

export interface GetDownloadFileRequest {
    id: number;
}

export interface GetDownloadIconRequest {
    id: number;
}

export interface GetFilesystemPermissionRequest {
    id: number;
}

export interface GetGroupRequest {
    id: number;
}

export interface GetHomeWorkspaceRequest {
    id: number;
}

export interface GetIPMIConfigurationRequest {
    id: number;
}

export interface GetLDAPServerRequest {
    id: number;
}

export interface GetLDAPServerGroupsRequest {
    id: number;
}

export interface GetLDAPServerUsersRequest {
    id: number;
}

export interface GetLogRequest {
    path: string;
    offset?: number;
}

export interface GetNTPServerRequest {
    id: number;
}

export interface GetNodeIPMISensorsRequest {
    id: number;
}

export interface GetNodeStatsRequest {
    id: number;
}

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

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

export interface GetServiceStatusRequest {
    id: number;
    service: string;
}

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

export interface GetUserRequest {
    id: number;
    includeAllowedFsPaths?: boolean;
}

export interface GetWorkstationRequest {
    id: string;
}

export interface InstallStorNextLicenseRequest {
    stornextLicense: StornextLicense;
}

export interface PatchCloudAccountRequest {
    id: number;
    cloudAccountPartialUpdate: CloudAccountPartialUpdate;
}

export interface PatchCurrentWorkstationRequest {
    workstationPartialUpdate: WorkstationPartialUpdate;
}

export interface PatchDownloadArchiveRequest {
    id: string;
    downloadArchivePartialUpdate: DownloadArchivePartialUpdate;
}

export interface PatchFilesystemPermissionRequest {
    id: number;
    filesystemPermissionPartialUpdate: FilesystemPermissionPartialUpdate;
}

export interface PatchGroupRequest {
    id: number;
    elementsGroupDetailPartialUpdate: ElementsGroupDetailPartialUpdate;
}

export interface PatchNTPServerRequest {
    id: number;
    nTPServerPartialUpdate: NTPServerPartialUpdate;
}

export interface PatchProfileRequest {
    elementsUserProfilePartialUpdate: ElementsUserProfilePartialUpdate;
}

export interface PatchUserRequest {
    id: number;
    elementsUserDetailPartialUpdate: ElementsUserDetailPartialUpdate;
}

export interface PatchWorkstationRequest {
    id: string;
    workstationPartialUpdate: WorkstationPartialUpdate;
}

export interface PreviewUserRequest {
    userPreviewRequest: UserPreviewRequest;
}

export interface RegisterUploadRequest {
    registerUploadEndpointRequest: RegisterUploadEndpointRequest;
}

export interface RegisterUploadMetadataRequest {
    registerUploadMetadataEndpointRequest: RegisterUploadMetadataEndpointRequest;
}

export interface RenderEmailTemplatePreviewRequest {
    emailPreview: EmailPreview;
}

export interface ResetUserPasswordRequest {
    id: number;
}

export interface RunServiceOperationRequest {
    id: number;
    operation: string;
    service: string;
}

export interface SetIPMIConfigurationRequest {
    id: number;
    ipmi: Ipmi;
}

export interface SetLocalTimeRequest {
    timeEndpointRequest: TimeEndpointRequest;
}

export interface SetMyPasswordRequest {
    changeOwnPasswordRequest: ChangeOwnPasswordRequest;
}

export interface SetUserPasswordRequest {
    id: number;
    changePasswordRequest: ChangePasswordRequest;
}

export interface StartSystemBackupRequest {
    path: Path;
}

export interface SyncLDAPGroupRequest {
    id: number;
}

export interface SyncLDAPUsersRequest {
    id: number;
}

export interface SyncTimeRequest {
    timeSyncEndpointRequest: TimeSyncEndpointRequest;
}

export interface SyncUserTOTPRequest {
    id: number;
    syncTOTPRequest: SyncTOTPRequest;
}

export interface TestCloudAccountCredentialsOperationRequest {
    testCloudAccountCredentialsRequest: TestCloudAccountCredentialsRequest;
}

export interface TestSMTPConfigurationRequest {
    testSMTP: TestSMTP;
}

export interface UpdateCertificateConfigurationRequest {
    certificateUpdate: CertificateUpdate;
}

export interface UpdateCloudAccountRequest {
    id: number;
    cloudAccountUpdate: CloudAccountUpdate;
}

export interface UpdateCurrentWorkstationRequest {
    workstationUpdate: WorkstationUpdate;
}

export interface UpdateDownloadArchiveRequest {
    id: string;
    downloadArchiveUpdate: DownloadArchiveUpdate;
}

export interface UpdateFilesystemPermissionRequest {
    id: number;
    filesystemPermissionUpdate: FilesystemPermissionUpdate;
}

export interface UpdateGroupRequest {
    id: number;
    elementsGroupDetailUpdate: ElementsGroupDetailUpdate;
}

export interface UpdateNTPServerRequest {
    id: number;
    nTPServerUpdate: NTPServerUpdate;
}

export interface UpdateParametersRequest {
    parametersUpdate: ParametersUpdate;
}

export interface UpdateProfileRequest {
    elementsUserProfileUpdate: ElementsUserProfileUpdate;
}

export interface UpdateSMTPConfigurationRequest {
    sMTPConfigurationUpdate: SMTPConfigurationUpdate;
}

export interface UpdateUserRequest {
    id: number;
    elementsUserDetailUpdate: ElementsUserDetailUpdate;
}

export interface UpdateWorkstationRequest {
    id: string;
    workstationUpdate: WorkstationUpdate;
}

export interface UploadChunkRequest {
    uploadChunkEndpointRequest: UploadChunkEndpointRequest;
}

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

    /**
     * ### Required permissions    * Authenticated user 
     */
    async applyConfigurationRaw(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/configuration/apply`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * ### Required permissions    * Authenticated user 
     */
    async applyConfiguration(initOverrides?: RequestInit): Promise<void> {
        await this.applyConfigurationRaw(initOverrides);
    }

    /**
     * ### Required permissions    * User account permission: `system:admin-access` 
     */
    async beepRaw(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/system/beep`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * ### Required permissions    * User account permission: `system:admin-access` 
     */
    async beep(initOverrides?: RequestInit): Promise<void> {
        await this.beepRaw(initOverrides);
    }

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

        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/system/certificate/check`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: CertificateToJSON(requestParameters.certificate),
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * ### Required permissions    * User account permission: `system:admin-access` 
     */
    async checkCertificate(requestParameters: CheckCertificateRequest, initOverrides?: RequestInit): Promise<void> {
        await this.checkCertificateRaw(requestParameters, initOverrides);
    }

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

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

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

        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/uploads/chunk`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

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

    /**
     * ### Required permissions    * User account permission: `system:admin-access` 
     */
    async checkInternetConnectivityRaw(initOverrides?: RequestInit): Promise<runtime.ApiResponse<CheckConnectivityEndpointResponse>> {
        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/system/check-connectivity`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

    /**
     * ### Required permissions    * User account permission: `system:admin-access` 
     */
    async checkInternetConnectivity(initOverrides?: RequestInit): Promise<CheckConnectivityEndpointResponse> {
        const response = await this.checkInternetConnectivityRaw(initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `system:admin-access`   * License component: stornext_mdc 
     */
    async checkStorNextLicenseRaw(requestParameters: CheckStorNextLicenseRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Array<StorNextLicenseCheckEndpointResponse>>> {
        if (requestParameters.stornextLicense === null || requestParameters.stornextLicense === undefined) {
            throw new runtime.RequiredError('stornextLicense','Required parameter requestParameters.stornextLicense was null or undefined when calling checkStorNextLicense.');
        }

        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/stornext-license/check`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: StornextLicenseToJSON(requestParameters.stornextLicense),
        }, initOverrides);

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

    /**
     * ### Required permissions    * User account permission: `system:admin-access`   * License component: stornext_mdc 
     */
    async checkStorNextLicense(requestParameters: CheckStorNextLicenseRequest, initOverrides?: RequestInit): Promise<Array<StorNextLicenseCheckEndpointResponse>> {
        const response = await this.checkStorNextLicenseRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `system:admin-access` 
     */
    async collectDiagnosticsRaw(initOverrides?: RequestInit): Promise<runtime.ApiResponse<DownloadArchive>> {
        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/system/collect-diagnostics`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

    /**
     * ### Required permissions    * User account permission: `system:admin-access` 
     */
    async collectDiagnostics(initOverrides?: RequestInit): Promise<DownloadArchive> {
        const response = await this.collectDiagnosticsRaw(initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * Authenticated user 
     */
    async createArchiveRaw(requestParameters: CreateArchiveRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<DownloadArchive>> {
        if (requestParameters.createDownloadArchive === null || requestParameters.createDownloadArchive === undefined) {
            throw new runtime.RequiredError('createDownloadArchive','Required parameter requestParameters.createDownloadArchive was null or undefined when calling createArchive.');
        }

        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/download-archive/create`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: CreateDownloadArchiveToJSON(requestParameters.createDownloadArchive),
        }, initOverrides);

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

    /**
     * ### Required permissions    * Authenticated user 
     */
    async createArchive(requestParameters: CreateArchiveRequest, initOverrides?: RequestInit): Promise<DownloadArchive> {
        const response = await this.createArchiveRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * Authenticated user 
     */
    async createCloudAccountRaw(requestParameters: CreateCloudAccountRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<CloudAccount>> {
        if (requestParameters.cloudAccountUpdate === null || requestParameters.cloudAccountUpdate === undefined) {
            throw new runtime.RequiredError('cloudAccountUpdate','Required parameter requestParameters.cloudAccountUpdate was null or undefined when calling createCloudAccount.');
        }

        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/cloud/accounts`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: CloudAccountUpdateToJSON(requestParameters.cloudAccountUpdate),
        }, initOverrides);

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

    /**
     * ### Required permissions    * Authenticated user 
     */
    async createCloudAccount(requestParameters: CreateCloudAccountRequest, initOverrides?: RequestInit): Promise<CloudAccount> {
        const response = await this.createCloudAccountRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `None` (read) / `users:manage` (write) 
     */
    async createFilesystemPermissionRaw(requestParameters: CreateFilesystemPermissionRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<FilesystemPermission>> {
        if (requestParameters.filesystemPermissionUpdate === null || requestParameters.filesystemPermissionUpdate === undefined) {
            throw new runtime.RequiredError('filesystemPermissionUpdate','Required parameter requestParameters.filesystemPermissionUpdate was null or undefined when calling createFilesystemPermission.');
        }

        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-permissions`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: FilesystemPermissionUpdateToJSON(requestParameters.filesystemPermissionUpdate),
        }, initOverrides);

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

    /**
     * ### Required permissions    * User account permission: `None` (read) / `users:manage` (write) 
     */
    async createFilesystemPermission(requestParameters: CreateFilesystemPermissionRequest, initOverrides?: RequestInit): Promise<FilesystemPermission> {
        const response = await this.createFilesystemPermissionRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `users:view` (read) / `users:manage` (write) 
     */
    async createGroupRaw(requestParameters: CreateGroupRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<ElementsGroupDetail>> {
        if (requestParameters.elementsGroupDetailUpdate === null || requestParameters.elementsGroupDetailUpdate === undefined) {
            throw new runtime.RequiredError('elementsGroupDetailUpdate','Required parameter requestParameters.elementsGroupDetailUpdate was null or undefined when calling createGroup.');
        }

        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/groups`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: ElementsGroupDetailUpdateToJSON(requestParameters.elementsGroupDetailUpdate),
        }, initOverrides);

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

    /**
     * ### Required permissions    * User account permission: `users:view` (read) / `users:manage` (write) 
     */
    async createGroup(requestParameters: CreateGroupRequest, initOverrides?: RequestInit): Promise<ElementsGroupDetail> {
        const response = await this.createGroupRaw(requestParameters, initOverrides);
        return await response.value();
    }

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

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

        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/users/{id}/home`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: CreateHomeWorkspaceRequestToJSON(requestParameters.createHomeWorkspaceRequest),
        }, initOverrides);

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

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

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

        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/system/time/servers`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: NTPServerUpdateToJSON(requestParameters.nTPServerUpdate),
        }, initOverrides);

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

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

    /**
     * ### Required permissions    * User account permission: `None` (read) / `users:manage` (write) 
     */
    async createUserRaw(requestParameters: CreateUserRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<ElementsUserDetail>> {
        if (requestParameters.elementsUserDetailUpdate === null || requestParameters.elementsUserDetailUpdate === undefined) {
            throw new runtime.RequiredError('elementsUserDetailUpdate','Required parameter requestParameters.elementsUserDetailUpdate was null or undefined when calling createUser.');
        }

        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/users`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: ElementsUserDetailUpdateToJSON(requestParameters.elementsUserDetailUpdate),
        }, initOverrides);

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

    /**
     * ### Required permissions    * User account permission: `None` (read) / `users:manage` (write) 
     */
    async createUser(requestParameters: CreateUserRequest, initOverrides?: RequestInit): Promise<ElementsUserDetail> {
        const response = await this.createUserRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * Authenticated user   * Own workstation or User account permission: `workstations:view` (read) / `workstations:manage` (write) 
     */
    async createWorkstationRaw(requestParameters: CreateWorkstationRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Workstation>> {
        if (requestParameters.workstationUpdate === null || requestParameters.workstationUpdate === undefined) {
            throw new runtime.RequiredError('workstationUpdate','Required parameter requestParameters.workstationUpdate was null or undefined when calling createWorkstation.');
        }

        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/workstations`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: WorkstationUpdateToJSON(requestParameters.workstationUpdate),
        }, initOverrides);

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

    /**
     * ### Required permissions    * Authenticated user   * Own workstation or User account permission: `workstations:view` (read) / `workstations:manage` (write) 
     */
    async createWorkstation(requestParameters: CreateWorkstationRequest, initOverrides?: RequestInit): Promise<Workstation> {
        const response = await this.createWorkstationRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * Authenticated user 
     */
    async deleteCloudAccountRaw(requestParameters: DeleteCloudAccountRequest, 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 deleteCloudAccount.');
        }

        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/cloud/accounts/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

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

    /**
     * ### Required permissions    * Authenticated user 
     */
    async deleteDownloadArchiveRaw(requestParameters: DeleteDownloadArchiveRequest, 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 deleteDownloadArchive.');
        }

        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/download-archive/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

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

    /**
     * ### Required permissions    * User account permission: `None` (read) / `users:manage` (write) 
     */
    async deleteFilesystemPermissionRaw(requestParameters: DeleteFilesystemPermissionRequest, 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 deleteFilesystemPermission.');
        }

        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/filesystem-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: `None` (read) / `users:manage` (write) 
     */
    async deleteFilesystemPermission(requestParameters: DeleteFilesystemPermissionRequest, initOverrides?: RequestInit): Promise<void> {
        await this.deleteFilesystemPermissionRaw(requestParameters, initOverrides);
    }

    /**
     * ### Required permissions    * User account permission: `users:view` (read) / `users:manage` (write) 
     */
    async deleteGroupRaw(requestParameters: DeleteGroupRequest, 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 deleteGroup.');
        }

        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/groups/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

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

    /**
     * ### Required permissions    * User account permission: `users:manage` 
     */
    async deleteHomeWorkspaceRaw(requestParameters: DeleteHomeWorkspaceRequest, 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 deleteHomeWorkspace.');
        }

        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/users/{id}/home`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

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

    /**
     * ### Required permissions    * User account permission: `system:admin-access` 
     */
    async deleteNTPServerRaw(requestParameters: DeleteNTPServerRequest, 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 deleteNTPServer.');
        }

        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/system/time/servers/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * ### Required permissions    * User account permission: `system:admin-access` 
     */
    async deleteNTPServer(requestParameters: DeleteNTPServerRequest, initOverrides?: RequestInit): Promise<void> {
        await this.deleteNTPServerRaw(requestParameters, initOverrides);
    }

    /**
     * ### Required permissions    * User account permission: `None` (read) / `users:manage` (write) 
     */
    async deleteUserRaw(requestParameters: DeleteUserRequest, 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 deleteUser.');
        }

        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/users/{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) / `users:manage` (write) 
     */
    async deleteUser(requestParameters: DeleteUserRequest, initOverrides?: RequestInit): Promise<void> {
        await this.deleteUserRaw(requestParameters, initOverrides);
    }

    /**
     * ### Required permissions    * Authenticated user   * Own workstation or User account permission: `workstations:view` (read) / `workstations:manage` (write) 
     */
    async deleteWorkstationRaw(requestParameters: DeleteWorkstationRequest, 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 deleteWorkstation.');
        }

        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/workstations/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * ### Required permissions    * Authenticated user   * Own workstation or User account permission: `workstations:view` (read) / `workstations:manage` (write) 
     */
    async deleteWorkstation(requestParameters: DeleteWorkstationRequest, initOverrides?: RequestInit): Promise<void> {
        await this.deleteWorkstationRaw(requestParameters, initOverrides);
    }

    /**
     */
    async disableUserTOTPRaw(requestParameters: DisableUserTOTPRequest, 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 disableUserTOTP.');
        }

        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/users/{id}/totp`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     */
    async disableUserTOTP(requestParameters: DisableUserTOTPRequest, initOverrides?: RequestInit): Promise<void> {
        await this.disableUserTOTPRaw(requestParameters, initOverrides);
    }

    /**
     */
    async enableUserTOTPRaw(requestParameters: EnableUserTOTPRequest, 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 enableUserTOTP.');
        }

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

        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/users/{id}/totp`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: EnableTOTPRequestToJSON(requestParameters.enableTOTPRequest),
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     */
    async enableUserTOTP(requestParameters: EnableUserTOTPRequest, initOverrides?: RequestInit): Promise<void> {
        await this.enableUserTOTPRaw(requestParameters, initOverrides);
    }

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

        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/uploads/finish`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: FinishUploadEndpointRequestToJSON(requestParameters.finishUploadEndpointRequest),
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

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

    /**
     * ### Required permissions    * User account permission: `users:manage` 
     */
    async fixLDAPGroupMembershipsRaw(requestParameters: FixLDAPGroupMembershipsRequest, 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 fixLDAPGroupMemberships.');
        }

        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/ldap-servers/{id}/fix-memberships`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

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

    /**
     * ### Required permissions    * User account permission: `system:status:view` 
     */
    async getAllClientSessionsRaw(requestParameters: GetAllClientSessionsRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Array<ClientSession>>> {
        const queryParameters: any = {};

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

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

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

        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/client-sessions`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

    /**
     * ### Required permissions    * User account permission: `system:status:view` 
     */
    async getAllClientSessions(requestParameters: GetAllClientSessionsRequest, initOverrides?: RequestInit): Promise<Array<ClientSession>> {
        const response = await this.getAllClientSessionsRaw(requestParameters, initOverrides);
        return await response.value();
    }

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

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

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

        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/cloud/accounts`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

    /**
     * ### Required permissions    * Authenticated user 
     */
    async getAllCloudAccounts(requestParameters: GetAllCloudAccountsRequest, initOverrides?: RequestInit): Promise<Array<CloudAccount>> {
        const response = await this.getAllCloudAccountsRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * Authenticated user 
     */
    async getAllDownloadArchivesRaw(requestParameters: GetAllDownloadArchivesRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Array<DownloadArchive>>> {
        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/download-archive`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

    /**
     * ### Required permissions    * Authenticated user 
     */
    async getAllDownloadArchives(requestParameters: GetAllDownloadArchivesRequest, initOverrides?: RequestInit): Promise<Array<DownloadArchive>> {
        const response = await this.getAllDownloadArchivesRaw(requestParameters, initOverrides);
        return await response.value();
    }

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

        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;
        }

        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/downloads`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

    /**
     * ### Required permissions    * User account permission: `downloads:view` 
     */
    async getAllDownloads(requestParameters: GetAllDownloadsRequest, initOverrides?: RequestInit): Promise<Array<Download>> {
        const response = await this.getAllDownloadsRaw(requestParameters, initOverrides);
        return await response.value();
    }

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

        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;
        }

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

        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/filesystem-permissions`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

    /**
     * ### Required permissions    * User account permission: `None` (read) / `users:manage` (write) 
     */
    async getAllFilesystemPermissions(requestParameters: GetAllFilesystemPermissionsRequest, initOverrides?: RequestInit): Promise<Array<FilesystemPermission>> {
        const response = await this.getAllFilesystemPermissionsRaw(requestParameters, initOverrides);
        return await response.value();
    }

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

        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;
        }

        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/groups`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

    /**
     * ### Required permissions    * User account permission: `users:view` (read) / `users:manage` (write) 
     */
    async getAllGroups(requestParameters: GetAllGroupsRequest, initOverrides?: RequestInit): Promise<Array<ElementsGroup>> {
        const response = await this.getAllGroupsRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * Authenticated user 
     */
    async getAllLDAPServersRaw(requestParameters: GetAllLDAPServersRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Array<LDAPServer>>> {
        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/ldap-servers`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

    /**
     * ### Required permissions    * Authenticated user 
     */
    async getAllLDAPServers(requestParameters: GetAllLDAPServersRequest, initOverrides?: RequestInit): Promise<Array<LDAPServer>> {
        const response = await this.getAllLDAPServersRaw(requestParameters, initOverrides);
        return await response.value();
    }

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

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

        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/system/time/servers`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

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

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

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

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

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

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

        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/nodes`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

    /**
     * ### Required permissions    * Authenticated user 
     */
    async getAllStorageNodes(requestParameters: GetAllStorageNodesRequest, initOverrides?: RequestInit): Promise<Array<StorageNode>> {
        const response = await this.getAllStorageNodesRaw(requestParameters, initOverrides);
        return await response.value();
    }

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

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

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

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

        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.includeAllowedFsPaths !== undefined) {
            queryParameters['include_allowed_fs_paths'] = requestParameters.includeAllowedFsPaths;
        }

        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/users`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

    /**
     * ### Required permissions    * User account permission: `None` (read) / `users:manage` (write) 
     */
    async getAllUsers(requestParameters: GetAllUsersRequest, initOverrides?: RequestInit): Promise<Array<ElementsUser>> {
        const response = await this.getAllUsersRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * Authenticated user   * Own workstation or User account permission: `workstations:view` (read) / `workstations:manage` (write) 
     */
    async getAllWorkstationsRaw(requestParameters: GetAllWorkstationsRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Array<Workstation>>> {
        const queryParameters: any = {};

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

        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;
        }

        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/workstations`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

    /**
     * ### Required permissions    * Authenticated user   * Own workstation or User account permission: `workstations:view` (read) / `workstations:manage` (write) 
     */
    async getAllWorkstations(requestParameters: GetAllWorkstationsRequest, initOverrides?: RequestInit): Promise<Array<Workstation>> {
        const response = await this.getAllWorkstationsRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `system:admin-access` 
     */
    async getCertificateConfigurationRaw(initOverrides?: RequestInit): Promise<runtime.ApiResponse<Certificate>> {
        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/system/certificate`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

    /**
     * ### Required permissions    * User account permission: `system:admin-access` 
     */
    async getCertificateConfiguration(initOverrides?: RequestInit): Promise<Certificate> {
        const response = await this.getCertificateConfigurationRaw(initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * <class \'rest_framework.permissions.AllowAny\'> 
     */
    async getClientDownloadFileRaw(requestParameters: GetClientDownloadFileRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.file === null || requestParameters.file === undefined) {
            throw new runtime.RequiredError('file','Required parameter requestParameters.file was null or undefined when calling getClientDownloadFile.');
        }

        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/downloads/clients/{file}`.replace(`{${"file"}}`, encodeURIComponent(String(requestParameters.file))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * ### Required permissions    * <class \'rest_framework.permissions.AllowAny\'> 
     */
    async getClientDownloadFile(requestParameters: GetClientDownloadFileRequest, initOverrides?: RequestInit): Promise<void> {
        await this.getClientDownloadFileRaw(requestParameters, initOverrides);
    }

    /**
     * ### Required permissions    * <class \'rest_framework.permissions.AllowAny\'> 
     */
    async getClientDownloadsRaw(initOverrides?: RequestInit): Promise<runtime.ApiResponse<Array<ClientsEndpointResponse>>> {
        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/downloads/clients`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

    /**
     * ### Required permissions    * <class \'rest_framework.permissions.AllowAny\'> 
     */
    async getClientDownloads(initOverrides?: RequestInit): Promise<Array<ClientsEndpointResponse>> {
        const response = await this.getClientDownloadsRaw(initOverrides);
        return await response.value();
    }

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

        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/client-sessions/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

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

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

        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/cloud/accounts/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

    /**
     * ### Required permissions    * Authenticated user 
     */
    async getCloudAccount(requestParameters: GetCloudAccountRequest, initOverrides?: RequestInit): Promise<CloudAccount> {
        const response = await this.getCloudAccountRaw(requestParameters, initOverrides);
        return await response.value();
    }

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

        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/cloud/accounts/{id}/storage-roots`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

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

    /**
     * ### Required permissions    * <class \'rest_framework.permissions.AllowAny\'> 
     */
    async getCurrentWorkstationRaw(requestParameters: GetCurrentWorkstationRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Workstation>> {
        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/workstations/current`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

    /**
     * ### Required permissions    * <class \'rest_framework.permissions.AllowAny\'> 
     */
    async getCurrentWorkstation(requestParameters: GetCurrentWorkstationRequest, initOverrides?: RequestInit): Promise<Workstation> {
        const response = await this.getCurrentWorkstationRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `downloads:view` 
     */
    async getDownloadRaw(requestParameters: GetDownloadRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Download>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling getDownload.');
        }

        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/downloads/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

    /**
     * ### Required permissions    * User account permission: `downloads:view` 
     */
    async getDownload(requestParameters: GetDownloadRequest, initOverrides?: RequestInit): Promise<Download> {
        const response = await this.getDownloadRaw(requestParameters, initOverrides);
        return await response.value();
    }

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

        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/download-archive/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

    /**
     * ### Required permissions    * Authenticated user 
     */
    async getDownloadArchive(requestParameters: GetDownloadArchiveRequest, initOverrides?: RequestInit): Promise<DownloadArchive> {
        const response = await this.getDownloadArchiveRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * Authenticated user 
     */
    async getDownloadArchiveFileRaw(requestParameters: GetDownloadArchiveFileRequest, 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 getDownloadArchiveFile.');
        }

        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/download-archive/{id}/download`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

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

    /**
     * ### Required permissions    * User account permission: `downloads:view` 
     */
    async getDownloadFileRaw(requestParameters: GetDownloadFileRequest, 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 getDownloadFile.');
        }

        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/downloads/{id}/download`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * ### Required permissions    * User account permission: `downloads:view` 
     */
    async getDownloadFile(requestParameters: GetDownloadFileRequest, initOverrides?: RequestInit): Promise<void> {
        await this.getDownloadFileRaw(requestParameters, initOverrides);
    }

    /**
     * ### Required permissions    * User account permission: `downloads:view` 
     */
    async getDownloadIconRaw(requestParameters: GetDownloadIconRequest, 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 getDownloadIcon.');
        }

        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/downloads/{id}/icon`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * ### Required permissions    * User account permission: `downloads:view` 
     */
    async getDownloadIcon(requestParameters: GetDownloadIconRequest, initOverrides?: RequestInit): Promise<void> {
        await this.getDownloadIconRaw(requestParameters, initOverrides);
    }

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

        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/filesystem-permissions/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

    /**
     * ### Required permissions    * User account permission: `None` (read) / `users:manage` (write) 
     */
    async getFilesystemPermission(requestParameters: GetFilesystemPermissionRequest, initOverrides?: RequestInit): Promise<FilesystemPermission> {
        const response = await this.getFilesystemPermissionRaw(requestParameters, initOverrides);
        return await response.value();
    }

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

        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/groups/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

    /**
     * ### Required permissions    * User account permission: `users:view` (read) / `users:manage` (write) 
     */
    async getGroup(requestParameters: GetGroupRequest, initOverrides?: RequestInit): Promise<ElementsGroupDetail> {
        const response = await this.getGroupRaw(requestParameters, initOverrides);
        return await response.value();
    }

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

        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/users/{id}/home`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

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

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

        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/nodes/{id}/ipmi`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

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

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

        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/ldap-servers/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

    /**
     * ### Required permissions    * Authenticated user 
     */
    async getLDAPServer(requestParameters: GetLDAPServerRequest, initOverrides?: RequestInit): Promise<LDAPServer> {
        const response = await this.getLDAPServerRaw(requestParameters, initOverrides);
        return await response.value();
    }

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

        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/ldap-servers/{id}/groups`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

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

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

        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/ldap-servers/{id}/users`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

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

    /**
     * ### Required permissions    * <class \'rest_framework.permissions.AllowAny\'> 
     */
    async getLicenseRaw(initOverrides?: RequestInit): Promise<runtime.ApiResponse<License>> {
        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/license`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

    /**
     * ### Required permissions    * <class \'rest_framework.permissions.AllowAny\'> 
     */
    async getLicense(initOverrides?: RequestInit): Promise<License> {
        const response = await this.getLicenseRaw(initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `system:admin-access` 
     */
    async getLocalTimeRaw(initOverrides?: RequestInit): Promise<runtime.ApiResponse<TimeEndpointResponse>> {
        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/system/time`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

    /**
     * ### Required permissions    * User account permission: `system:admin-access` 
     */
    async getLocalTime(initOverrides?: RequestInit): Promise<TimeEndpointResponse> {
        const response = await this.getLocalTimeRaw(initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * Authenticated user 
     */
    async getLogRaw(requestParameters: GetLogRequest, 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 getLog.');
        }

        const queryParameters: any = {};

        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/system/log/{path}`.replace(`{${"path"}}`, encodeURIComponent(String(requestParameters.path))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

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

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

        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/system/time/servers/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

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

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

        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/nodes/{id}/sensors`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

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

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

        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/nodes/{id}/stats`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

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

    /**
     * ### Required permissions    * <class \'rest_framework.permissions.AllowAny\'> 
     */
    async getParametersRaw(requestParameters: GetParametersRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Parameters>> {
        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/parameters`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

    /**
     * ### Required permissions    * <class \'rest_framework.permissions.AllowAny\'> 
     */
    async getParameters(requestParameters: GetParametersRequest, initOverrides?: RequestInit): Promise<Parameters> {
        const response = await this.getParametersRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * Authenticated user 
     */
    async getProfileRaw(requestParameters: GetProfileRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<ElementsUserProfile>> {
        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/users/me`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

    /**
     * ### Required permissions    * Authenticated user 
     */
    async getProfile(requestParameters: GetProfileRequest, initOverrides?: RequestInit): Promise<ElementsUserProfile> {
        const response = await this.getProfileRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * Authenticated user 
     */
    async getReleaseNotesRaw(initOverrides?: RequestInit): Promise<runtime.ApiResponse<Array<ReleaseNotesEndpointResponse>>> {
        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/release-notes`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

    /**
     * ### Required permissions    * Authenticated user 
     */
    async getReleaseNotes(initOverrides?: RequestInit): Promise<Array<ReleaseNotesEndpointResponse>> {
        const response = await this.getReleaseNotesRaw(initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `system:admin-access` 
     */
    async getSMTPConfigurationRaw(initOverrides?: RequestInit): Promise<runtime.ApiResponse<SMTPConfiguration>> {
        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/system/smtp`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

    /**
     * ### Required permissions    * User account permission: `system:admin-access` 
     */
    async getSMTPConfiguration(initOverrides?: RequestInit): Promise<SMTPConfiguration> {
        const response = await this.getSMTPConfigurationRaw(initOverrides);
        return await response.value();
    }

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

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

        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/nodes/{id}/services/{service}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))).replace(`{${"service"}}`, encodeURIComponent(String(requestParameters.service))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

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

    /**
     * ### Required permissions    * User account permission: `system:admin-access`   * License component: stornext_mdc 
     */
    async getStorNextLicenseRaw(initOverrides?: RequestInit): Promise<runtime.ApiResponse<StorNextLicenseEndpointResponse>> {
        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/stornext-license`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

    /**
     * ### Required permissions    * User account permission: `system:admin-access`   * License component: stornext_mdc 
     */
    async getStorNextLicense(initOverrides?: RequestInit): Promise<StorNextLicenseEndpointResponse> {
        const response = await this.getStorNextLicenseRaw(initOverrides);
        return await response.value();
    }

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

        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/nodes/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

    /**
     * ### Required permissions    * Authenticated user 
     */
    async getStorageNode(requestParameters: GetStorageNodeRequest, initOverrides?: RequestInit): Promise<StorageNode> {
        const response = await this.getStorageNodeRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * <class \'rest_framework.permissions.AllowAny\'> 
     */
    async getSystemInfoRaw(initOverrides?: RequestInit): Promise<runtime.ApiResponse<SystemInfoEndpointResponse>> {
        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/system/info`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

    /**
     * ### Required permissions    * <class \'rest_framework.permissions.AllowAny\'> 
     */
    async getSystemInfo(initOverrides?: RequestInit): Promise<SystemInfoEndpointResponse> {
        const response = await this.getSystemInfoRaw(initOverrides);
        return await response.value();
    }

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

        const queryParameters: any = {};

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

        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/users/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

    /**
     * ### Required permissions    * User account permission: `None` (read) / `users:manage` (write) 
     */
    async getUser(requestParameters: GetUserRequest, initOverrides?: RequestInit): Promise<ElementsUserDetail> {
        const response = await this.getUserRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * Authenticated user   * Own workstation or User account permission: `workstations:view` (read) / `workstations:manage` (write) 
     */
    async getWorkstationRaw(requestParameters: GetWorkstationRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Workstation>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling getWorkstation.');
        }

        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/workstations/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

    /**
     * ### Required permissions    * Authenticated user   * Own workstation or User account permission: `workstations:view` (read) / `workstations:manage` (write) 
     */
    async getWorkstation(requestParameters: GetWorkstationRequest, initOverrides?: RequestInit): Promise<Workstation> {
        const response = await this.getWorkstationRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `system:admin-access`   * License component: stornext_mdc 
     */
    async installStorNextLicenseRaw(requestParameters: InstallStorNextLicenseRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<StorNextLicenseEndpointResponse>> {
        if (requestParameters.stornextLicense === null || requestParameters.stornextLicense === undefined) {
            throw new runtime.RequiredError('stornextLicense','Required parameter requestParameters.stornextLicense was null or undefined when calling installStorNextLicense.');
        }

        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/stornext-license`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: StornextLicenseToJSON(requestParameters.stornextLicense),
        }, initOverrides);

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

    /**
     * ### Required permissions    * User account permission: `system:admin-access`   * License component: stornext_mdc 
     */
    async installStorNextLicense(requestParameters: InstallStorNextLicenseRequest, initOverrides?: RequestInit): Promise<StorNextLicenseEndpointResponse> {
        const response = await this.installStorNextLicenseRaw(requestParameters, initOverrides);
        return await response.value();
    }

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

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

        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/cloud/accounts/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
            body: CloudAccountPartialUpdateToJSON(requestParameters.cloudAccountPartialUpdate),
        }, initOverrides);

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

    /**
     * ### Required permissions    * Authenticated user 
     */
    async patchCloudAccount(requestParameters: PatchCloudAccountRequest, initOverrides?: RequestInit): Promise<CloudAccount> {
        const response = await this.patchCloudAccountRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * <class \'rest_framework.permissions.AllowAny\'> 
     */
    async patchCurrentWorkstationRaw(requestParameters: PatchCurrentWorkstationRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Workstation>> {
        if (requestParameters.workstationPartialUpdate === null || requestParameters.workstationPartialUpdate === undefined) {
            throw new runtime.RequiredError('workstationPartialUpdate','Required parameter requestParameters.workstationPartialUpdate was null or undefined when calling patchCurrentWorkstation.');
        }

        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/workstations/current`,
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
            body: WorkstationPartialUpdateToJSON(requestParameters.workstationPartialUpdate),
        }, initOverrides);

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

    /**
     * ### Required permissions    * <class \'rest_framework.permissions.AllowAny\'> 
     */
    async patchCurrentWorkstation(requestParameters: PatchCurrentWorkstationRequest, initOverrides?: RequestInit): Promise<Workstation> {
        const response = await this.patchCurrentWorkstationRaw(requestParameters, initOverrides);
        return await response.value();
    }

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

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

        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/download-archive/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
            body: DownloadArchivePartialUpdateToJSON(requestParameters.downloadArchivePartialUpdate),
        }, initOverrides);

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

    /**
     * ### Required permissions    * Authenticated user 
     */
    async patchDownloadArchive(requestParameters: PatchDownloadArchiveRequest, initOverrides?: RequestInit): Promise<DownloadArchive> {
        const response = await this.patchDownloadArchiveRaw(requestParameters, initOverrides);
        return await response.value();
    }

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

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

        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-permissions/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
            body: FilesystemPermissionPartialUpdateToJSON(requestParameters.filesystemPermissionPartialUpdate),
        }, initOverrides);

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

    /**
     * ### Required permissions    * User account permission: `None` (read) / `users:manage` (write) 
     */
    async patchFilesystemPermission(requestParameters: PatchFilesystemPermissionRequest, initOverrides?: RequestInit): Promise<FilesystemPermission> {
        const response = await this.patchFilesystemPermissionRaw(requestParameters, initOverrides);
        return await response.value();
    }

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

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

        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/groups/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
            body: ElementsGroupDetailPartialUpdateToJSON(requestParameters.elementsGroupDetailPartialUpdate),
        }, initOverrides);

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

    /**
     * ### Required permissions    * User account permission: `users:view` (read) / `users:manage` (write) 
     */
    async patchGroup(requestParameters: PatchGroupRequest, initOverrides?: RequestInit): Promise<ElementsGroupDetail> {
        const response = await this.patchGroupRaw(requestParameters, initOverrides);
        return await response.value();
    }

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

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

        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/system/time/servers/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
            body: NTPServerPartialUpdateToJSON(requestParameters.nTPServerPartialUpdate),
        }, initOverrides);

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

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

    /**
     * ### Required permissions    * Authenticated user 
     */
    async patchProfileRaw(requestParameters: PatchProfileRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<ElementsUserProfile>> {
        if (requestParameters.elementsUserProfilePartialUpdate === null || requestParameters.elementsUserProfilePartialUpdate === undefined) {
            throw new runtime.RequiredError('elementsUserProfilePartialUpdate','Required parameter requestParameters.elementsUserProfilePartialUpdate was null or undefined when calling patchProfile.');
        }

        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/users/me`,
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
            body: ElementsUserProfilePartialUpdateToJSON(requestParameters.elementsUserProfilePartialUpdate),
        }, initOverrides);

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

    /**
     * ### Required permissions    * Authenticated user 
     */
    async patchProfile(requestParameters: PatchProfileRequest, initOverrides?: RequestInit): Promise<ElementsUserProfile> {
        const response = await this.patchProfileRaw(requestParameters, initOverrides);
        return await response.value();
    }

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

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

        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/users/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
            body: ElementsUserDetailPartialUpdateToJSON(requestParameters.elementsUserDetailPartialUpdate),
        }, initOverrides);

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

    /**
     * ### Required permissions    * User account permission: `None` (read) / `users:manage` (write) 
     */
    async patchUser(requestParameters: PatchUserRequest, initOverrides?: RequestInit): Promise<ElementsUserDetail> {
        const response = await this.patchUserRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * Authenticated user   * Own workstation or User account permission: `workstations:view` (read) / `workstations:manage` (write) 
     */
    async patchWorkstationRaw(requestParameters: PatchWorkstationRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Workstation>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling patchWorkstation.');
        }

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

        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/workstations/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
            body: WorkstationPartialUpdateToJSON(requestParameters.workstationPartialUpdate),
        }, initOverrides);

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

    /**
     * ### Required permissions    * Authenticated user   * Own workstation or User account permission: `workstations:view` (read) / `workstations:manage` (write) 
     */
    async patchWorkstation(requestParameters: PatchWorkstationRequest, initOverrides?: RequestInit): Promise<Workstation> {
        const response = await this.patchWorkstationRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     */
    async previewUserRaw(requestParameters: PreviewUserRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<UserPreviewResponse>> {
        if (requestParameters.userPreviewRequest === null || requestParameters.userPreviewRequest === undefined) {
            throw new runtime.RequiredError('userPreviewRequest','Required parameter requestParameters.userPreviewRequest was null or undefined when calling previewUser.');
        }

        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/users/preview`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: UserPreviewRequestToJSON(requestParameters.userPreviewRequest),
        }, initOverrides);

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

    /**
     */
    async previewUser(requestParameters: PreviewUserRequest, initOverrides?: RequestInit): Promise<UserPreviewResponse> {
        const response = await this.previewUserRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `system:admin-access` 
     */
    async rebootRaw(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/system/reboot`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * ### Required permissions    * User account permission: `system:admin-access` 
     */
    async reboot(initOverrides?: RequestInit): Promise<void> {
        await this.rebootRaw(initOverrides);
    }

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

        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/uploads/register`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: RegisterUploadEndpointRequestToJSON(requestParameters.registerUploadEndpointRequest),
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

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

    /**
     * ### Required permissions    * User account permission: `media:access` 
     */
    async registerUploadMetadataRaw(requestParameters: RegisterUploadMetadataRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.registerUploadMetadataEndpointRequest === null || requestParameters.registerUploadMetadataEndpointRequest === undefined) {
            throw new runtime.RequiredError('registerUploadMetadataEndpointRequest','Required parameter requestParameters.registerUploadMetadataEndpointRequest was null or undefined when calling registerUploadMetadata.');
        }

        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/uploads/metadata`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: RegisterUploadMetadataEndpointRequestToJSON(requestParameters.registerUploadMetadataEndpointRequest),
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * ### Required permissions    * User account permission: `media:access` 
     */
    async registerUploadMetadata(requestParameters: RegisterUploadMetadataRequest, initOverrides?: RequestInit): Promise<void> {
        await this.registerUploadMetadataRaw(requestParameters, initOverrides);
    }

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

        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/system/smtp/preview`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: EmailPreviewToJSON(requestParameters.emailPreview),
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * ### Required permissions    * User account permission: `system:admin-access` 
     */
    async renderEmailTemplatePreview(requestParameters: RenderEmailTemplatePreviewRequest, initOverrides?: RequestInit): Promise<void> {
        await this.renderEmailTemplatePreviewRaw(requestParameters, initOverrides);
    }

    /**
     * ### Required permissions    * User account permission: `users:manage` 
     */
    async resetUserPasswordRaw(requestParameters: ResetUserPasswordRequest, 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 resetUserPassword.');
        }

        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/users/{id}/password/reset`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

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

    /**
     * ### Required permissions    * User account permission: `system:admin-access` 
     */
    async restartWebUIRaw(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/system/restart-webui`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * ### Required permissions    * User account permission: `system:admin-access` 
     */
    async restartWebUI(initOverrides?: RequestInit): Promise<void> {
        await this.restartWebUIRaw(initOverrides);
    }

    /**
     * ### Required permissions    * User account permission: `system:admin-access` 
     */
    async runServiceOperationRaw(requestParameters: RunServiceOperationRequest, 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 runServiceOperation.');
        }

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

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

        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/nodes/{id}/services/{service}/{operation}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))).replace(`{${"operation"}}`, encodeURIComponent(String(requestParameters.operation))).replace(`{${"service"}}`, encodeURIComponent(String(requestParameters.service))),
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * ### Required permissions    * User account permission: `system:admin-access` 
     */
    async runServiceOperation(requestParameters: RunServiceOperationRequest, initOverrides?: RequestInit): Promise<void> {
        await this.runServiceOperationRaw(requestParameters, initOverrides);
    }

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

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

        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/nodes/{id}/ipmi`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: IpmiToJSON(requestParameters.ipmi),
        }, initOverrides);

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

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

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

        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/system/time`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: TimeEndpointRequestToJSON(requestParameters.timeEndpointRequest),
        }, initOverrides);

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

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

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

        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/users/me/password`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: ChangeOwnPasswordRequestToJSON(requestParameters.changeOwnPasswordRequest),
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

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

    /**
     * ### Required permissions    * User account permission: `users:manage` 
     */
    async setUserPasswordRaw(requestParameters: SetUserPasswordRequest, 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 setUserPassword.');
        }

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

        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/users/{id}/password`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: ChangePasswordRequestToJSON(requestParameters.changePasswordRequest),
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

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

    /**
     * ### Required permissions    * User account permission: `system:admin-access` 
     */
    async shutdownRaw(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/system/shutdown`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * ### Required permissions    * User account permission: `system:admin-access` 
     */
    async shutdown(initOverrides?: RequestInit): Promise<void> {
        await this.shutdownRaw(initOverrides);
    }

    /**
     * ### Required permissions    * User account permission: `system:admin-access` 
     */
    async startSolrReindexRaw(initOverrides?: RequestInit): Promise<runtime.ApiResponse<SolrReindexEndpointResponse>> {
        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/system/solr/reindex`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

    /**
     * ### Required permissions    * User account permission: `system:admin-access` 
     */
    async startSolrReindex(initOverrides?: RequestInit): Promise<SolrReindexEndpointResponse> {
        const response = await this.startSolrReindexRaw(initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `system:admin-access` 
     */
    async startSupportSessionRaw(initOverrides?: RequestInit): Promise<runtime.ApiResponse<TaskInfo>> {
        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/system/support-session/start`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

    /**
     * ### Required permissions    * User account permission: `system:admin-access` 
     */
    async startSupportSession(initOverrides?: RequestInit): Promise<TaskInfo> {
        const response = await this.startSupportSessionRaw(initOverrides);
        return await response.value();
    }

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

        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/system/backup/start`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: PathToJSON(requestParameters.path),
        }, initOverrides);

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

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

    /**
     * ### Required permissions    * User account permission: `users:manage` 
     */
    async syncLDAPGroupRaw(requestParameters: SyncLDAPGroupRequest, 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 syncLDAPGroup.');
        }

        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/groups/{id}/ldap-sync`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

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

    /**
     * ### Required permissions    * User account permission: `users:manage` 
     */
    async syncLDAPUsersRaw(requestParameters: SyncLDAPUsersRequest, 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 syncLDAPUsers.');
        }

        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/ldap-servers/{id}/sync-users`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

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

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

        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/system/time/sync`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: TimeSyncEndpointRequestToJSON(requestParameters.timeSyncEndpointRequest),
        }, initOverrides);

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

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

    /**
     */
    async syncUserTOTPRaw(requestParameters: SyncUserTOTPRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<SyncTOTP>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling syncUserTOTP.');
        }

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

        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/users/{id}/totp`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: SyncTOTPRequestToJSON(requestParameters.syncTOTPRequest),
        }, initOverrides);

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

    /**
     */
    async syncUserTOTP(requestParameters: SyncUserTOTPRequest, initOverrides?: RequestInit): Promise<SyncTOTP> {
        const response = await this.syncUserTOTPRaw(requestParameters, initOverrides);
        return await response.value();
    }

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

        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/cloud/accounts/test-credentials`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: TestCloudAccountCredentialsRequestToJSON(requestParameters.testCloudAccountCredentialsRequest),
        }, initOverrides);

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

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

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

        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/system/smtp/test`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: TestSMTPToJSON(requestParameters.testSMTP),
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * ### Required permissions    * User account permission: `system:admin-access` 
     */
    async testSMTPConfiguration(requestParameters: TestSMTPConfigurationRequest, initOverrides?: RequestInit): Promise<void> {
        await this.testSMTPConfigurationRaw(requestParameters, initOverrides);
    }

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

        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/system/certificate`,
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: CertificateUpdateToJSON(requestParameters.certificateUpdate),
        }, initOverrides);

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

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

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

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

        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/cloud/accounts/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: CloudAccountUpdateToJSON(requestParameters.cloudAccountUpdate),
        }, initOverrides);

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

    /**
     * ### Required permissions    * Authenticated user 
     */
    async updateCloudAccount(requestParameters: UpdateCloudAccountRequest, initOverrides?: RequestInit): Promise<CloudAccount> {
        const response = await this.updateCloudAccountRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * <class \'rest_framework.permissions.AllowAny\'> 
     */
    async updateCurrentWorkstationRaw(requestParameters: UpdateCurrentWorkstationRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Workstation>> {
        if (requestParameters.workstationUpdate === null || requestParameters.workstationUpdate === undefined) {
            throw new runtime.RequiredError('workstationUpdate','Required parameter requestParameters.workstationUpdate was null or undefined when calling updateCurrentWorkstation.');
        }

        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/workstations/current`,
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: WorkstationUpdateToJSON(requestParameters.workstationUpdate),
        }, initOverrides);

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

    /**
     * ### Required permissions    * <class \'rest_framework.permissions.AllowAny\'> 
     */
    async updateCurrentWorkstation(requestParameters: UpdateCurrentWorkstationRequest, initOverrides?: RequestInit): Promise<Workstation> {
        const response = await this.updateCurrentWorkstationRaw(requestParameters, initOverrides);
        return await response.value();
    }

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

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

        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/download-archive/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: DownloadArchiveUpdateToJSON(requestParameters.downloadArchiveUpdate),
        }, initOverrides);

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

    /**
     * ### Required permissions    * Authenticated user 
     */
    async updateDownloadArchive(requestParameters: UpdateDownloadArchiveRequest, initOverrides?: RequestInit): Promise<DownloadArchive> {
        const response = await this.updateDownloadArchiveRaw(requestParameters, initOverrides);
        return await response.value();
    }

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

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

        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-permissions/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: FilesystemPermissionUpdateToJSON(requestParameters.filesystemPermissionUpdate),
        }, initOverrides);

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

    /**
     * ### Required permissions    * User account permission: `None` (read) / `users:manage` (write) 
     */
    async updateFilesystemPermission(requestParameters: UpdateFilesystemPermissionRequest, initOverrides?: RequestInit): Promise<FilesystemPermission> {
        const response = await this.updateFilesystemPermissionRaw(requestParameters, initOverrides);
        return await response.value();
    }

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

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

        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/groups/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: ElementsGroupDetailUpdateToJSON(requestParameters.elementsGroupDetailUpdate),
        }, initOverrides);

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

    /**
     * ### Required permissions    * User account permission: `users:view` (read) / `users:manage` (write) 
     */
    async updateGroup(requestParameters: UpdateGroupRequest, initOverrides?: RequestInit): Promise<ElementsGroupDetail> {
        const response = await this.updateGroupRaw(requestParameters, initOverrides);
        return await response.value();
    }

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

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

        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/system/time/servers/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: NTPServerUpdateToJSON(requestParameters.nTPServerUpdate),
        }, initOverrides);

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

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

    /**
     * ### Required permissions    * <class \'rest_framework.permissions.AllowAny\'> 
     */
    async updateParametersRaw(requestParameters: UpdateParametersRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Parameters>> {
        if (requestParameters.parametersUpdate === null || requestParameters.parametersUpdate === undefined) {
            throw new runtime.RequiredError('parametersUpdate','Required parameter requestParameters.parametersUpdate was null or undefined when calling updateParameters.');
        }

        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/parameters`,
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: ParametersUpdateToJSON(requestParameters.parametersUpdate),
        }, initOverrides);

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

    /**
     * ### Required permissions    * <class \'rest_framework.permissions.AllowAny\'> 
     */
    async updateParameters(requestParameters: UpdateParametersRequest, initOverrides?: RequestInit): Promise<Parameters> {
        const response = await this.updateParametersRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * Authenticated user 
     */
    async updateProfileRaw(requestParameters: UpdateProfileRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<ElementsUserProfile>> {
        if (requestParameters.elementsUserProfileUpdate === null || requestParameters.elementsUserProfileUpdate === undefined) {
            throw new runtime.RequiredError('elementsUserProfileUpdate','Required parameter requestParameters.elementsUserProfileUpdate was null or undefined when calling updateProfile.');
        }

        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/users/me`,
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: ElementsUserProfileUpdateToJSON(requestParameters.elementsUserProfileUpdate),
        }, initOverrides);

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

    /**
     * ### Required permissions    * Authenticated user 
     */
    async updateProfile(requestParameters: UpdateProfileRequest, initOverrides?: RequestInit): Promise<ElementsUserProfile> {
        const response = await this.updateProfileRaw(requestParameters, initOverrides);
        return await response.value();
    }

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

        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/system/smtp`,
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: SMTPConfigurationUpdateToJSON(requestParameters.sMTPConfigurationUpdate),
        }, initOverrides);

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

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

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

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

        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/users/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: ElementsUserDetailUpdateToJSON(requestParameters.elementsUserDetailUpdate),
        }, initOverrides);

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

    /**
     * ### Required permissions    * User account permission: `None` (read) / `users:manage` (write) 
     */
    async updateUser(requestParameters: UpdateUserRequest, initOverrides?: RequestInit): Promise<ElementsUserDetail> {
        const response = await this.updateUserRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * Authenticated user   * Own workstation or User account permission: `workstations:view` (read) / `workstations:manage` (write) 
     */
    async updateWorkstationRaw(requestParameters: UpdateWorkstationRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Workstation>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling updateWorkstation.');
        }

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

        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/workstations/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: WorkstationUpdateToJSON(requestParameters.workstationUpdate),
        }, initOverrides);

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

    /**
     * ### Required permissions    * Authenticated user   * Own workstation or User account permission: `workstations:view` (read) / `workstations:manage` (write) 
     */
    async updateWorkstation(requestParameters: UpdateWorkstationRequest, initOverrides?: RequestInit): Promise<Workstation> {
        const response = await this.updateWorkstationRaw(requestParameters, initOverrides);
        return await response.value();
    }

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

        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/uploads/chunk`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: UploadChunkEndpointRequestToJSON(requestParameters.uploadChunkEndpointRequest),
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

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

}