/* generated using openapi-typescript-codegen -- do not edit */
/* istanbul ignore file */
/* tslint:disable */
/* eslint-disable */
import type { CancelablePromise } from '../core/CancelablePromise';
import type { BaseHttpRequest } from '../core/BaseHttpRequest';
export class MonitorIncidentService {
    constructor(public readonly httpRequest: BaseHttpRequest) { }
    /**
     * @returns void
     * @throws ApiError
     */
    public insert(): CancelablePromise<void> {
        return this.httpRequest.request({
            method: 'GET',
            url: '/monitor/incident/insert',
            errors: {
                401: `Need proper authorization, it's usually acheived by getting the right permission.`,
            },
        });
    }
    /**
     * Add Multiple Incidents
     * API to add multiple incidents at once.
     * @returns void
     * @throws ApiError
     */
    public bulkInsert(): CancelablePromise<void> {
        return this.httpRequest.request({
            method: 'GET',
            url: '/monitor/incident/bulkInsert',
            errors: {
                401: `Need proper authorization, it's usually acheived by getting the right permission.`,
            },
        });
    }
    /**
     * @returns void
     * @throws ApiError
     */
    public close(): CancelablePromise<void> {
        return this.httpRequest.request({
            method: 'GET',
            url: '/monitor/incident/close',
            errors: {
                401: `Need proper authorization, it's usually acheived by getting the right permission.`,
            },
        });
    }
    /**
     * @returns void
     * @throws ApiError
     */
    public update(): CancelablePromise<void> {
        return this.httpRequest.request({
            method: 'GET',
            url: '/monitor/incident/update',
            errors: {
                401: `Need proper authorization, it's usually acheived by getting the right permission.`,
            },
        });
    }
    /**
     * @returns void
     * @throws ApiError
     */
    public comment(): CancelablePromise<void> {
        return this.httpRequest.request({
            method: 'GET',
            url: '/monitor/incident/comment',
            errors: {
                401: `Need proper authorization, it's usually acheived by getting the right permission.`,
            },
        });
    }
    /**
     * @returns void
     * @throws ApiError
     */
    public import(): CancelablePromise<void> {
        return this.httpRequest.request({
            method: 'GET',
            url: '/monitor/incident/import',
            errors: {
                401: `Need proper authorization, it's usually acheived by getting the right permission.`,
            },
        });
    }
    /**
     * @returns void
     * @throws ApiError
     */
    public getById(): CancelablePromise<void> {
        return this.httpRequest.request({
            method: 'GET',
            url: '/monitor/incident/getById',
            errors: {
                401: `Need proper authorization, it's usually acheived by getting the right permission.`,
            },
        });
    }
    /**
     * @returns void
     * @throws ApiError
     */
    public getByUrl(): CancelablePromise<void> {
        return this.httpRequest.request({
            method: 'GET',
            url: '/monitor/incident/getByURL',
            errors: {
                401: `Need proper authorization, it's usually acheived by getting the right permission.`,
            },
        });
    }
    /**
     * @returns void
     * @throws ApiError
     */
    public getIncidentOrg(): CancelablePromise<void> {
        return this.httpRequest.request({
            method: 'GET',
            url: '/monitor/incident/getIncidentOrg',
            errors: {
                401: `Need proper authorization, it's usually acheived by getting the right permission.`,
            },
        });
    }
    /**
     * @returns void
     * @throws ApiError
     */
    public getIntel(): CancelablePromise<void> {
        return this.httpRequest.request({
            method: 'GET',
            url: '/monitor/incident/getIntel',
            errors: {
                401: `Need proper authorization, it's usually acheived by getting the right permission.`,
            },
        });
    }
    /**
     * @returns void
     * @throws ApiError
     */
    public getMany(): CancelablePromise<void> {
        return this.httpRequest.request({
            method: 'GET',
            url: '/monitor/incident/getMany',
            errors: {
                401: `Need proper authorization, it's usually acheived by getting the right permission.`,
            },
        });
    }
    /**
     * @returns void
     * @throws ApiError
     */
    public addTag(): CancelablePromise<void> {
        return this.httpRequest.request({
            method: 'GET',
            url: '/monitor/incident/addTag',
            errors: {
                401: `Need proper authorization, it's usually acheived by getting the right permission.`,
            },
        });
    }
    /**
     * @returns void
     * @throws ApiError
     */
    public removeTag(): CancelablePromise<void> {
        return this.httpRequest.request({
            method: 'GET',
            url: '/monitor/incident/removeTag',
            errors: {
                401: `Need proper authorization, it's usually acheived by getting the right permission.`,
            },
        });
    }
    /**
     * @returns void
     * @throws ApiError
     */
    public initiateTakeDown(): CancelablePromise<void> {
        return this.httpRequest.request({
            method: 'GET',
            url: '/monitor/incident/initiateTakeDown',
            errors: {
                401: `Need proper authorization, it's usually acheived by getting the right permission.`,
            },
        });
    }
    /**
     * @returns void
     * @throws ApiError
     */
    public statusUpdate(): CancelablePromise<void> {
        return this.httpRequest.request({
            method: 'GET',
            url: '/monitor/incident/statusUpdate',
            errors: {
                401: `Need proper authorization, it's usually acheived by getting the right permission.`,
            },
        });
    }
    /**
     * @returns void
     * @throws ApiError
     */
    public descriptionUpdate(): CancelablePromise<void> {
        return this.httpRequest.request({
            method: 'GET',
            url: '/monitor/incident/descriptionUpdate',
            errors: {
                401: `Need proper authorization, it's usually acheived by getting the right permission.`,
            },
        });
    }
    /**
     * @returns void
     * @throws ApiError
     */
    public attachFile(): CancelablePromise<void> {
        return this.httpRequest.request({
            method: 'GET',
            url: '/monitor/incident/attachFile',
            errors: {
                401: `Need proper authorization, it's usually acheived by getting the right permission.`,
            },
        });
    }
    /**
     * @returns void
     * @throws ApiError
     */
    public deleteAttachment(): CancelablePromise<void> {
        return this.httpRequest.request({
            method: 'GET',
            url: '/monitor/incident/deleteAttachment',
            errors: {
                401: `Need proper authorization, it's usually acheived by getting the right permission.`,
            },
        });
    }
    /**
     * @returns void
     * @throws ApiError
     */
    public updateAttr(): CancelablePromise<void> {
        return this.httpRequest.request({
            method: 'GET',
            url: '/monitor/incident/updateAttr',
            errors: {
                401: `Need proper authorization, it's usually acheived by getting the right permission.`,
            },
        });
    }
    /**
     * @returns void
     * @throws ApiError
     */
    public updateStatusReason(): CancelablePromise<void> {
        return this.httpRequest.request({
            method: 'GET',
            url: '/monitor/incident/updateStatusReason',
            errors: {
                401: `Need proper authorization, it's usually acheived by getting the right permission.`,
            },
        });
    }
    /**
     * @returns void
     * @throws ApiError
     */
    public assigneeUpdate(): CancelablePromise<void> {
        return this.httpRequest.request({
            method: 'GET',
            url: '/monitor/incident/assigneeUpdate',
            errors: {
                401: `Need proper authorization, it's usually acheived by getting the right permission.`,
            },
        });
    }
    /**
     * @returns void
     * @throws ApiError
     */
    public gatherScreenshot(): CancelablePromise<void> {
        return this.httpRequest.request({
            method: 'GET',
            url: '/monitor/incident/gatherScreenshot',
            errors: {
                401: `Need proper authorization, it's usually acheived by getting the right permission.`,
            },
        });
    }
    /**
     * @returns void
     * @throws ApiError
     */
    public getUsersForAssignee(): CancelablePromise<void> {
        return this.httpRequest.request({
            method: 'GET',
            url: '/monitor/incident/getUsersForAssignee',
            errors: {
                401: `Need proper authorization, it's usually acheived by getting the right permission.`,
            },
        });
    }
    /**
     * @returns void
     * @throws ApiError
     */
    public canClassify(): CancelablePromise<void> {
        return this.httpRequest.request({
            method: 'GET',
            url: '/monitor/incident/canClassify',
            errors: {
                401: `Need proper authorization, it's usually acheived by getting the right permission.`,
            },
        });
    }
    /**
     * @returns void
     * @throws ApiError
     */
    public isReclassification(): CancelablePromise<void> {
        return this.httpRequest.request({
            method: 'GET',
            url: '/monitor/incident/isReclassification',
            errors: {
                401: `Need proper authorization, it's usually acheived by getting the right permission.`,
            },
        });
    }
    /**
     * @returns void
     * @throws ApiError
     */
    public submitIntelligentClassificationResponse(): CancelablePromise<void> {
        return this.httpRequest.request({
            method: 'GET',
            url: '/monitor/incident/submitIntelligentClassificationResponse',
            errors: {
                401: `Need proper authorization, it's usually acheived by getting the right permission.`,
            },
        });
    }
    /**
     * @returns void
     * @throws ApiError
     */
    public getDetailedClassificationResponse(): CancelablePromise<void> {
        return this.httpRequest.request({
            method: 'GET',
            url: '/monitor/incident/getDetailedClassificationResponse',
            errors: {
                401: `Need proper authorization, it's usually acheived by getting the right permission.`,
            },
        });
    }
    /**
     * @returns void
     * @throws ApiError
     */
    public getClassificationSummary(): CancelablePromise<void> {
        return this.httpRequest.request({
            method: 'GET',
            url: '/monitor/incident/getClassificationSummary',
            errors: {
                401: `Need proper authorization, it's usually acheived by getting the right permission.`,
            },
        });
    }
    /**
     * @returns void
     * @throws ApiError
     */
    public getResponse(): CancelablePromise<void> {
        return this.httpRequest.request({
            method: 'GET',
            url: '/monitor/incident/getResponse',
            errors: {
                401: `Need proper authorization, it's usually acheived by getting the right permission.`,
            },
        });
    }
    /**
     * @returns void
     * @throws ApiError
     */
    public getIncidents(): CancelablePromise<void> {
        return this.httpRequest.request({
            method: 'GET',
            url: '/monitor/incident/getIncidents',
            errors: {
                401: `Need proper authorization, it's usually acheived by getting the right permission.`,
            },
        });
    }
    /**
     * @returns void
     * @throws ApiError
     */
    public sendCorrespondance(): CancelablePromise<void> {
        return this.httpRequest.request({
            method: 'GET',
            url: '/monitor/incident/sendCorrespondance',
            errors: {
                401: `Need proper authorization, it's usually acheived by getting the right permission.`,
            },
        });
    }
    /**
     * @returns void
     * @throws ApiError
     */
    public aiOverview(): CancelablePromise<void> {
        return this.httpRequest.request({
            method: 'GET',
            url: '/monitor/incident/aiOverview',
            errors: {
                401: `Need proper authorization, it's usually acheived by getting the right permission.`,
            },
        });
    }
    /**
     * @returns void
     * @throws ApiError
     */
    public aiImpactOverview(): CancelablePromise<void> {
        return this.httpRequest.request({
            method: 'GET',
            url: '/monitor/incident/aiImpactOverview',
            errors: {
                401: `Need proper authorization, it's usually acheived by getting the right permission.`,
            },
        });
    }
    /**
     * @returns void
     * @throws ApiError
     */
    public aiRemediationOverview(): CancelablePromise<void> {
        return this.httpRequest.request({
            method: 'GET',
            url: '/monitor/incident/aiRemediationOverview',
            errors: {
                401: `Need proper authorization, it's usually acheived by getting the right permission.`,
            },
        });
    }
    /**
     * @returns void
     * @throws ApiError
     */
    public addAuditLog(): CancelablePromise<void> {
        return this.httpRequest.request({
            method: 'GET',
            url: '/monitor/incident/addAuditLog',
            errors: {
                401: `Need proper authorization, it's usually acheived by getting the right permission.`,
            },
        });
    }
    /**
     * @returns void
     * @throws ApiError
     */
    public getCount(): CancelablePromise<void> {
        return this.httpRequest.request({
            method: 'GET',
            url: '/monitor/incident/getCount',
            errors: {
                401: `Need proper authorization, it's usually acheived by getting the right permission.`,
            },
        });
    }
    /**
     * @returns void
     * @throws ApiError
     */
    public getAvgMitigationTime(): CancelablePromise<void> {
        return this.httpRequest.request({
            method: 'GET',
            url: '/monitor/incident/getAvgMitigationTime',
            errors: {
                401: `Need proper authorization, it's usually acheived by getting the right permission.`,
            },
        });
    }
    /**
     * @returns void
     * @throws ApiError
     */
    public getRevenueSaved(): CancelablePromise<void> {
        return this.httpRequest.request({
            method: 'GET',
            url: '/monitor/incident/getRevenueSaved',
            errors: {
                401: `Need proper authorization, it's usually acheived by getting the right permission.`,
            },
        });
    }
    /**
     * @returns void
     * @throws ApiError
     */
    public getUniqueStatus(): CancelablePromise<void> {
        return this.httpRequest.request({
            method: 'GET',
            url: '/monitor/incident/getUniqueStatus',
            errors: {
                401: `Need proper authorization, it's usually acheived by getting the right permission.`,
            },
        });
    }
    /**
     * @returns void
     * @throws ApiError
     */
    public getSocGenerator(): CancelablePromise<void> {
        return this.httpRequest.request({
            method: 'GET',
            url: '/monitor/incident/getSocGenerator',
            errors: {
                401: `Need proper authorization, it's usually acheived by getting the right permission.`,
            },
        });
    }
    /**
     * @returns void
     * @throws ApiError
     */
    public getMedianTimeTaken(): CancelablePromise<void> {
        return this.httpRequest.request({
            method: 'GET',
            url: '/monitor/incident/getMedianTimeTaken',
            errors: {
                401: `Need proper authorization, it's usually acheived by getting the right permission.`,
            },
        });
    }
    /**
     * @returns void
     * @throws ApiError
     */
    public getAvgTimeTaken(): CancelablePromise<void> {
        return this.httpRequest.request({
            method: 'GET',
            url: '/monitor/incident/getAvgTimeTaken',
            errors: {
                401: `Need proper authorization, it's usually acheived by getting the right permission.`,
            },
        });
    }
    /**
     * @returns void
     * @throws ApiError
     */
    public getBrandProtectionIncidents(): CancelablePromise<void> {
        return this.httpRequest.request({
            method: 'GET',
            url: '/monitor/incident/getBrandProtectionIncidents',
            errors: {
                401: `Need proper authorization, it's usually acheived by getting the right permission.`,
            },
        });
    }
    /**
     * @returns void
     * @throws ApiError
     */
    public getBrandProtectionIncidentsByStatus(): CancelablePromise<void> {
        return this.httpRequest.request({
            method: 'GET',
            url: '/monitor/incident/getBrandProtectionIncidentsByStatus',
            errors: {
                401: `Need proper authorization, it's usually acheived by getting the right permission.`,
            },
        });
    }
    /**
     * Get all incidents with actionable_by_client status (or custom statuses)
     * and include the total audit log count per incident.
     * @returns void
     * @throws ApiError
     */
    public getIncidentsByStatusWithAuditCount(data?: {
        statuses?: string[];
        start?: number;
        end?: number;
    }): CancelablePromise<void> {
        return this.httpRequest.request({
            method: 'POST',
            url: '/monitor/incident/getIncidentsByStatusWithAuditCount',
            body: data,
            errors: {
                401: `Need proper authorization, it's usually acheived by getting the right permission.`,
            },
        });
    }
}