/* 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 {
    BootstrapData,
    BootstrapDataFromJSON,
    BootstrapDataToJSON,
    ClientSidePathEndpointRequest,
    ClientSidePathEndpointRequestFromJSON,
    ClientSidePathEndpointRequestToJSON,
    ClientSidePathEndpointResponse,
    ClientSidePathEndpointResponseFromJSON,
    ClientSidePathEndpointResponseToJSON,
    HelpEndpointResponse,
    HelpEndpointResponseFromJSON,
    HelpEndpointResponseToJSON,
    InstallLicenseEndpointRequest,
    InstallLicenseEndpointRequestFromJSON,
    InstallLicenseEndpointRequestToJSON,
    LocaleEndpointResponse,
    LocaleEndpointResponseFromJSON,
    LocaleEndpointResponseToJSON,
    LocateEndpointRequest,
    LocateEndpointRequestFromJSON,
    LocateEndpointRequestToJSON,
    LocateProxiesEndpointRequest,
    LocateProxiesEndpointRequestFromJSON,
    LocateProxiesEndpointRequestToJSON,
    LocateProxiesEndpointResponse,
    LocateProxiesEndpointResponseFromJSON,
    LocateProxiesEndpointResponseToJSON,
    LocateResult,
    LocateResultFromJSON,
    LocateResultToJSON,
    ProxyFSSizeEndpointResponse,
    ProxyFSSizeEndpointResponseFromJSON,
    ProxyFSSizeEndpointResponseToJSON,
    UploadImageEndpointRequest,
    UploadImageEndpointRequestFromJSON,
    UploadImageEndpointRequestToJSON,
    VeritoneConnection,
    VeritoneConnectionFromJSON,
    VeritoneConnectionToJSON,
    VeritoneEngineList,
    VeritoneEngineListFromJSON,
    VeritoneEngineListToJSON,
    VeritoneJobList,
    VeritoneJobListFromJSON,
    VeritoneJobListToJSON,
    VeritoneMetadata,
    VeritoneMetadataFromJSON,
    VeritoneMetadataToJSON,
    VeritoneUploadRequest,
    VeritoneUploadRequestFromJSON,
    VeritoneUploadRequestToJSON,
} from '../models';

export interface DeleteStoredImageRequest {
    name: string;
}

export interface DeleteVeritoneTDORequest {
    id: number;
    tdoId: string;
}

export interface ExportNonProxiedAssetsRequest {
    rootId: string;
}

export interface ExportNonProxiedAssetsForPathRequest {
    path: string;
    rootId: string;
}

export interface ExportUpdatesRequest {
    rootId: string;
}

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

export interface GetAllVeritoneMetadataRequest {
    asset?: number;
    isParsed?: string;
    ordering?: string;
    limit?: number;
    offset?: number;
}

export interface GetClientSideURLRequest {
    clientSidePathEndpointRequest: ClientSidePathEndpointRequest;
}

export interface GetHelpPageRequest {
    id: string;
}

export interface GetLocaleRequest {
    lang: string;
}

export interface GetStoredImageRequest {
    name: string;
}

export interface GetVeritoneConnectionRequest {
    id: number;
}

export interface GetVeritoneEnginesRequest {
    id: number;
}

export interface GetVeritoneJobsRequest {
    id: number;
    offset?: number;
    limit?: number;
}

export interface GetVeritoneMetadataRequest {
    id: number;
}

export interface InstallLicenseRequest {
    installLicenseEndpointRequest: InstallLicenseEndpointRequest;
}

export interface LanguageServerRequestRequest {
    language: string;
}

export interface LocateFileRequest {
    locateEndpointRequest: LocateEndpointRequest;
}

export interface LocateProxiesRequest {
    locateProxiesEndpointRequest: LocateProxiesEndpointRequest;
}

export interface UploadStoredImageRequest {
    uploadImageEndpointRequest: UploadImageEndpointRequest;
}

export interface UploadToVeritoneRequest {
    id: number;
    veritoneUploadRequest: VeritoneUploadRequest;
}

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

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

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

        return new runtime.VoidApiResponse(response);
    }

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

    /**
     * ### Required permissions    * User account permission: `media:access` 
     */
    async deleteVeritoneTDORaw(requestParameters: DeleteVeritoneTDORequest, 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 deleteVeritoneTDO.');
        }

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

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

        return new runtime.VoidApiResponse(response);
    }

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

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

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

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

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

        return new runtime.VoidApiResponse(response);
    }

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

    /**
     * ### Required permissions    * User account permission: `media:access` 
     */
    async exportNonProxiedAssetsForPathRaw(requestParameters: ExportNonProxiedAssetsForPathRequest, 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 exportNonProxiedAssetsForPath.');
        }

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

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

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

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

        return new runtime.VoidApiResponse(response);
    }

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

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

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

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

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

        return new runtime.VoidApiResponse(response);
    }

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

    /**
     * ### Required permissions    * <class \'rest_framework.permissions.AllowAny\'> 
     */
    async getRaw(initOverrides?: RequestInit): Promise<runtime.ApiResponse<BootstrapData>> {
        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

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

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

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

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

    /**
     * ### Required permissions    * User account permission: `media:access` 
     */
    async getAllVeritoneConnectionsRaw(requestParameters: GetAllVeritoneConnectionsRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Array<VeritoneConnection>>> {
        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/veritone/connections`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

    /**
     * ### Required permissions    * User account permission: `media:access` 
     */
    async getAllVeritoneConnections(requestParameters: GetAllVeritoneConnectionsRequest, initOverrides?: RequestInit): Promise<Array<VeritoneConnection>> {
        const response = await this.getAllVeritoneConnectionsRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access` 
     */
    async getAllVeritoneMetadataRaw(requestParameters: GetAllVeritoneMetadataRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Array<VeritoneMetadata>>> {
        const queryParameters: any = {};

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

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

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

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

    /**
     * ### Required permissions    * User account permission: `media:access` 
     */
    async getAllVeritoneMetadata(requestParameters: GetAllVeritoneMetadataRequest, initOverrides?: RequestInit): Promise<Array<VeritoneMetadata>> {
        const response = await this.getAllVeritoneMetadataRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `client:access` 
     */
    async getClientSideURLRaw(requestParameters: GetClientSideURLRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<ClientSidePathEndpointResponse>> {
        if (requestParameters.clientSidePathEndpointRequest === null || requestParameters.clientSidePathEndpointRequest === undefined) {
            throw new runtime.RequiredError('clientSidePathEndpointRequest','Required parameter requestParameters.clientSidePathEndpointRequest was null or undefined when calling getClientSideURL.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

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

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

        const response = await this.request({
            path: `/api/2/private/client-side-url`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: ClientSidePathEndpointRequestToJSON(requestParameters.clientSidePathEndpointRequest),
        }, initOverrides);

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

    /**
     * ### Required permissions    * User account permission: `client:access` 
     */
    async getClientSideURL(requestParameters: GetClientSideURLRequest, initOverrides?: RequestInit): Promise<ClientSidePathEndpointResponse> {
        const response = await this.getClientSideURLRaw(requestParameters, initOverrides);
        return await response.value();
    }

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

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

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

    /**
     * ### Required permissions    * Authenticated user 
     */
    async getHelpPage(requestParameters: GetHelpPageRequest, initOverrides?: RequestInit): Promise<HelpEndpointResponse> {
        const response = await this.getHelpPageRaw(requestParameters, initOverrides);
        return await response.value();
    }

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

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

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

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

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

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

    /**
     * ### Required permissions    * User account permission: `media:access` 
     */
    async getProxyFSSizeRaw(initOverrides?: RequestInit): Promise<runtime.ApiResponse<ProxyFSSizeEndpointResponse>> {
        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

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

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

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

    /**
     * ### Required permissions    * User account permission: `media:access` 
     */
    async getProxyFSSize(initOverrides?: RequestInit): Promise<ProxyFSSizeEndpointResponse> {
        const response = await this.getProxyFSSizeRaw(initOverrides);
        return await response.value();
    }

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

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

        return new runtime.VoidApiResponse(response);
    }

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

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

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

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

    /**
     * ### Required permissions    * User account permission: `media:access` 
     */
    async getVeritoneConnection(requestParameters: GetVeritoneConnectionRequest, initOverrides?: RequestInit): Promise<VeritoneConnection> {
        const response = await this.getVeritoneConnectionRaw(requestParameters, initOverrides);
        return await response.value();
    }

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

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

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

    /**
     * ### Required permissions    * User account permission: `media:access` 
     */
    async getVeritoneEngines(requestParameters: GetVeritoneEnginesRequest, initOverrides?: RequestInit): Promise<VeritoneEngineList> {
        const response = await this.getVeritoneEnginesRaw(requestParameters, initOverrides);
        return await response.value();
    }

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

        const queryParameters: any = {};

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

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

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

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

    /**
     * ### Required permissions    * User account permission: `media:access` 
     */
    async getVeritoneJobs(requestParameters: GetVeritoneJobsRequest, initOverrides?: RequestInit): Promise<VeritoneJobList> {
        const response = await this.getVeritoneJobsRaw(requestParameters, initOverrides);
        return await response.value();
    }

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

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

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

    /**
     * ### Required permissions    * User account permission: `media:access` 
     */
    async getVeritoneMetadata(requestParameters: GetVeritoneMetadataRequest, initOverrides?: RequestInit): Promise<VeritoneMetadata> {
        const response = await this.getVeritoneMetadataRaw(requestParameters, initOverrides);
        return await response.value();
    }

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

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

        return new runtime.VoidApiResponse(response);
    }

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

    /**
     * ### Required permissions    * User account permission: `system:admin-access` 
     */
    async languageServerRequestRaw(requestParameters: LanguageServerRequestRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<{ [key: string]: object | undefined; }>> {
        if (requestParameters.language === null || requestParameters.language === undefined) {
            throw new runtime.RequiredError('language','Required parameter requestParameters.language was null or undefined when calling languageServerRequest.');
        }

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

        return new runtime.JSONApiResponse<any>(response);
    }

    /**
     * ### Required permissions    * User account permission: `system:admin-access` 
     */
    async languageServerRequest(requestParameters: LanguageServerRequestRequest, initOverrides?: RequestInit): Promise<{ [key: string]: object | undefined; }> {
        const response = await this.languageServerRequestRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * Authenticated user 
     */
    async locateFileRaw(requestParameters: LocateFileRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<LocateResult>> {
        if (requestParameters.locateEndpointRequest === null || requestParameters.locateEndpointRequest === undefined) {
            throw new runtime.RequiredError('locateEndpointRequest','Required parameter requestParameters.locateEndpointRequest was null or undefined when calling locateFile.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

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

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

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

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

    /**
     * ### Required permissions    * Authenticated user 
     */
    async locateFile(requestParameters: LocateFileRequest, initOverrides?: RequestInit): Promise<LocateResult> {
        const response = await this.locateFileRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access` 
     */
    async locateProxiesRaw(requestParameters: LocateProxiesRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Array<LocateProxiesEndpointResponse>>> {
        if (requestParameters.locateProxiesEndpointRequest === null || requestParameters.locateProxiesEndpointRequest === undefined) {
            throw new runtime.RequiredError('locateProxiesEndpointRequest','Required parameter requestParameters.locateProxiesEndpointRequest was null or undefined when calling locateProxies.');
        }

        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/panel/locate-proxies`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: LocateProxiesEndpointRequestToJSON(requestParameters.locateProxiesEndpointRequest),
        }, initOverrides);

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

    /**
     * ### Required permissions    * User account permission: `media:access` 
     */
    async locateProxies(requestParameters: LocateProxiesRequest, initOverrides?: RequestInit): Promise<Array<LocateProxiesEndpointResponse>> {
        const response = await this.locateProxiesRaw(requestParameters, initOverrides);
        return await response.value();
    }

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

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

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

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

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

        return new runtime.VoidApiResponse(response);
    }

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

    /**
     * ### Required permissions    * User account permission: `media:access` 
     */
    async uploadToVeritoneRaw(requestParameters: UploadToVeritoneRequest, 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 uploadToVeritone.');
        }

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

        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/veritone/connections/{id}/upload`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: VeritoneUploadRequestToJSON(requestParameters.veritoneUploadRequest),
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

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

}