/* 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 {
    AIAnnotation,
    AIAnnotationFromJSON,
    AIAnnotationToJSON,
    AIAnnotationCreateRequest,
    AIAnnotationCreateRequestFromJSON,
    AIAnnotationCreateRequestToJSON,
    AIAnnotationPartialUpdate,
    AIAnnotationPartialUpdateFromJSON,
    AIAnnotationPartialUpdateToJSON,
    AIAnnotationUpdate,
    AIAnnotationUpdateFromJSON,
    AIAnnotationUpdateToJSON,
    AICategory,
    AICategoryFromJSON,
    AICategoryToJSON,
    AICategoryDetail,
    AICategoryDetailFromJSON,
    AICategoryDetailToJSON,
    AICategoryDetailPartialUpdate,
    AICategoryDetailPartialUpdateFromJSON,
    AICategoryDetailPartialUpdateToJSON,
    AICategoryDetailUpdate,
    AICategoryDetailUpdateFromJSON,
    AICategoryDetailUpdateToJSON,
    AIConnection,
    AIConnectionFromJSON,
    AIConnectionToJSON,
    AIDatasetExportRequest,
    AIDatasetExportRequestFromJSON,
    AIDatasetExportRequestToJSON,
    AIDatasetExportResponse,
    AIDatasetExportResponseFromJSON,
    AIDatasetExportResponseToJSON,
    AIDatasetWithPreview,
    AIDatasetWithPreviewFromJSON,
    AIDatasetWithPreviewToJSON,
    AIDatasetWithPreviewPartialUpdate,
    AIDatasetWithPreviewPartialUpdateFromJSON,
    AIDatasetWithPreviewPartialUpdateToJSON,
    AIDatasetWithPreviewUpdate,
    AIDatasetWithPreviewUpdateFromJSON,
    AIDatasetWithPreviewUpdateToJSON,
    AIImage,
    AIImageFromJSON,
    AIImageToJSON,
    AIMetadata,
    AIMetadataFromJSON,
    AIMetadataToJSON,
    AIModel,
    AIModelFromJSON,
    AIModelToJSON,
    AIModelExportRequest,
    AIModelExportRequestFromJSON,
    AIModelExportRequestToJSON,
    AIModelExportResponse,
    AIModelExportResponseFromJSON,
    AIModelExportResponseToJSON,
    AIModelInferenceRequest,
    AIModelInferenceRequestFromJSON,
    AIModelInferenceRequestToJSON,
    AIModelInferenceResponse,
    AIModelInferenceResponseFromJSON,
    AIModelInferenceResponseToJSON,
    AIModelPartialUpdate,
    AIModelPartialUpdateFromJSON,
    AIModelPartialUpdateToJSON,
    AIModelTrainingRequest,
    AIModelTrainingRequestFromJSON,
    AIModelTrainingRequestToJSON,
    AIModelUpdate,
    AIModelUpdateFromJSON,
    AIModelUpdateToJSON,
    AIProcessingRequest,
    AIProcessingRequestFromJSON,
    AIProcessingRequestToJSON,
    ImportAIDatasetRequest,
    ImportAIDatasetRequestFromJSON,
    ImportAIDatasetRequestToJSON,
    ImportAIDatasetResponse,
    ImportAIDatasetResponseFromJSON,
    ImportAIDatasetResponseToJSON,
    ImportAIModelRequest,
    ImportAIModelRequestFromJSON,
    ImportAIModelRequestToJSON,
    ImportAIModelResponse,
    ImportAIModelResponseFromJSON,
    ImportAIModelResponseToJSON,
    UploadAIImageRequest,
    UploadAIImageRequestFromJSON,
    UploadAIImageRequestToJSON,
} from '../models';

export interface AbortAIDatasetModelCreationRequest {
    id: string;
}

export interface ActivateAIModelRequest {
    id: string;
}

export interface CreateAIAnnotationTrackRequest {
    aIAnnotationCreateRequest: AIAnnotationCreateRequest;
}

export interface CreateAICategoryRequest {
    aICategoryDetailUpdate: AICategoryDetailUpdate;
}

export interface CreateAIDatasetRequest {
    aIDatasetWithPreviewUpdate: AIDatasetWithPreviewUpdate;
}

export interface CreateAIDatasetModelRequest {
    aIModelTrainingRequest: AIModelTrainingRequest;
}

export interface CreateAIMetadataRequest {
    aIProcessingRequest: AIProcessingRequest;
}

export interface CreateAIModelRequest {
    aIModelUpdate: AIModelUpdate;
}

export interface DeleteAIAnnotationRequest {
    id: string;
}

export interface DeleteAIAnnotationTrackRequest {
    id: string;
}

export interface DeleteAICategoryRequest {
    id: string;
}

export interface DeleteAIDatasetRequest {
    id: string;
}

export interface DeleteAIModelRequest {
    id: string;
}

export interface ExportAIDatasetRequest {
    id: string;
    aIDatasetExportRequest: AIDatasetExportRequest;
}

export interface ExportAIModelRequest {
    id: string;
    aIModelExportRequest: AIModelExportRequest;
}

export interface GetAIAnnotationRequest {
    id: string;
    includeTransformsForAsset?: number;
}

export interface GetAIAnnotationImageRequest {
    id: string;
}

export interface GetAICategoryRequest {
    id: string;
}

export interface GetAIConnectionRequest {
    id: number;
}

export interface GetAIDatasetRequest {
    id: string;
}

export interface GetAIImageRequest {
    id: string;
}

export interface GetAIImageContentRequest {
    id: string;
}

export interface GetAIMetadataRequest {
    id: number;
}

export interface GetAIModelRequest {
    id: string;
}

export interface GetAllAIAnnotationTracksRequest {
    category?: string;
    imageDataset?: string;
    track?: string;
    image?: string;
    ordering?: string;
    limit?: number;
    offset?: number;
}

export interface GetAllAIAnnotationsRequest {
    category?: string;
    imageDataset?: string;
    imageAsset?: number;
    track?: string;
    image?: string;
    ordering?: string;
    limit?: number;
    offset?: number;
    includeTransformsForAsset?: number;
}

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

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

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

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

export interface GetAllAIMetadataRequest {
    asset?: number;
    id?: number;
    ordering?: string;
    limit?: number;
    offset?: number;
}

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

export interface ImportAIDatasetsRequest {
    importAIDatasetRequest: ImportAIDatasetRequest;
}

export interface ImportAIModelsRequest {
    id: string;
    importAIModelRequest: ImportAIModelRequest;
}

export interface PatchAIAnnotationRequest {
    id: string;
    aIAnnotationPartialUpdate: AIAnnotationPartialUpdate;
}

export interface PatchAICategoryRequest {
    id: string;
    aICategoryDetailPartialUpdate: AICategoryDetailPartialUpdate;
}

export interface PatchAIDatasetRequest {
    id: string;
    aIDatasetWithPreviewPartialUpdate: AIDatasetWithPreviewPartialUpdate;
}

export interface PatchAIModelRequest {
    id: string;
    aIModelPartialUpdate: AIModelPartialUpdate;
}

export interface RunAIModelInferenceRequest {
    id: string;
    aIModelInferenceRequest: AIModelInferenceRequest;
}

export interface UpdateAIAnnotationRequest {
    id: string;
    aIAnnotationUpdate: AIAnnotationUpdate;
}

export interface UpdateAICategoryRequest {
    id: string;
    aICategoryDetailUpdate: AICategoryDetailUpdate;
}

export interface UpdateAIDatasetRequest {
    id: string;
    aIDatasetWithPreviewUpdate: AIDatasetWithPreviewUpdate;
}

export interface UpdateAIModelRequest {
    id: string;
    aIModelUpdate: AIModelUpdate;
}

export interface UploadAIImageOperationRequest {
    uploadAIImageRequest: UploadAIImageRequest;
}

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

    /**
     * ### Required permissions    * User account permission: `media:access` (read) / `media:roots:manage` (write) 
     */
    async abortAIDatasetModelCreationRaw(requestParameters: AbortAIDatasetModelCreationRequest, 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 abortAIDatasetModelCreation.');
        }

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

        return new runtime.VoidApiResponse(response);
    }

    /**
     * ### Required permissions    * User account permission: `media:access` (read) / `media:roots:manage` (write) 
     */
    async abortAIDatasetModelCreation(requestParameters: AbortAIDatasetModelCreationRequest, initOverrides?: RequestInit): Promise<void> {
        await this.abortAIDatasetModelCreationRaw(requestParameters, initOverrides);
    }

    /**
     * ### Required permissions    * User account permission: `media:access` (read) / `media:roots:manage` (write) 
     */
    async activateAIModelRaw(requestParameters: ActivateAIModelRequest, 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 activateAIModel.');
        }

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

        return new runtime.VoidApiResponse(response);
    }

    /**
     * ### Required permissions    * User account permission: `media:access` (read) / `media:roots:manage` (write) 
     */
    async activateAIModel(requestParameters: ActivateAIModelRequest, initOverrides?: RequestInit): Promise<void> {
        await this.activateAIModelRaw(requestParameters, initOverrides);
    }

    /**
     * ### Required permissions    * User account permission: `None` (read) / `media:roots:manage` (write) 
     */
    async createAIAnnotationTrackRaw(requestParameters: CreateAIAnnotationTrackRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Array<AIAnnotation>>> {
        if (requestParameters.aIAnnotationCreateRequest === null || requestParameters.aIAnnotationCreateRequest === undefined) {
            throw new runtime.RequiredError('aIAnnotationCreateRequest','Required parameter requestParameters.aIAnnotationCreateRequest was null or undefined when calling createAIAnnotationTrack.');
        }

        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/ai/annotations/tracks/create`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: AIAnnotationCreateRequestToJSON(requestParameters.aIAnnotationCreateRequest),
        }, initOverrides);

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

    /**
     * ### Required permissions    * User account permission: `None` (read) / `media:roots:manage` (write) 
     */
    async createAIAnnotationTrack(requestParameters: CreateAIAnnotationTrackRequest, initOverrides?: RequestInit): Promise<Array<AIAnnotation>> {
        const response = await this.createAIAnnotationTrackRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `None` (read) / `media:roots:manage` (write) 
     */
    async createAICategoryRaw(requestParameters: CreateAICategoryRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<AICategoryDetail>> {
        if (requestParameters.aICategoryDetailUpdate === null || requestParameters.aICategoryDetailUpdate === undefined) {
            throw new runtime.RequiredError('aICategoryDetailUpdate','Required parameter requestParameters.aICategoryDetailUpdate was null or undefined when calling createAICategory.');
        }

        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/ai/categories`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: AICategoryDetailUpdateToJSON(requestParameters.aICategoryDetailUpdate),
        }, initOverrides);

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

    /**
     * ### Required permissions    * User account permission: `None` (read) / `media:roots:manage` (write) 
     */
    async createAICategory(requestParameters: CreateAICategoryRequest, initOverrides?: RequestInit): Promise<AICategoryDetail> {
        const response = await this.createAICategoryRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `None` (read) / `media:roots:manage` (write) 
     */
    async createAIDatasetRaw(requestParameters: CreateAIDatasetRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<AIDatasetWithPreview>> {
        if (requestParameters.aIDatasetWithPreviewUpdate === null || requestParameters.aIDatasetWithPreviewUpdate === undefined) {
            throw new runtime.RequiredError('aIDatasetWithPreviewUpdate','Required parameter requestParameters.aIDatasetWithPreviewUpdate was null or undefined when calling createAIDataset.');
        }

        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/ai/datasets`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: AIDatasetWithPreviewUpdateToJSON(requestParameters.aIDatasetWithPreviewUpdate),
        }, initOverrides);

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

    /**
     * ### Required permissions    * User account permission: `None` (read) / `media:roots:manage` (write) 
     */
    async createAIDataset(requestParameters: CreateAIDatasetRequest, initOverrides?: RequestInit): Promise<AIDatasetWithPreview> {
        const response = await this.createAIDatasetRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access` (read) / `media:roots:manage` (write) 
     */
    async createAIDatasetModelRaw(requestParameters: CreateAIDatasetModelRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<AIModel>> {
        if (requestParameters.aIModelTrainingRequest === null || requestParameters.aIModelTrainingRequest === undefined) {
            throw new runtime.RequiredError('aIModelTrainingRequest','Required parameter requestParameters.aIModelTrainingRequest was null or undefined when calling createAIDatasetModel.');
        }

        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/ai/models/create`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: AIModelTrainingRequestToJSON(requestParameters.aIModelTrainingRequest),
        }, initOverrides);

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

    /**
     * ### Required permissions    * User account permission: `media:access` (read) / `media:roots:manage` (write) 
     */
    async createAIDatasetModel(requestParameters: CreateAIDatasetModelRequest, initOverrides?: RequestInit): Promise<AIModel> {
        const response = await this.createAIDatasetModelRaw(requestParameters, initOverrides);
        return await response.value();
    }

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

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

        return new runtime.VoidApiResponse(response);
    }

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

    /**
     * ### Required permissions    * User account permission: `media:access` (read) / `media:roots:manage` (write) 
     */
    async createAIModelRaw(requestParameters: CreateAIModelRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<AIModel>> {
        if (requestParameters.aIModelUpdate === null || requestParameters.aIModelUpdate === undefined) {
            throw new runtime.RequiredError('aIModelUpdate','Required parameter requestParameters.aIModelUpdate was null or undefined when calling createAIModel.');
        }

        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/ai/models`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: AIModelUpdateToJSON(requestParameters.aIModelUpdate),
        }, initOverrides);

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

    /**
     * ### Required permissions    * User account permission: `media:access` (read) / `media:roots:manage` (write) 
     */
    async createAIModel(requestParameters: CreateAIModelRequest, initOverrides?: RequestInit): Promise<AIModel> {
        const response = await this.createAIModelRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `None` (read) / `media:roots:manage` (write) 
     */
    async deleteAIAnnotationRaw(requestParameters: DeleteAIAnnotationRequest, 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 deleteAIAnnotation.');
        }

        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/ai/annotations/{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) / `media:roots:manage` (write) 
     */
    async deleteAIAnnotation(requestParameters: DeleteAIAnnotationRequest, initOverrides?: RequestInit): Promise<void> {
        await this.deleteAIAnnotationRaw(requestParameters, initOverrides);
    }

    /**
     * ### Required permissions    * User account permission: `None` (read) / `media:roots:manage` (write) 
     */
    async deleteAIAnnotationTrackRaw(requestParameters: DeleteAIAnnotationTrackRequest, 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 deleteAIAnnotationTrack.');
        }

        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/ai/annotations/tracks/{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) / `media:roots:manage` (write) 
     */
    async deleteAIAnnotationTrack(requestParameters: DeleteAIAnnotationTrackRequest, initOverrides?: RequestInit): Promise<void> {
        await this.deleteAIAnnotationTrackRaw(requestParameters, initOverrides);
    }

    /**
     * ### Required permissions    * User account permission: `None` (read) / `media:roots:manage` (write) 
     */
    async deleteAICategoryRaw(requestParameters: DeleteAICategoryRequest, 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 deleteAICategory.');
        }

        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/ai/categories/{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) / `media:roots:manage` (write) 
     */
    async deleteAICategory(requestParameters: DeleteAICategoryRequest, initOverrides?: RequestInit): Promise<void> {
        await this.deleteAICategoryRaw(requestParameters, initOverrides);
    }

    /**
     * ### Required permissions    * User account permission: `None` (read) / `media:roots:manage` (write) 
     */
    async deleteAIDatasetRaw(requestParameters: DeleteAIDatasetRequest, 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 deleteAIDataset.');
        }

        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/ai/datasets/{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) / `media:roots:manage` (write) 
     */
    async deleteAIDataset(requestParameters: DeleteAIDatasetRequest, initOverrides?: RequestInit): Promise<void> {
        await this.deleteAIDatasetRaw(requestParameters, initOverrides);
    }

    /**
     * ### Required permissions    * User account permission: `media:access` (read) / `media:roots:manage` (write) 
     */
    async deleteAIModelRaw(requestParameters: DeleteAIModelRequest, 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 deleteAIModel.');
        }

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

        return new runtime.VoidApiResponse(response);
    }

    /**
     * ### Required permissions    * User account permission: `media:access` (read) / `media:roots:manage` (write) 
     */
    async deleteAIModel(requestParameters: DeleteAIModelRequest, initOverrides?: RequestInit): Promise<void> {
        await this.deleteAIModelRaw(requestParameters, initOverrides);
    }

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

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

        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/ai/datasets/{id}/export`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: AIDatasetExportRequestToJSON(requestParameters.aIDatasetExportRequest),
        }, initOverrides);

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

    /**
     * ### Required permissions    * User account permission: `None` (read) / `media:roots:manage` (write) 
     */
    async exportAIDataset(requestParameters: ExportAIDatasetRequest, initOverrides?: RequestInit): Promise<AIDatasetExportResponse> {
        const response = await this.exportAIDatasetRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access` (read) / `media:roots:manage` (write) 
     */
    async exportAIModelRaw(requestParameters: ExportAIModelRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<AIModelExportResponse>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling exportAIModel.');
        }

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

        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/ai/models/{id}/export`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: AIModelExportRequestToJSON(requestParameters.aIModelExportRequest),
        }, initOverrides);

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

    /**
     * ### Required permissions    * User account permission: `media:access` (read) / `media:roots:manage` (write) 
     */
    async exportAIModel(requestParameters: ExportAIModelRequest, initOverrides?: RequestInit): Promise<AIModelExportResponse> {
        const response = await this.exportAIModelRaw(requestParameters, initOverrides);
        return await response.value();
    }

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

        const queryParameters: any = {};

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

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

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

    /**
     * ### Required permissions    * User account permission: `None` (read) / `media:roots:manage` (write) 
     */
    async getAIAnnotation(requestParameters: GetAIAnnotationRequest, initOverrides?: RequestInit): Promise<AIAnnotation> {
        const response = await this.getAIAnnotationRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `None` (read) / `media:roots:manage` (write) 
     */
    async getAIAnnotationImageRaw(requestParameters: GetAIAnnotationImageRequest, 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 getAIAnnotationImage.');
        }

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

        return new runtime.VoidApiResponse(response);
    }

    /**
     * ### Required permissions    * User account permission: `None` (read) / `media:roots:manage` (write) 
     */
    async getAIAnnotationImage(requestParameters: GetAIAnnotationImageRequest, initOverrides?: RequestInit): Promise<void> {
        await this.getAIAnnotationImageRaw(requestParameters, initOverrides);
    }

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

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

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

    /**
     * ### Required permissions    * User account permission: `None` (read) / `media:roots:manage` (write) 
     */
    async getAICategory(requestParameters: GetAICategoryRequest, initOverrides?: RequestInit): Promise<AICategoryDetail> {
        const response = await this.getAICategoryRaw(requestParameters, initOverrides);
        return await response.value();
    }

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

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

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

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

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

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

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

    /**
     * ### Required permissions    * User account permission: `None` (read) / `media:roots:manage` (write) 
     */
    async getAIDataset(requestParameters: GetAIDatasetRequest, initOverrides?: RequestInit): Promise<AIDatasetWithPreview> {
        const response = await this.getAIDatasetRaw(requestParameters, initOverrides);
        return await response.value();
    }

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

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

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

    /**
     * ### Required permissions    * User account permission: `None` (read) / `media:roots:manage` (write) 
     */
    async getAIImage(requestParameters: GetAIImageRequest, initOverrides?: RequestInit): Promise<AIImage> {
        const response = await this.getAIImageRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `None` (read) / `media:roots:manage` (write) 
     */
    async getAIImageContentRaw(requestParameters: GetAIImageContentRequest, 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 getAIImageContent.');
        }

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

        return new runtime.VoidApiResponse(response);
    }

    /**
     * ### Required permissions    * User account permission: `None` (read) / `media:roots:manage` (write) 
     */
    async getAIImageContent(requestParameters: GetAIImageContentRequest, initOverrides?: RequestInit): Promise<void> {
        await this.getAIImageContentRaw(requestParameters, initOverrides);
    }

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

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

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

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

    /**
     * ### Required permissions    * User account permission: `media:access` (read) / `media:roots:manage` (write) 
     */
    async getAIModelRaw(requestParameters: GetAIModelRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<AIModel>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling getAIModel.');
        }

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

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

    /**
     * ### Required permissions    * User account permission: `media:access` (read) / `media:roots:manage` (write) 
     */
    async getAIModel(requestParameters: GetAIModelRequest, initOverrides?: RequestInit): Promise<AIModel> {
        const response = await this.getAIModelRaw(requestParameters, initOverrides);
        return await response.value();
    }

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

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

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

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

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

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

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

    /**
     * ### Required permissions    * User account permission: `None` (read) / `media:roots:manage` (write) 
     */
    async getAllAIAnnotationTracks(requestParameters: GetAllAIAnnotationTracksRequest, initOverrides?: RequestInit): Promise<Array<AIAnnotation>> {
        const response = await this.getAllAIAnnotationTracksRaw(requestParameters, initOverrides);
        return await response.value();
    }

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

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

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

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

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

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

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

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

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

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

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

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

    /**
     * ### Required permissions    * User account permission: `None` (read) / `media:roots:manage` (write) 
     */
    async getAllAIAnnotations(requestParameters: GetAllAIAnnotationsRequest, initOverrides?: RequestInit): Promise<Array<AIAnnotation>> {
        const response = await this.getAllAIAnnotationsRaw(requestParameters, initOverrides);
        return await response.value();
    }

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

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

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

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

    /**
     * ### Required permissions    * User account permission: `None` (read) / `media:roots:manage` (write) 
     */
    async getAllAICategories(requestParameters: GetAllAICategoriesRequest, initOverrides?: RequestInit): Promise<Array<AICategory>> {
        const response = await this.getAllAICategoriesRaw(requestParameters, initOverrides);
        return await response.value();
    }

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

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

    /**
     * ### Required permissions    * <class \'rest_framework.permissions.AllowAny\'> 
     */
    async getAllAIConnections(requestParameters: GetAllAIConnectionsRequest, initOverrides?: RequestInit): Promise<Array<AIConnection>> {
        const response = await this.getAllAIConnectionsRaw(requestParameters, initOverrides);
        return await response.value();
    }

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

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

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

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

    /**
     * ### Required permissions    * User account permission: `None` (read) / `media:roots:manage` (write) 
     */
    async getAllAIDatasets(requestParameters: GetAllAIDatasetsRequest, initOverrides?: RequestInit): Promise<Array<AIDatasetWithPreview>> {
        const response = await this.getAllAIDatasetsRaw(requestParameters, initOverrides);
        return await response.value();
    }

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

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

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

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

    /**
     * ### Required permissions    * User account permission: `None` (read) / `media:roots:manage` (write) 
     */
    async getAllAIImages(requestParameters: GetAllAIImagesRequest, initOverrides?: RequestInit): Promise<Array<AIImage>> {
        const response = await this.getAllAIImagesRaw(requestParameters, initOverrides);
        return await response.value();
    }

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

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

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

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

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

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

    /**
     * ### Required permissions    * User account permission: `media:access` (read) / `media:roots:manage` (write) 
     */
    async getAllAIModelsRaw(requestParameters: GetAllAIModelsRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Array<AIModel>>> {
        const queryParameters: any = {};

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

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

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

    /**
     * ### Required permissions    * User account permission: `media:access` (read) / `media:roots:manage` (write) 
     */
    async getAllAIModels(requestParameters: GetAllAIModelsRequest, initOverrides?: RequestInit): Promise<Array<AIModel>> {
        const response = await this.getAllAIModelsRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `None` (read) / `media:roots:manage` (write) 
     */
    async importAIDatasetsRaw(requestParameters: ImportAIDatasetsRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<ImportAIDatasetResponse>> {
        if (requestParameters.importAIDatasetRequest === null || requestParameters.importAIDatasetRequest === undefined) {
            throw new runtime.RequiredError('importAIDatasetRequest','Required parameter requestParameters.importAIDatasetRequest was null or undefined when calling importAIDatasets.');
        }

        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/ai/datasets/import`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: ImportAIDatasetRequestToJSON(requestParameters.importAIDatasetRequest),
        }, initOverrides);

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

    /**
     * ### Required permissions    * User account permission: `None` (read) / `media:roots:manage` (write) 
     */
    async importAIDatasets(requestParameters: ImportAIDatasetsRequest, initOverrides?: RequestInit): Promise<ImportAIDatasetResponse> {
        const response = await this.importAIDatasetsRaw(requestParameters, initOverrides);
        return await response.value();
    }

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

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

        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/ai/datasets/{id}/import-models`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: ImportAIModelRequestToJSON(requestParameters.importAIModelRequest),
        }, initOverrides);

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

    /**
     * ### Required permissions    * User account permission: `None` (read) / `media:roots:manage` (write) 
     */
    async importAIModels(requestParameters: ImportAIModelsRequest, initOverrides?: RequestInit): Promise<ImportAIModelResponse> {
        const response = await this.importAIModelsRaw(requestParameters, initOverrides);
        return await response.value();
    }

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

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

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

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

    /**
     * ### Required permissions    * User account permission: `None` (read) / `media:roots:manage` (write) 
     */
    async patchAIAnnotation(requestParameters: PatchAIAnnotationRequest, initOverrides?: RequestInit): Promise<AIAnnotation> {
        const response = await this.patchAIAnnotationRaw(requestParameters, initOverrides);
        return await response.value();
    }

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

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

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

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

    /**
     * ### Required permissions    * User account permission: `None` (read) / `media:roots:manage` (write) 
     */
    async patchAICategory(requestParameters: PatchAICategoryRequest, initOverrides?: RequestInit): Promise<AICategoryDetail> {
        const response = await this.patchAICategoryRaw(requestParameters, initOverrides);
        return await response.value();
    }

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

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

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

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

    /**
     * ### Required permissions    * User account permission: `None` (read) / `media:roots:manage` (write) 
     */
    async patchAIDataset(requestParameters: PatchAIDatasetRequest, initOverrides?: RequestInit): Promise<AIDatasetWithPreview> {
        const response = await this.patchAIDatasetRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access` (read) / `media:roots:manage` (write) 
     */
    async patchAIModelRaw(requestParameters: PatchAIModelRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<AIModel>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling patchAIModel.');
        }

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

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

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

    /**
     * ### Required permissions    * User account permission: `media:access` (read) / `media:roots:manage` (write) 
     */
    async patchAIModel(requestParameters: PatchAIModelRequest, initOverrides?: RequestInit): Promise<AIModel> {
        const response = await this.patchAIModelRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access` (read) / `media:roots:manage` (write) 
     */
    async runAIModelInferenceRaw(requestParameters: RunAIModelInferenceRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<AIModelInferenceResponse>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling runAIModelInference.');
        }

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

        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/ai/models/{id}/inference`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: AIModelInferenceRequestToJSON(requestParameters.aIModelInferenceRequest),
        }, initOverrides);

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

    /**
     * ### Required permissions    * User account permission: `media:access` (read) / `media:roots:manage` (write) 
     */
    async runAIModelInference(requestParameters: RunAIModelInferenceRequest, initOverrides?: RequestInit): Promise<AIModelInferenceResponse> {
        const response = await this.runAIModelInferenceRaw(requestParameters, initOverrides);
        return await response.value();
    }

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

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

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

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

    /**
     * ### Required permissions    * User account permission: `None` (read) / `media:roots:manage` (write) 
     */
    async updateAIAnnotation(requestParameters: UpdateAIAnnotationRequest, initOverrides?: RequestInit): Promise<AIAnnotation> {
        const response = await this.updateAIAnnotationRaw(requestParameters, initOverrides);
        return await response.value();
    }

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

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

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

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

    /**
     * ### Required permissions    * User account permission: `None` (read) / `media:roots:manage` (write) 
     */
    async updateAICategory(requestParameters: UpdateAICategoryRequest, initOverrides?: RequestInit): Promise<AICategoryDetail> {
        const response = await this.updateAICategoryRaw(requestParameters, initOverrides);
        return await response.value();
    }

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

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

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

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

    /**
     * ### Required permissions    * User account permission: `None` (read) / `media:roots:manage` (write) 
     */
    async updateAIDataset(requestParameters: UpdateAIDatasetRequest, initOverrides?: RequestInit): Promise<AIDatasetWithPreview> {
        const response = await this.updateAIDatasetRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `media:access` (read) / `media:roots:manage` (write) 
     */
    async updateAIModelRaw(requestParameters: UpdateAIModelRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<AIModel>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling updateAIModel.');
        }

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

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

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

    /**
     * ### Required permissions    * User account permission: `media:access` (read) / `media:roots:manage` (write) 
     */
    async updateAIModel(requestParameters: UpdateAIModelRequest, initOverrides?: RequestInit): Promise<AIModel> {
        const response = await this.updateAIModelRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `None` (read) / `media:roots:manage` (write) 
     */
    async uploadAIImageRaw(requestParameters: UploadAIImageOperationRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<AIImage>> {
        if (requestParameters.uploadAIImageRequest === null || requestParameters.uploadAIImageRequest === undefined) {
            throw new runtime.RequiredError('uploadAIImageRequest','Required parameter requestParameters.uploadAIImageRequest was null or undefined when calling uploadAIImage.');
        }

        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/ai/images/upload`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: UploadAIImageRequestToJSON(requestParameters.uploadAIImageRequest),
        }, initOverrides);

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

    /**
     * ### Required permissions    * User account permission: `None` (read) / `media:roots:manage` (write) 
     */
    async uploadAIImage(requestParameters: UploadAIImageOperationRequest, initOverrides?: RequestInit): Promise<AIImage> {
        const response = await this.uploadAIImageRaw(requestParameters, initOverrides);
        return await response.value();
    }

}