/* 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 {
    Event,
    EventFromJSON,
    EventToJSON,
    ImportJobRequest,
    ImportJobRequestFromJSON,
    ImportJobRequestToJSON,
    ImportJobResponse,
    ImportJobResponseFromJSON,
    ImportJobResponseToJSON,
    Job,
    JobFromJSON,
    JobToJSON,
    JobPartialUpdate,
    JobPartialUpdateFromJSON,
    JobPartialUpdateToJSON,
    JobUpdate,
    JobUpdateFromJSON,
    JobUpdateToJSON,
    PythonEnvironment,
    PythonEnvironmentFromJSON,
    PythonEnvironmentToJSON,
    Queue,
    QueueFromJSON,
    QueueToJSON,
    Schedule,
    ScheduleFromJSON,
    ScheduleToJSON,
    SchedulePartialUpdate,
    SchedulePartialUpdateFromJSON,
    SchedulePartialUpdateToJSON,
    ScheduleUpdate,
    ScheduleUpdateFromJSON,
    ScheduleUpdateToJSON,
    StartJobRequest,
    StartJobRequestFromJSON,
    StartJobRequestToJSON,
    StartTaskRequest,
    StartTaskRequestFromJSON,
    StartTaskRequestToJSON,
    Subtask,
    SubtaskFromJSON,
    SubtaskToJSON,
    SubtaskPartialUpdate,
    SubtaskPartialUpdateFromJSON,
    SubtaskPartialUpdateToJSON,
    SubtaskUpdate,
    SubtaskUpdateFromJSON,
    SubtaskUpdateToJSON,
    TaskInfo,
    TaskInfoFromJSON,
    TaskInfoToJSON,
    TaskLog,
    TaskLogFromJSON,
    TaskLogToJSON,
    TaskType,
    TaskTypeFromJSON,
    TaskTypeToJSON,
    TasksSummary,
    TasksSummaryFromJSON,
    TasksSummaryToJSON,
} from '../models';

export interface AbortTaskRequest {
    id: string;
}

export interface CreateJobRequest {
    jobUpdate: JobUpdate;
}

export interface CreateScheduleRequest {
    scheduleUpdate: ScheduleUpdate;
}

export interface CreateSubtaskRequest {
    subtaskUpdate: SubtaskUpdate;
}

export interface DeleteJobRequest {
    id: number;
}

export interface DeleteScheduleRequest {
    id: number;
}

export interface DeleteSubtaskRequest {
    id: number;
}

export interface DeleteTaskRequest {
    id: string;
}

export interface DownloadAllTaskLogsRequest {
    jobInstance?: string;
    jobInstanceIn?: string;
    subtask?: number;
    state?: string;
    stateIn?: number;
    id?: string;
    idIn?: string;
    name?: string;
    taskName?: string;
    ordering?: string;
    limit?: number;
    offset?: number;
}

export interface DownloadTaskLogRequest {
    id: string;
}

export interface ExportJobRequest {
    id: number;
}

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

export interface GetAllJobsRequest {
    specialType?: string;
    specialTypeIsnull?: string;
    hook?: string;
    name?: string;
    ordering?: string;
    limit?: number;
    offset?: number;
}

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

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

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

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

export interface GetAllTasksRequest {
    jobInstance?: string;
    jobInstanceIn?: string;
    subtask?: number;
    state?: string;
    stateIn?: number;
    id?: string;
    idIn?: string;
    name?: string;
    taskName?: string;
    ordering?: string;
    limit?: number;
    offset?: number;
}

export interface GetEventRequest {
    id: string;
}

export interface GetFinishedTasksRequest {
    jobInstance?: string;
    jobInstanceIn?: string;
    subtask?: number;
    state?: string;
    stateIn?: number;
    id?: string;
    idIn?: string;
    name?: string;
    taskName?: string;
    ordering?: string;
    limit?: number;
    offset?: number;
}

export interface GetJobRequest {
    id: number;
}

export interface GetPendingTasksRequest {
    jobInstance?: string;
    jobInstanceIn?: string;
    subtask?: number;
    state?: string;
    stateIn?: number;
    id?: string;
    idIn?: string;
    name?: string;
    taskName?: string;
    ordering?: string;
    limit?: number;
    offset?: number;
}

export interface GetScheduleRequest {
    id: number;
}

export interface GetSubtaskRequest {
    id: number;
}

export interface GetTaskRequest {
    id: string;
}

export interface GetTaskLogRequest {
    id: string;
}

export interface GetTaskTypeRequest {
    type: string;
}

export interface GetTasksSummaryRequest {
    jobInstance?: string;
    jobInstanceIn?: string;
    subtask?: number;
    state?: string;
    stateIn?: number;
    id?: string;
    idIn?: string;
    name?: string;
    taskName?: string;
    ordering?: string;
    limit?: number;
    offset?: number;
}

export interface ImportJobOperationRequest {
    importJobRequest: ImportJobRequest;
}

export interface KillTaskRequest {
    id: string;
}

export interface PatchJobRequest {
    id: number;
    jobPartialUpdate: JobPartialUpdate;
}

export interface PatchScheduleRequest {
    id: number;
    schedulePartialUpdate: SchedulePartialUpdate;
}

export interface PatchSubtaskRequest {
    id: number;
    subtaskPartialUpdate: SubtaskPartialUpdate;
}

export interface RestartTaskRequest {
    id: string;
}

export interface StartJobOperationRequest {
    id: number;
    startJobRequest: StartJobRequest;
}

export interface StartTaskOperationRequest {
    startTaskRequest: StartTaskRequest;
}

export interface UpdateJobRequest {
    id: number;
    jobUpdate: JobUpdate;
}

export interface UpdateScheduleRequest {
    id: number;
    scheduleUpdate: ScheduleUpdate;
}

export interface UpdateSubtaskRequest {
    id: number;
    subtaskUpdate: SubtaskUpdate;
}

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

    /**
     * ### Required permissions    * User account permission: `tasks:manage` 
     */
    async abortTaskRaw(requestParameters: AbortTaskRequest, 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 abortTask.');
        }

        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/tasks/{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: `tasks:manage` 
     */
    async abortTask(requestParameters: AbortTaskRequest, initOverrides?: RequestInit): Promise<void> {
        await this.abortTaskRaw(requestParameters, initOverrides);
    }

    /**
     * ### Required permissions    * User account permission: `None` (read) / `tasks:manage` (write) 
     */
    async createJobRaw(requestParameters: CreateJobRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Job>> {
        if (requestParameters.jobUpdate === null || requestParameters.jobUpdate === undefined) {
            throw new runtime.RequiredError('jobUpdate','Required parameter requestParameters.jobUpdate was null or undefined when calling createJob.');
        }

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

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

    /**
     * ### Required permissions    * User account permission: `None` (read) / `tasks:manage` (write) 
     */
    async createJob(requestParameters: CreateJobRequest, initOverrides?: RequestInit): Promise<Job> {
        const response = await this.createJobRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `tasks:view` (read) / `tasks:manage` (write) 
     */
    async createScheduleRaw(requestParameters: CreateScheduleRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Schedule>> {
        if (requestParameters.scheduleUpdate === null || requestParameters.scheduleUpdate === undefined) {
            throw new runtime.RequiredError('scheduleUpdate','Required parameter requestParameters.scheduleUpdate was null or undefined when calling createSchedule.');
        }

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

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

    /**
     * ### Required permissions    * User account permission: `tasks:view` (read) / `tasks:manage` (write) 
     */
    async createSchedule(requestParameters: CreateScheduleRequest, initOverrides?: RequestInit): Promise<Schedule> {
        const response = await this.createScheduleRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `tasks:view` (read) / `tasks:manage` (write) 
     */
    async createSubtaskRaw(requestParameters: CreateSubtaskRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Subtask>> {
        if (requestParameters.subtaskUpdate === null || requestParameters.subtaskUpdate === undefined) {
            throw new runtime.RequiredError('subtaskUpdate','Required parameter requestParameters.subtaskUpdate was null or undefined when calling createSubtask.');
        }

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

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

    /**
     * ### Required permissions    * User account permission: `tasks:view` (read) / `tasks:manage` (write) 
     */
    async createSubtask(requestParameters: CreateSubtaskRequest, initOverrides?: RequestInit): Promise<Subtask> {
        const response = await this.createSubtaskRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `None` (read) / `tasks:manage` (write) 
     */
    async deleteFinishedTasksRaw(initOverrides?: RequestInit): Promise<runtime.ApiResponse<void>> {
        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

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

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

        return new runtime.VoidApiResponse(response);
    }

    /**
     * ### Required permissions    * User account permission: `None` (read) / `tasks:manage` (write) 
     */
    async deleteFinishedTasks(initOverrides?: RequestInit): Promise<void> {
        await this.deleteFinishedTasksRaw(initOverrides);
    }

    /**
     * ### Required permissions    * User account permission: `None` (read) / `tasks:manage` (write) 
     */
    async deleteJobRaw(requestParameters: DeleteJobRequest, 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 deleteJob.');
        }

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

        return new runtime.VoidApiResponse(response);
    }

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

    /**
     * ### Required permissions    * User account permission: `tasks:view` (read) / `tasks:manage` (write) 
     */
    async deleteScheduleRaw(requestParameters: DeleteScheduleRequest, 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 deleteSchedule.');
        }

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

        return new runtime.VoidApiResponse(response);
    }

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

    /**
     * ### Required permissions    * User account permission: `tasks:view` (read) / `tasks:manage` (write) 
     */
    async deleteSubtaskRaw(requestParameters: DeleteSubtaskRequest, 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 deleteSubtask.');
        }

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

        return new runtime.VoidApiResponse(response);
    }

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

    /**
     * ### Required permissions    * User account permission: `None` (read) / `tasks:manage` (write) 
     */
    async deleteTaskRaw(requestParameters: DeleteTaskRequest, 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 deleteTask.');
        }

        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/tasks/{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) / `tasks:manage` (write) 
     */
    async deleteTask(requestParameters: DeleteTaskRequest, initOverrides?: RequestInit): Promise<void> {
        await this.deleteTaskRaw(requestParameters, initOverrides);
    }

    /**
     * ### Required permissions    * User account permission: `tasks:view` 
     */
    async downloadAllTaskLogsRaw(requestParameters: DownloadAllTaskLogsRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<void>> {
        const queryParameters: any = {};

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

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

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

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

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

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

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

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

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

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

        return new runtime.VoidApiResponse(response);
    }

    /**
     * ### Required permissions    * User account permission: `tasks:view` 
     */
    async downloadAllTaskLogs(requestParameters: DownloadAllTaskLogsRequest, initOverrides?: RequestInit): Promise<void> {
        await this.downloadAllTaskLogsRaw(requestParameters, initOverrides);
    }

    /**
     * ### Required permissions    * User account permission: `tasks:view` 
     */
    async downloadTaskLogRaw(requestParameters: DownloadTaskLogRequest, 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 downloadTaskLog.');
        }

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

        return new runtime.VoidApiResponse(response);
    }

    /**
     * ### Required permissions    * User account permission: `tasks:view` 
     */
    async downloadTaskLog(requestParameters: DownloadTaskLogRequest, initOverrides?: RequestInit): Promise<void> {
        await this.downloadTaskLogRaw(requestParameters, initOverrides);
    }

    /**
     * ### Required permissions    * User account permission: `None` (read) / `tasks:manage` (write) 
     */
    async exportJobRaw(requestParameters: ExportJobRequest, 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 exportJob.');
        }

        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/jobs/{id}/export`.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) / `tasks:manage` (write) 
     */
    async exportJob(requestParameters: ExportJobRequest, initOverrides?: RequestInit): Promise<void> {
        await this.exportJobRaw(requestParameters, initOverrides);
    }

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

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

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

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

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

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

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

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

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

    /**
     * ### Required permissions    * User account permission: `None` (read) / `tasks:manage` (write) 
     */
    async getAllJobs(requestParameters: GetAllJobsRequest, initOverrides?: RequestInit): Promise<Array<Job>> {
        const response = await this.getAllJobsRaw(requestParameters, initOverrides);
        return await response.value();
    }

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

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

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

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

    /**
     * ### Required permissions    * User account permission: `tasks:view` (read) / `tasks:manage` (write) 
     */
    async getAllSchedules(requestParameters: GetAllSchedulesRequest, initOverrides?: RequestInit): Promise<Array<Schedule>> {
        const response = await this.getAllSchedulesRaw(requestParameters, initOverrides);
        return await response.value();
    }

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

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

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

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

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

        const headerParameters: runtime.HTTPHeaders = {};

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

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

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

    /**
     * ### Required permissions    * User account permission: `tasks:view` (read) / `tasks:manage` (write) 
     */
    async getAllSubtasks(requestParameters: GetAllSubtasksRequest, initOverrides?: RequestInit): Promise<Array<Subtask>> {
        const response = await this.getAllSubtasksRaw(requestParameters, initOverrides);
        return await response.value();
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    /**
     * ### Required permissions    * User account permission: `None` (read) / `tasks:manage` (write) 
     */
    async getAllTasks(requestParameters: GetAllTasksRequest, initOverrides?: RequestInit): Promise<Array<TaskInfo>> {
        const response = await this.getAllTasksRaw(requestParameters, initOverrides);
        return await response.value();
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    /**
     * ### Required permissions    * User account permission: `None` (read) / `tasks:manage` (write) 
     */
    async getFinishedTasks(requestParameters: GetFinishedTasksRequest, initOverrides?: RequestInit): Promise<Array<TaskInfo>> {
        const response = await this.getFinishedTasksRaw(requestParameters, initOverrides);
        return await response.value();
    }

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

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

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

    /**
     * ### Required permissions    * User account permission: `None` (read) / `tasks:manage` (write) 
     */
    async getJob(requestParameters: GetJobRequest, initOverrides?: RequestInit): Promise<Job> {
        const response = await this.getJobRaw(requestParameters, initOverrides);
        return await response.value();
    }

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

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

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

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

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

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

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

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

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

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

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

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

    /**
     * ### Required permissions    * User account permission: `None` (read) / `tasks:manage` (write) 
     */
    async getPendingTasks(requestParameters: GetPendingTasksRequest, initOverrides?: RequestInit): Promise<Array<TaskInfo>> {
        const response = await this.getPendingTasksRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `tasks:manage` 
     */
    async getPythonEnvironmentsRaw(initOverrides?: RequestInit): Promise<runtime.ApiResponse<Array<PythonEnvironment>>> {
        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/python/environments`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

    /**
     * ### Required permissions    * User account permission: `tasks:manage` 
     */
    async getPythonEnvironments(initOverrides?: RequestInit): Promise<Array<PythonEnvironment>> {
        const response = await this.getPythonEnvironmentsRaw(initOverrides);
        return await response.value();
    }

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

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

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

    /**
     * ### Required permissions    * User account permission: `tasks:view` (read) / `tasks:manage` (write) 
     */
    async getSchedule(requestParameters: GetScheduleRequest, initOverrides?: RequestInit): Promise<Schedule> {
        const response = await this.getScheduleRaw(requestParameters, initOverrides);
        return await response.value();
    }

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

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

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

    /**
     * ### Required permissions    * User account permission: `tasks:view` (read) / `tasks:manage` (write) 
     */
    async getSubtask(requestParameters: GetSubtaskRequest, initOverrides?: RequestInit): Promise<Subtask> {
        const response = await this.getSubtaskRaw(requestParameters, initOverrides);
        return await response.value();
    }

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

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

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

    /**
     * ### Required permissions    * User account permission: `None` (read) / `tasks:manage` (write) 
     */
    async getTask(requestParameters: GetTaskRequest, initOverrides?: RequestInit): Promise<TaskInfo> {
        const response = await this.getTaskRaw(requestParameters, initOverrides);
        return await response.value();
    }

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

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

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

    /**
     * ### Required permissions    * User account permission: `tasks:view` 
     */
    async getTaskLog(requestParameters: GetTaskLogRequest, initOverrides?: RequestInit): Promise<TaskLog> {
        const response = await this.getTaskLogRaw(requestParameters, initOverrides);
        return await response.value();
    }

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

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

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

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

    /**
     * ### Required permissions    * User account permission: `None` (read) / `tasks:manage` (write) 
     */
    async getTasksSummaryRaw(requestParameters: GetTasksSummaryRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<TasksSummary>> {
        const queryParameters: any = {};

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

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

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

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

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

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

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

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

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

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

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

    /**
     * ### Required permissions    * User account permission: `None` (read) / `tasks:manage` (write) 
     */
    async getTasksSummary(requestParameters: GetTasksSummaryRequest, initOverrides?: RequestInit): Promise<TasksSummary> {
        const response = await this.getTasksSummaryRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `None` (read) / `tasks:manage` (write) 
     */
    async importJobRaw(requestParameters: ImportJobOperationRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<ImportJobResponse>> {
        if (requestParameters.importJobRequest === null || requestParameters.importJobRequest === undefined) {
            throw new runtime.RequiredError('importJobRequest','Required parameter requestParameters.importJobRequest was null or undefined when calling importJob.');
        }

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

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

    /**
     * ### Required permissions    * User account permission: `None` (read) / `tasks:manage` (write) 
     */
    async importJob(requestParameters: ImportJobOperationRequest, initOverrides?: RequestInit): Promise<ImportJobResponse> {
        const response = await this.importJobRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `None` (read) / `tasks:manage` (write) 
     */
    async killAllPendingTasksRaw(initOverrides?: RequestInit): Promise<runtime.ApiResponse<void>> {
        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

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

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

        return new runtime.VoidApiResponse(response);
    }

    /**
     * ### Required permissions    * User account permission: `None` (read) / `tasks:manage` (write) 
     */
    async killAllPendingTasks(initOverrides?: RequestInit): Promise<void> {
        await this.killAllPendingTasksRaw(initOverrides);
    }

    /**
     * ### Required permissions    * User account permission: `tasks:manage` 
     */
    async killTaskRaw(requestParameters: KillTaskRequest, 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 killTask.');
        }

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

        return new runtime.VoidApiResponse(response);
    }

    /**
     * ### Required permissions    * User account permission: `tasks:manage` 
     */
    async killTask(requestParameters: KillTaskRequest, initOverrides?: RequestInit): Promise<void> {
        await this.killTaskRaw(requestParameters, initOverrides);
    }

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

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

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

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

    /**
     * ### Required permissions    * User account permission: `None` (read) / `tasks:manage` (write) 
     */
    async patchJob(requestParameters: PatchJobRequest, initOverrides?: RequestInit): Promise<Job> {
        const response = await this.patchJobRaw(requestParameters, initOverrides);
        return await response.value();
    }

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

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

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

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

    /**
     * ### Required permissions    * User account permission: `tasks:view` (read) / `tasks:manage` (write) 
     */
    async patchSchedule(requestParameters: PatchScheduleRequest, initOverrides?: RequestInit): Promise<Schedule> {
        const response = await this.patchScheduleRaw(requestParameters, initOverrides);
        return await response.value();
    }

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

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

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

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

    /**
     * ### Required permissions    * User account permission: `tasks:view` (read) / `tasks:manage` (write) 
     */
    async patchSubtask(requestParameters: PatchSubtaskRequest, initOverrides?: RequestInit): Promise<Subtask> {
        const response = await this.patchSubtaskRaw(requestParameters, initOverrides);
        return await response.value();
    }

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

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

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

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

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

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

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

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

    /**
     */
    async startJob(requestParameters: StartJobOperationRequest, initOverrides?: RequestInit): Promise<Array<TaskInfo>> {
        const response = await this.startJobRaw(requestParameters, initOverrides);
        return await response.value();
    }

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

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

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

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

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

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

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

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

    /**
     * ### Required permissions    * User account permission: `None` (read) / `tasks:manage` (write) 
     */
    async updateJob(requestParameters: UpdateJobRequest, initOverrides?: RequestInit): Promise<Job> {
        const response = await this.updateJobRaw(requestParameters, initOverrides);
        return await response.value();
    }

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

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

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

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

    /**
     * ### Required permissions    * User account permission: `tasks:view` (read) / `tasks:manage` (write) 
     */
    async updateSchedule(requestParameters: UpdateScheduleRequest, initOverrides?: RequestInit): Promise<Schedule> {
        const response = await this.updateScheduleRaw(requestParameters, initOverrides);
        return await response.value();
    }

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

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

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

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

    /**
     * ### Required permissions    * User account permission: `tasks:view` (read) / `tasks:manage` (write) 
     */
    async updateSubtask(requestParameters: UpdateSubtaskRequest, initOverrides?: RequestInit): Promise<Subtask> {
        const response = await this.updateSubtaskRaw(requestParameters, initOverrides);
        return await response.value();
    }

}