/* 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 {
    ArchiveEndpointRequest,
    ArchiveEndpointRequestFromJSON,
    ArchiveEndpointRequestToJSON,
    RestoreEndpointRequest,
    RestoreEndpointRequestFromJSON,
    RestoreEndpointRequestToJSON,
    SearchEndpointRequest,
    SearchEndpointRequestFromJSON,
    SearchEndpointRequestToJSON,
    SearchEndpointResponse,
    SearchEndpointResponseFromJSON,
    SearchEndpointResponseToJSON,
    Tape,
    TapeFromJSON,
    TapeToJSON,
    TapeFile,
    TapeFileFromJSON,
    TapeFileToJSON,
    TapeGroup,
    TapeGroupFromJSON,
    TapeGroupToJSON,
    TapeGroupPartialUpdate,
    TapeGroupPartialUpdateFromJSON,
    TapeGroupPartialUpdateToJSON,
    TapeGroupUpdate,
    TapeGroupUpdateFromJSON,
    TapeGroupUpdateToJSON,
    TapeJob,
    TapeJobFromJSON,
    TapeJobToJSON,
    TapeJobSource,
    TapeJobSourceFromJSON,
    TapeJobSourceToJSON,
    TapeLibraryEndpointResponse,
    TapeLibraryEndpointResponseFromJSON,
    TapeLibraryEndpointResponseToJSON,
    TapeLibraryFormatEndpointRequest,
    TapeLibraryFormatEndpointRequestFromJSON,
    TapeLibraryFormatEndpointRequestToJSON,
    TapeLibraryFsckEndpointRequest,
    TapeLibraryFsckEndpointRequestFromJSON,
    TapeLibraryFsckEndpointRequestToJSON,
    TapeLibraryLoadEndpointRequest,
    TapeLibraryLoadEndpointRequestFromJSON,
    TapeLibraryLoadEndpointRequestToJSON,
    TapeLibraryMoveEndpointRequest,
    TapeLibraryMoveEndpointRequestFromJSON,
    TapeLibraryMoveEndpointRequestToJSON,
    TapeLibraryReindexEndpointRequest,
    TapeLibraryReindexEndpointRequestFromJSON,
    TapeLibraryReindexEndpointRequestToJSON,
    TapeLibraryUnloadEndpointRequest,
    TapeLibraryUnloadEndpointRequestFromJSON,
    TapeLibraryUnloadEndpointRequestToJSON,
    TapePartialUpdate,
    TapePartialUpdateFromJSON,
    TapePartialUpdateToJSON,
    TapeUpdate,
    TapeUpdateFromJSON,
    TapeUpdateToJSON,
} from '../models';

export interface ArchiveToTapeRequest {
    archiveEndpointRequest: ArchiveEndpointRequest;
}

export interface CheckTapeRequest {
    tapeLibraryFsckEndpointRequest: TapeLibraryFsckEndpointRequest;
}

export interface CreateTapeRequest {
    tapeUpdate: TapeUpdate;
}

export interface CreateTapeGroupRequest {
    tapeGroupUpdate: TapeGroupUpdate;
}

export interface DeleteTapeRequest {
    id: number;
}

export interface DeleteTapeArchiveJobRequest {
    id: string;
}

export interface DeleteTapeGroupRequest {
    id: number;
}

export interface FormatTapeRequest {
    tapeLibraryFormatEndpointRequest: TapeLibraryFormatEndpointRequest;
}

export interface GetAllArchivedFileEntriesRequest {
    id?: number;
    isDir?: string;
    name?: string;
    fullpath?: string;
    parent?: number;
    ordering?: string;
    limit?: number;
    offset?: number;
}

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

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

export interface GetAllTapesRequest {
    id?: number;
    name?: string;
    group?: number;
    groupIsnull?: string;
    ordering?: string;
    limit?: number;
    offset?: number;
}

export interface GetArchivedFileEntryRequest {
    id: number;
}

export interface GetTapeRequest {
    id: number;
}

export interface GetTapeArchiveJobRequest {
    id: string;
}

export interface GetTapeArchiveJobSourcesRequest {
    id: string;
}

export interface GetTapeGroupRequest {
    id: number;
}

export interface LoadTapeRequest {
    tapeLibraryLoadEndpointRequest: TapeLibraryLoadEndpointRequest;
}

export interface MoveTapeRequest {
    tapeLibraryMoveEndpointRequest: TapeLibraryMoveEndpointRequest;
}

export interface PatchTapeRequest {
    id: number;
    tapePartialUpdate: TapePartialUpdate;
}

export interface PatchTapeGroupRequest {
    id: number;
    tapeGroupPartialUpdate: TapeGroupPartialUpdate;
}

export interface PauseTapeArchiveJobRequest {
    id: string;
}

export interface ReindexTapeRequest {
    tapeLibraryReindexEndpointRequest: TapeLibraryReindexEndpointRequest;
}

export interface RestartTapeArchiveJobRequest {
    id: string;
}

export interface RestoreFromTapeRequest {
    restoreEndpointRequest: RestoreEndpointRequest;
}

export interface ResumeTapeArchiveJobRequest {
    id: string;
}

export interface SearchTapeArchiveRequest {
    searchEndpointRequest: SearchEndpointRequest;
}

export interface UnloadTapeRequest {
    tapeLibraryUnloadEndpointRequest: TapeLibraryUnloadEndpointRequest;
}

export interface UpdateTapeRequest {
    id: number;
    tapeUpdate: TapeUpdate;
}

export interface UpdateTapeGroupRequest {
    id: number;
    tapeGroupUpdate: TapeGroupUpdate;
}

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

    /**
     * ### Required permissions    * User account permission: `ltfs:backup`   * License component: ltfs 
     */
    async archiveToTapeRaw(requestParameters: ArchiveToTapeRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Array<TapeJob>>> {
        if (requestParameters.archiveEndpointRequest === null || requestParameters.archiveEndpointRequest === undefined) {
            throw new runtime.RequiredError('archiveEndpointRequest','Required parameter requestParameters.archiveEndpointRequest was null or undefined when calling archiveToTape.');
        }

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

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

    /**
     * ### Required permissions    * User account permission: `ltfs:backup`   * License component: ltfs 
     */
    async archiveToTape(requestParameters: ArchiveToTapeRequest, initOverrides?: RequestInit): Promise<Array<TapeJob>> {
        const response = await this.archiveToTapeRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `None` (read) / `ltfs:manage` (write)   * License component: ltfs 
     */
    async cancelAllTapeArchiveJobsRaw(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/archive/tape/jobs/cancel-all`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * ### Required permissions    * User account permission: `None` (read) / `ltfs:manage` (write)   * License component: ltfs 
     */
    async cancelAllTapeArchiveJobs(initOverrides?: RequestInit): Promise<void> {
        await this.cancelAllTapeArchiveJobsRaw(initOverrides);
    }

    /**
     * ### Required permissions    * User account permission: `ltfs:manage`   * License component: ltfs 
     */
    async checkTapeRaw(requestParameters: CheckTapeRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.tapeLibraryFsckEndpointRequest === null || requestParameters.tapeLibraryFsckEndpointRequest === undefined) {
            throw new runtime.RequiredError('tapeLibraryFsckEndpointRequest','Required parameter requestParameters.tapeLibraryFsckEndpointRequest was null or undefined when calling checkTape.');
        }

        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/archive/tape/library/check`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: TapeLibraryFsckEndpointRequestToJSON(requestParameters.tapeLibraryFsckEndpointRequest),
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * ### Required permissions    * User account permission: `ltfs:manage`   * License component: ltfs 
     */
    async checkTape(requestParameters: CheckTapeRequest, initOverrides?: RequestInit): Promise<void> {
        await this.checkTapeRaw(requestParameters, initOverrides);
    }

    /**
     * ### Required permissions    * User account permission: `None` (read) / `ltfs:tapegroups:manage` (write)   * License component: ltfs 
     */
    async createTapeRaw(requestParameters: CreateTapeRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Tape>> {
        if (requestParameters.tapeUpdate === null || requestParameters.tapeUpdate === undefined) {
            throw new runtime.RequiredError('tapeUpdate','Required parameter requestParameters.tapeUpdate was null or undefined when calling createTape.');
        }

        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/archive/tape/tapes`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: TapeUpdateToJSON(requestParameters.tapeUpdate),
        }, initOverrides);

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

    /**
     * ### Required permissions    * User account permission: `None` (read) / `ltfs:tapegroups:manage` (write)   * License component: ltfs 
     */
    async createTape(requestParameters: CreateTapeRequest, initOverrides?: RequestInit): Promise<Tape> {
        const response = await this.createTapeRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `None` (read) / `ltfs:tapegroups:manage` (write)   * License component: ltfs 
     */
    async createTapeGroupRaw(requestParameters: CreateTapeGroupRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<TapeGroup>> {
        if (requestParameters.tapeGroupUpdate === null || requestParameters.tapeGroupUpdate === undefined) {
            throw new runtime.RequiredError('tapeGroupUpdate','Required parameter requestParameters.tapeGroupUpdate was null or undefined when calling createTapeGroup.');
        }

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

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

    /**
     * ### Required permissions    * User account permission: `None` (read) / `ltfs:tapegroups:manage` (write)   * License component: ltfs 
     */
    async createTapeGroup(requestParameters: CreateTapeGroupRequest, initOverrides?: RequestInit): Promise<TapeGroup> {
        const response = await this.createTapeGroupRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `None` (read) / `ltfs:tapegroups:manage` (write)   * License component: ltfs 
     */
    async deleteTapeRaw(requestParameters: DeleteTapeRequest, 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 deleteTape.');
        }

        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/archive/tape/tapes/{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) / `ltfs:tapegroups:manage` (write)   * License component: ltfs 
     */
    async deleteTape(requestParameters: DeleteTapeRequest, initOverrides?: RequestInit): Promise<void> {
        await this.deleteTapeRaw(requestParameters, initOverrides);
    }

    /**
     * ### Required permissions    * User account permission: `None` (read) / `ltfs:manage` (write)   * License component: ltfs 
     */
    async deleteTapeArchiveJobRaw(requestParameters: DeleteTapeArchiveJobRequest, 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 deleteTapeArchiveJob.');
        }

        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/archive/tape/jobs/{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) / `ltfs:manage` (write)   * License component: ltfs 
     */
    async deleteTapeArchiveJob(requestParameters: DeleteTapeArchiveJobRequest, initOverrides?: RequestInit): Promise<void> {
        await this.deleteTapeArchiveJobRaw(requestParameters, initOverrides);
    }

    /**
     * ### Required permissions    * User account permission: `None` (read) / `ltfs:tapegroups:manage` (write)   * License component: ltfs 
     */
    async deleteTapeGroupRaw(requestParameters: DeleteTapeGroupRequest, 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 deleteTapeGroup.');
        }

        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/archive/tape/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: `None` (read) / `ltfs:tapegroups:manage` (write)   * License component: ltfs 
     */
    async deleteTapeGroup(requestParameters: DeleteTapeGroupRequest, initOverrides?: RequestInit): Promise<void> {
        await this.deleteTapeGroupRaw(requestParameters, initOverrides);
    }

    /**
     * ### Required permissions    * User account permission: `ltfs:manage`   * License component: ltfs 
     */
    async formatTapeRaw(requestParameters: FormatTapeRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.tapeLibraryFormatEndpointRequest === null || requestParameters.tapeLibraryFormatEndpointRequest === undefined) {
            throw new runtime.RequiredError('tapeLibraryFormatEndpointRequest','Required parameter requestParameters.tapeLibraryFormatEndpointRequest was null or undefined when calling formatTape.');
        }

        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/archive/tape/library/format`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: TapeLibraryFormatEndpointRequestToJSON(requestParameters.tapeLibraryFormatEndpointRequest),
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * ### Required permissions    * User account permission: `ltfs:manage`   * License component: ltfs 
     */
    async formatTape(requestParameters: FormatTapeRequest, initOverrides?: RequestInit): Promise<void> {
        await this.formatTapeRaw(requestParameters, initOverrides);
    }

    /**
     * ### Required permissions    * User account permission: `ltfs:search` (read) / `ltfs:manage` (write)   * License component: ltfs 
     */
    async getAllArchivedFileEntriesRaw(requestParameters: GetAllArchivedFileEntriesRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Array<TapeFile>>> {
        const queryParameters: any = {};

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

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

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

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

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

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

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

    /**
     * ### Required permissions    * User account permission: `ltfs:search` (read) / `ltfs:manage` (write)   * License component: ltfs 
     */
    async getAllArchivedFileEntries(requestParameters: GetAllArchivedFileEntriesRequest, initOverrides?: RequestInit): Promise<Array<TapeFile>> {
        const response = await this.getAllArchivedFileEntriesRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `None` (read) / `ltfs:manage` (write)   * License component: ltfs 
     */
    async getAllTapeArchiveJobsRaw(requestParameters: GetAllTapeArchiveJobsRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Array<TapeJob>>> {
        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/archive/tape/jobs`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

    /**
     * ### Required permissions    * User account permission: `None` (read) / `ltfs:manage` (write)   * License component: ltfs 
     */
    async getAllTapeArchiveJobs(requestParameters: GetAllTapeArchiveJobsRequest, initOverrides?: RequestInit): Promise<Array<TapeJob>> {
        const response = await this.getAllTapeArchiveJobsRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `None` (read) / `ltfs:tapegroups:manage` (write)   * License component: ltfs 
     */
    async getAllTapeGroupsRaw(requestParameters: GetAllTapeGroupsRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Array<TapeGroup>>> {
        const queryParameters: any = {};

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

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

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

    /**
     * ### Required permissions    * User account permission: `None` (read) / `ltfs:tapegroups:manage` (write)   * License component: ltfs 
     */
    async getAllTapeGroups(requestParameters: GetAllTapeGroupsRequest, initOverrides?: RequestInit): Promise<Array<TapeGroup>> {
        const response = await this.getAllTapeGroupsRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `None` (read) / `ltfs:tapegroups:manage` (write)   * License component: ltfs 
     */
    async getAllTapesRaw(requestParameters: GetAllTapesRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Array<Tape>>> {
        const queryParameters: any = {};

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

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

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

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

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

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

    /**
     * ### Required permissions    * User account permission: `None` (read) / `ltfs:tapegroups:manage` (write)   * License component: ltfs 
     */
    async getAllTapes(requestParameters: GetAllTapesRequest, initOverrides?: RequestInit): Promise<Array<Tape>> {
        const response = await this.getAllTapesRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `ltfs:search` (read) / `ltfs:manage` (write)   * License component: ltfs 
     */
    async getArchivedFileEntryRaw(requestParameters: GetArchivedFileEntryRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<TapeFile>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling getArchivedFileEntry.');
        }

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

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

    /**
     * ### Required permissions    * User account permission: `ltfs:search` (read) / `ltfs:manage` (write)   * License component: ltfs 
     */
    async getArchivedFileEntry(requestParameters: GetArchivedFileEntryRequest, initOverrides?: RequestInit): Promise<TapeFile> {
        const response = await this.getArchivedFileEntryRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `None` (read) / `ltfs:tapegroups:manage` (write)   * License component: ltfs 
     */
    async getTapeRaw(requestParameters: GetTapeRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Tape>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling getTape.');
        }

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

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

    /**
     * ### Required permissions    * User account permission: `None` (read) / `ltfs:tapegroups:manage` (write)   * License component: ltfs 
     */
    async getTape(requestParameters: GetTapeRequest, initOverrides?: RequestInit): Promise<Tape> {
        const response = await this.getTapeRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `None` (read) / `ltfs:manage` (write)   * License component: ltfs 
     */
    async getTapeArchiveJobRaw(requestParameters: GetTapeArchiveJobRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<TapeJob>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling getTapeArchiveJob.');
        }

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

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

    /**
     * ### Required permissions    * User account permission: `None` (read) / `ltfs:manage` (write)   * License component: ltfs 
     */
    async getTapeArchiveJob(requestParameters: GetTapeArchiveJobRequest, initOverrides?: RequestInit): Promise<TapeJob> {
        const response = await this.getTapeArchiveJobRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `None` (read) / `ltfs:manage` (write)   * License component: ltfs 
     */
    async getTapeArchiveJobSourcesRaw(requestParameters: GetTapeArchiveJobSourcesRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Array<TapeJobSource>>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling getTapeArchiveJobSources.');
        }

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

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

    /**
     * ### Required permissions    * User account permission: `None` (read) / `ltfs:manage` (write)   * License component: ltfs 
     */
    async getTapeArchiveJobSources(requestParameters: GetTapeArchiveJobSourcesRequest, initOverrides?: RequestInit): Promise<Array<TapeJobSource>> {
        const response = await this.getTapeArchiveJobSourcesRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `None` (read) / `ltfs:tapegroups:manage` (write)   * License component: ltfs 
     */
    async getTapeGroupRaw(requestParameters: GetTapeGroupRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<TapeGroup>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling getTapeGroup.');
        }

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

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

    /**
     * ### Required permissions    * User account permission: `None` (read) / `ltfs:tapegroups:manage` (write)   * License component: ltfs 
     */
    async getTapeGroup(requestParameters: GetTapeGroupRequest, initOverrides?: RequestInit): Promise<TapeGroup> {
        const response = await this.getTapeGroupRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `ltfs:manage`   * License component: ltfs 
     */
    async getTapeLibraryStateRaw(initOverrides?: RequestInit): Promise<runtime.ApiResponse<TapeLibraryEndpointResponse>> {
        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/archive/tape/library`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

    /**
     * ### Required permissions    * User account permission: `ltfs:manage`   * License component: ltfs 
     */
    async getTapeLibraryState(initOverrides?: RequestInit): Promise<TapeLibraryEndpointResponse> {
        const response = await this.getTapeLibraryStateRaw(initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `ltfs:manage`   * License component: ltfs 
     */
    async loadTapeRaw(requestParameters: LoadTapeRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.tapeLibraryLoadEndpointRequest === null || requestParameters.tapeLibraryLoadEndpointRequest === undefined) {
            throw new runtime.RequiredError('tapeLibraryLoadEndpointRequest','Required parameter requestParameters.tapeLibraryLoadEndpointRequest was null or undefined when calling loadTape.');
        }

        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/archive/tape/library/load`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: TapeLibraryLoadEndpointRequestToJSON(requestParameters.tapeLibraryLoadEndpointRequest),
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * ### Required permissions    * User account permission: `ltfs:manage`   * License component: ltfs 
     */
    async loadTape(requestParameters: LoadTapeRequest, initOverrides?: RequestInit): Promise<void> {
        await this.loadTapeRaw(requestParameters, initOverrides);
    }

    /**
     * ### Required permissions    * User account permission: `ltfs:manage`   * License component: ltfs 
     */
    async moveTapeRaw(requestParameters: MoveTapeRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.tapeLibraryMoveEndpointRequest === null || requestParameters.tapeLibraryMoveEndpointRequest === undefined) {
            throw new runtime.RequiredError('tapeLibraryMoveEndpointRequest','Required parameter requestParameters.tapeLibraryMoveEndpointRequest was null or undefined when calling moveTape.');
        }

        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/archive/tape/library/move`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: TapeLibraryMoveEndpointRequestToJSON(requestParameters.tapeLibraryMoveEndpointRequest),
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * ### Required permissions    * User account permission: `ltfs:manage`   * License component: ltfs 
     */
    async moveTape(requestParameters: MoveTapeRequest, initOverrides?: RequestInit): Promise<void> {
        await this.moveTapeRaw(requestParameters, initOverrides);
    }

    /**
     * ### Required permissions    * User account permission: `None` (read) / `ltfs:tapegroups:manage` (write)   * License component: ltfs 
     */
    async patchTapeRaw(requestParameters: PatchTapeRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Tape>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling patchTape.');
        }

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

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

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

    /**
     * ### Required permissions    * User account permission: `None` (read) / `ltfs:tapegroups:manage` (write)   * License component: ltfs 
     */
    async patchTape(requestParameters: PatchTapeRequest, initOverrides?: RequestInit): Promise<Tape> {
        const response = await this.patchTapeRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `None` (read) / `ltfs:tapegroups:manage` (write)   * License component: ltfs 
     */
    async patchTapeGroupRaw(requestParameters: PatchTapeGroupRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<TapeGroup>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling patchTapeGroup.');
        }

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

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

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

    /**
     * ### Required permissions    * User account permission: `None` (read) / `ltfs:tapegroups:manage` (write)   * License component: ltfs 
     */
    async patchTapeGroup(requestParameters: PatchTapeGroupRequest, initOverrides?: RequestInit): Promise<TapeGroup> {
        const response = await this.patchTapeGroupRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `None` (read) / `ltfs:manage` (write)   * License component: ltfs 
     */
    async pauseTapeArchiveJobRaw(requestParameters: PauseTapeArchiveJobRequest, 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 pauseTapeArchiveJob.');
        }

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

        return new runtime.VoidApiResponse(response);
    }

    /**
     * ### Required permissions    * User account permission: `None` (read) / `ltfs:manage` (write)   * License component: ltfs 
     */
    async pauseTapeArchiveJob(requestParameters: PauseTapeArchiveJobRequest, initOverrides?: RequestInit): Promise<void> {
        await this.pauseTapeArchiveJobRaw(requestParameters, initOverrides);
    }

    /**
     * ### Required permissions    * User account permission: `ltfs:manage`   * License component: ltfs 
     */
    async refreshTapeLibraryStateRaw(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/archive/tape/library/refresh`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * ### Required permissions    * User account permission: `ltfs:manage`   * License component: ltfs 
     */
    async refreshTapeLibraryState(initOverrides?: RequestInit): Promise<void> {
        await this.refreshTapeLibraryStateRaw(initOverrides);
    }

    /**
     * ### Required permissions    * User account permission: `ltfs:manage`   * License component: ltfs 
     */
    async reindexTapeRaw(requestParameters: ReindexTapeRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.tapeLibraryReindexEndpointRequest === null || requestParameters.tapeLibraryReindexEndpointRequest === undefined) {
            throw new runtime.RequiredError('tapeLibraryReindexEndpointRequest','Required parameter requestParameters.tapeLibraryReindexEndpointRequest was null or undefined when calling reindexTape.');
        }

        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/archive/tape/library/reindex`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: TapeLibraryReindexEndpointRequestToJSON(requestParameters.tapeLibraryReindexEndpointRequest),
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * ### Required permissions    * User account permission: `ltfs:manage`   * License component: ltfs 
     */
    async reindexTape(requestParameters: ReindexTapeRequest, initOverrides?: RequestInit): Promise<void> {
        await this.reindexTapeRaw(requestParameters, initOverrides);
    }

    /**
     * ### Required permissions    * User account permission: `None` (read) / `ltfs:manage` (write)   * License component: ltfs 
     */
    async removeFinishedTapeArchiveJobsRaw(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/archive/tape/jobs/remove-finished`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * ### Required permissions    * User account permission: `None` (read) / `ltfs:manage` (write)   * License component: ltfs 
     */
    async removeFinishedTapeArchiveJobs(initOverrides?: RequestInit): Promise<void> {
        await this.removeFinishedTapeArchiveJobsRaw(initOverrides);
    }

    /**
     * ### Required permissions    * User account permission: `None` (read) / `ltfs:manage` (write)   * License component: ltfs 
     */
    async restartTapeArchiveJobRaw(requestParameters: RestartTapeArchiveJobRequest, 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 restartTapeArchiveJob.');
        }

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

        return new runtime.VoidApiResponse(response);
    }

    /**
     * ### Required permissions    * User account permission: `None` (read) / `ltfs:manage` (write)   * License component: ltfs 
     */
    async restartTapeArchiveJob(requestParameters: RestartTapeArchiveJobRequest, initOverrides?: RequestInit): Promise<void> {
        await this.restartTapeArchiveJobRaw(requestParameters, initOverrides);
    }

    /**
     * ### Required permissions    * User account permission: `ltfs:restore`   * License component: ltfs 
     */
    async restoreFromTapeRaw(requestParameters: RestoreFromTapeRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<TapeJob>> {
        if (requestParameters.restoreEndpointRequest === null || requestParameters.restoreEndpointRequest === undefined) {
            throw new runtime.RequiredError('restoreEndpointRequest','Required parameter requestParameters.restoreEndpointRequest was null or undefined when calling restoreFromTape.');
        }

        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/archive/tape/restore`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: RestoreEndpointRequestToJSON(requestParameters.restoreEndpointRequest),
        }, initOverrides);

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

    /**
     * ### Required permissions    * User account permission: `ltfs:restore`   * License component: ltfs 
     */
    async restoreFromTape(requestParameters: RestoreFromTapeRequest, initOverrides?: RequestInit): Promise<TapeJob> {
        const response = await this.restoreFromTapeRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `None` (read) / `ltfs:manage` (write)   * License component: ltfs 
     */
    async resumeTapeArchiveJobRaw(requestParameters: ResumeTapeArchiveJobRequest, 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 resumeTapeArchiveJob.');
        }

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

        return new runtime.VoidApiResponse(response);
    }

    /**
     * ### Required permissions    * User account permission: `None` (read) / `ltfs:manage` (write)   * License component: ltfs 
     */
    async resumeTapeArchiveJob(requestParameters: ResumeTapeArchiveJobRequest, initOverrides?: RequestInit): Promise<void> {
        await this.resumeTapeArchiveJobRaw(requestParameters, initOverrides);
    }

    /**
     * ### Required permissions    * User account permission: `ltfs:search`   * License component: ltfs 
     */
    async searchTapeArchiveRaw(requestParameters: SearchTapeArchiveRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<SearchEndpointResponse>> {
        if (requestParameters.searchEndpointRequest === null || requestParameters.searchEndpointRequest === undefined) {
            throw new runtime.RequiredError('searchEndpointRequest','Required parameter requestParameters.searchEndpointRequest was null or undefined when calling searchTapeArchive.');
        }

        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/archive/tape/search`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: SearchEndpointRequestToJSON(requestParameters.searchEndpointRequest),
        }, initOverrides);

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

    /**
     * ### Required permissions    * User account permission: `ltfs:search`   * License component: ltfs 
     */
    async searchTapeArchive(requestParameters: SearchTapeArchiveRequest, initOverrides?: RequestInit): Promise<SearchEndpointResponse> {
        const response = await this.searchTapeArchiveRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `ltfs:manage`   * License component: ltfs 
     */
    async unloadTapeRaw(requestParameters: UnloadTapeRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.tapeLibraryUnloadEndpointRequest === null || requestParameters.tapeLibraryUnloadEndpointRequest === undefined) {
            throw new runtime.RequiredError('tapeLibraryUnloadEndpointRequest','Required parameter requestParameters.tapeLibraryUnloadEndpointRequest was null or undefined when calling unloadTape.');
        }

        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/archive/tape/library/unload`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: TapeLibraryUnloadEndpointRequestToJSON(requestParameters.tapeLibraryUnloadEndpointRequest),
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * ### Required permissions    * User account permission: `ltfs:manage`   * License component: ltfs 
     */
    async unloadTape(requestParameters: UnloadTapeRequest, initOverrides?: RequestInit): Promise<void> {
        await this.unloadTapeRaw(requestParameters, initOverrides);
    }

    /**
     * ### Required permissions    * User account permission: `None` (read) / `ltfs:tapegroups:manage` (write)   * License component: ltfs 
     */
    async updateTapeRaw(requestParameters: UpdateTapeRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Tape>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling updateTape.');
        }

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

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

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

    /**
     * ### Required permissions    * User account permission: `None` (read) / `ltfs:tapegroups:manage` (write)   * License component: ltfs 
     */
    async updateTape(requestParameters: UpdateTapeRequest, initOverrides?: RequestInit): Promise<Tape> {
        const response = await this.updateTapeRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `None` (read) / `ltfs:tapegroups:manage` (write)   * License component: ltfs 
     */
    async updateTapeGroupRaw(requestParameters: UpdateTapeGroupRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<TapeGroup>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling updateTapeGroup.');
        }

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

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

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

    /**
     * ### Required permissions    * User account permission: `None` (read) / `ltfs:tapegroups:manage` (write)   * License component: ltfs 
     */
    async updateTapeGroup(requestParameters: UpdateTapeGroupRequest, initOverrides?: RequestInit): Promise<TapeGroup> {
        const response = await this.updateTapeGroupRaw(requestParameters, initOverrides);
        return await response.value();
    }

}