/* 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 MonitorDetectionService {
    constructor(public readonly httpRequest: BaseHttpRequest) { }
    /**
     * @returns void
     * @throws ApiError
     */
    public create(): CancelablePromise<void> {
        return this.httpRequest.request({
            method: 'GET',
            url: '/monitor/detection/create',
            errors: {
                401: `Need proper authorization, it's usually acheived by getting the right permission.`,
            },
        });
    }
    /**
     * @returns void
     * @throws ApiError
     */
    public createFromPotentialDetection(): CancelablePromise<void> {
        return this.httpRequest.request({
            method: 'GET',
            url: '/monitor/detection/createFromPotentialDetection',
            errors: {
                401: `Need proper authorization, it's usually acheived by getting the right permission.`,
            },
        });
    }
    /**
     * @returns void
     * @throws ApiError
     */
    public removePotentialDetection(): CancelablePromise<void> {
        return this.httpRequest.request({
            method: 'GET',
            url: '/monitor/detection/removePotentialDetection',
            errors: {
                401: `Need proper authorization, it's usually acheived by getting the right permission.`,
            },
        });
    }
    /**
     * @returns void
     * @throws ApiError
     */
    public updateFindingsToVulnerabilities(): CancelablePromise<void> {
        return this.httpRequest.request({
            method: 'GET',
            url: '/monitor/detection/updateFindingsToVulnerabilities',
            errors: {
                401: `Need proper authorization, it's usually acheived by getting the right permission.`,
            },
        });
    }
    /**
     * @returns void
     * @throws ApiError
     */
    public getAllAsmDetails(): CancelablePromise<void> {
        return this.httpRequest.request({
            method: 'GET',
            url: '/monitor/detection/getAllASMDetails',
            errors: {
                401: `Need proper authorization, it's usually acheived by getting the right permission.`,
            },
        });
    }
    /**
     * @returns void
     * @throws ApiError
     */
    public getAsmVulnerabilities(): CancelablePromise<void> {
        return this.httpRequest.request({
            method: 'GET',
            url: '/monitor/detection/getASMVulnerabilities',
            errors: {
                401: `Need proper authorization, it's usually acheived by getting the right permission.`,
            },
        });
    }
    /**
     * @returns void
     * @throws ApiError
     */
    public getDetectionsOverLocation(): CancelablePromise<void> {
        return this.httpRequest.request({
            method: 'GET',
            url: '/monitor/detection/getDetectionsOverLocation',
            errors: {
                401: `Need proper authorization, it's usually acheived by getting the right permission.`,
            },
        });
    }
    /**
     * @returns void
     * @throws ApiError
     */
    public getPortExposureStatistics(): CancelablePromise<void> {
        return this.httpRequest.request({
            method: 'GET',
            url: '/monitor/detection/getPortExposureStatistics',
            errors: {
                401: `Need proper authorization, it's usually acheived by getting the right permission.`,
            },
        });
    }
    /**
     * @returns void
     * @throws ApiError
     */
    public getPortExposureBySubdomain(): CancelablePromise<void> {
        return this.httpRequest.request({
            method: 'GET',
            url: '/monitor/detection/getPortExposureBySubdomain',
            errors: {
                401: `Need proper authorization, it's usually acheived by getting the right permission.`,
            },
        });
    }
    /**
     * @returns void
     * @throws ApiError
     */
    public groupDetectionsByFindings(): CancelablePromise<void> {
        return this.httpRequest.request({
            method: 'GET',
            url: '/monitor/detection/groupDetectionsByFindings',
            errors: {
                401: `Need proper authorization, it's usually acheived by getting the right permission.`,
            },
        });
    }
    /**
     * @returns void
     * @throws ApiError
     */
    public getFindingsOverTime(): CancelablePromise<void> {
        return this.httpRequest.request({
            method: 'GET',
            url: '/monitor/detection/getFindingsOverTime',
            errors: {
                401: `Need proper authorization, it's usually acheived by getting the right permission.`,
            },
        });
    }
    /**
     * @returns void
     * @throws ApiError
     */
    public getAsmDetectionsBySeverity(): CancelablePromise<void> {
        return this.httpRequest.request({
            method: 'GET',
            url: '/monitor/detection/getASMDetectionsBySeverity',
            errors: {
                401: `Need proper authorization, it's usually acheived by getting the right permission.`,
            },
        });
    }
    /**
     * @returns void
     * @throws ApiError
     */
    public remove(): CancelablePromise<void> {
        return this.httpRequest.request({
            method: 'GET',
            url: '/monitor/detection/remove',
            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/detection/update',
            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/detection/getById',
            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/detection/gatherScreenshot',
            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/detection/getMany',
            errors: {
                401: `Need proper authorization, it's usually acheived by getting the right permission.`,
            },
        });
    }
    /**
     * @returns void
     * @throws ApiError
     */
    public getManyMobileApplication(): CancelablePromise<void> {
        return this.httpRequest.request({
            method: 'GET',
            url: '/monitor/detection/getManyMobileApplication',
            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/detection/getIntel',
            errors: {
                401: `Need proper authorization, it's usually acheived by getting the right permission.`,
            },
        });
    }
    /**
     * @returns void
     * @throws ApiError
     */
    public getManySocialMedia(): CancelablePromise<void> {
        return this.httpRequest.request({
            method: 'GET',
            url: '/monitor/detection/getManySocialMedia',
            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/detection/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/detection/isReclassification',
            errors: {
                401: `Need proper authorization, it's usually acheived by getting the right permission.`,
            },
        });
    }
    /**
     * @returns void
     * @throws ApiError
     */
    public submitIntelligentClassificationResponse(data?: {
        id?: string;
        classificationResult?: Record<string, any>;
        questionResponses?: any[];
        sessionDuration?: number;
        attr?: Record<string, any>;
    }): CancelablePromise<void> {
        return this.httpRequest.request({
            method: 'POST',
            url: '/monitor/detection/submitIntelligentClassificationResponse',
            body: data,
            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/detection/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/detection/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/detection/getResponse',
            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/detection/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/detection/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/detection/deleteAttachment',
            errors: {
                401: `Need proper authorization, it's usually acheived by getting the right permission.`,
            },
        });
    }
    /**
     * @returns void
     * @throws ApiError
     */
    public updateAttr(requestBody?: {
        id?: string;
        attr?: Record<string, any>;
    }): CancelablePromise<void> {
        return this.httpRequest.request({
            method: 'POST',
            url: '/monitor/detection/updateAttr',
            body: requestBody,
            mediaType: 'application/json',
            errors: {
                401: `Need proper authorization, it's usually acheived by getting the right permission.`,
            },
        });
    }
    /**
     * @returns void
     * @throws ApiError
     */
    public getStatusWise(): CancelablePromise<void> {
        return this.httpRequest.request({
            method: 'GET',
            url: '/monitor/detection/getStatusWise',
            errors: {
                401: `Need proper authorization, it's usually acheived by getting the right permission.`,
            },
        });
    }
    /**
     * @returns void
     * @throws ApiError
     */
    public getTypeWise(): CancelablePromise<void> {
        return this.httpRequest.request({
            method: 'GET',
            url: '/monitor/detection/getTypeWise',
            errors: {
                401: `Need proper authorization, it's usually acheived by getting the right permission.`,
            },
        });
    }
    /**
     * @returns void
     * @throws ApiError
     */
    public getSeverityWise(): CancelablePromise<void> {
        return this.httpRequest.request({
            method: 'GET',
            url: '/monitor/detection/getSeverityWise',
            errors: {
                401: `Need proper authorization, it's usually acheived by getting the right permission.`,
            },
        });
    }
    /**
     * @returns void
     * @throws ApiError
     */
    public getThreatScoreWise(): CancelablePromise<void> {
        return this.httpRequest.request({
            method: 'GET',
            url: '/monitor/detection/getThreatScoreWise',
            errors: {
                401: `Need proper authorization, it's usually acheived by getting the right permission.`,
            },
        });
    }
    /**
     * @returns void
     * @throws ApiError
     */
    public getSourceWise(): CancelablePromise<void> {
        return this.httpRequest.request({
            method: 'GET',
            url: '/monitor/detection/getSourceWise',
            errors: {
                401: `Need proper authorization, it's usually acheived by getting the right permission.`,
            },
        });
    }
    /**
     * @returns void
     * @throws ApiError
     */
    public getDayWise(): CancelablePromise<void> {
        return this.httpRequest.request({
            method: 'GET',
            url: '/monitor/detection/getDayWise',
            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/detection/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/detection/removeTag',
            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/detection/import',
            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/detection/comment',
            errors: {
                401: `Need proper authorization, it's usually acheived by getting the right permission.`,
            },
        });
    }
    /**
     * @returns void
     * @throws ApiError
     */
    public getDetections(): CancelablePromise<void> {
        return this.httpRequest.request({
            method: 'GET',
            url: '/monitor/detection/getDetections',
            errors: {
                401: `Need proper authorization, it's usually acheived by getting the right permission.`,
            },
        });
    }
    /**
     * @returns void
     * @throws ApiError
     */
    public getUniqueClassification(): CancelablePromise<void> {
        return this.httpRequest.request({
            method: 'GET',
            url: '/monitor/detection/getUniqueClassification',
            errors: {
                401: `Need proper authorization, it's usually acheived by getting the right permission.`,
            },
        });
    }
    /**
     * @returns void
     * @throws ApiError
     */
    public getCurrentRisk(): CancelablePromise<void> {
        return this.httpRequest.request({
            method: 'GET',
            url: '/monitor/detection/getCurrentRisk',
            errors: {
                401: `Need proper authorization, it's usually acheived by getting the right permission.`,
            },
        });
    }
    /**
     * @returns void
     * @throws ApiError
     */
    public getImportCount(): CancelablePromise<void> {
        return this.httpRequest.request({
            method: 'GET',
            url: '/monitor/detection/getImportCount',
            errors: {
                401: `Need proper authorization, it's usually acheived by getting the right permission.`,
            },
        });
    }
    /**
     * @returns void
     * @throws ApiError
     */
    public hasCountryData(): CancelablePromise<void> {
        return this.httpRequest.request({
            method: 'GET',
            url: '/monitor/detection/hasCountryData',
            errors: {
                401: `Need proper authorization, it's usually acheived by getting the right permission.`,
            },
        });
    }
    /**
     * @returns void
     * @throws ApiError
     */
    public getDetectionsByMobileApplication(): CancelablePromise<void> {
        return this.httpRequest.request({
            method: 'GET',
            url: '/monitor/detection/getDetectionsByMobileApplication',
            errors: {
                401: `Need proper authorization, it's usually acheived by getting the right permission.`,
            },
        });
    }
    /**
     * @returns void
     * @throws ApiError
     */
    public getDetectionsBySocialMedia(): CancelablePromise<void> {
        return this.httpRequest.request({
            method: 'GET',
            url: '/monitor/detection/getDetectionsBySocialMedia',
            errors: {
                401: `Need proper authorization, it's usually acheived by getting the right permission.`,
            },
        });
    }
    /**
     * @returns void
     * @throws ApiError
     */
    public getScoreStatistics(): CancelablePromise<void> {
        return this.httpRequest.request({
            method: 'GET',
            url: '/monitor/detection/getScoreStatistics',
            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/detection/getCount',
            errors: {
                401: `Need proper authorization, it's usually acheived by getting the right permission.`,
            },
        });
    }
    /**
     * @returns void
     * @throws ApiError
     */
    public getDetectionByStatus(): CancelablePromise<void> {
        return this.httpRequest.request({
            method: 'GET',
            url: '/monitor/detection/getDetectionByStatus',
            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/detection/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/detection/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/detection/aiRemediationOverview',
            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/detection/statusUpdate',
            errors: {
                401: `Need proper authorization, it's usually acheived by getting the right permission.`,
            },
        });
    }
    /**
     * @returns void
     * @throws ApiError
     */
    public getDetectionByDomain(): CancelablePromise<void> {
        return this.httpRequest.request({
            method: 'GET',
            url: '/monitor/detection/getDetectionByDomain',
            errors: {
                401: `Need proper authorization, it's usually acheived by getting the right permission.`,
            },
        });
    }
    /**
     * @returns void
     * @throws ApiError
     */
    public getDetectionByHosting(): CancelablePromise<void> {
        return this.httpRequest.request({
            method: 'GET',
            url: '/monitor/detection/getDetectionByHosting',
            errors: {
                401: `Need proper authorization, it's usually acheived by getting the right permission.`,
            },
        });
    }
    /**
     * @returns void
     * @throws ApiError
     */
    public getDetectionCount(): CancelablePromise<void> {
        return this.httpRequest.request({
            method: 'GET',
            url: '/monitor/detection/getDetectionCount',
            errors: {
                401: `Need proper authorization, it's usually acheived by getting the right permission.`,
            },
        });
    }
    /**
     * @returns void
     * @throws ApiError
     */
    public patchDomain(): CancelablePromise<void> {
        return this.httpRequest.request({
            method: 'GET',
            url: '/monitor/detection/patch_domain',
            errors: {
                401: `Need proper authorization, it's usually acheived by getting the right permission.`,
            },
        });
    }
    /**
     * @returns void
     * @throws ApiError
     */
    public getDetectionOrg(): CancelablePromise<void> {
        return this.httpRequest.request({
            method: 'GET',
            url: '/monitor/detection/getDetectionOrg',
            errors: {
                401: `Need proper authorization, it's usually acheived by getting the right permission.`,
            },
        });
    }
    /**
     * @returns void
     * @throws ApiError
     */
    public getDetectionStatistics(): CancelablePromise<void> {
        return this.httpRequest.request({
            method: 'GET',
            url: '/monitor/detection/getDetectionStatistics',
            errors: {
                401: `Need proper authorization, it's usually acheived by getting the right permission.`,
            },
        });
    }
    /**
     * @returns void
     * @throws ApiError
     */
    public getAsmDashboardStatistics(): CancelablePromise<void> {
        return this.httpRequest.request({
            method: 'GET',
            url: '/monitor/detection/getASMDashboardStatistics',
            errors: {
                401: `Need proper authorization, it's usually acheived by getting the right permission.`,
            },
        });
    }
    /**
     * @returns void
     * @throws ApiError
     */
    public getAsmStatistics(): CancelablePromise<void> {
        return this.httpRequest.request({
            method: 'GET',
            url: '/monitor/detection/getASMStatistics',
            errors: {
                401: `Need proper authorization, it's usually acheived by getting the right permission.`,
            },
        });
    }
    /**
     * @returns void
     * @throws ApiError
     */
    public deleteAsmDetections(): CancelablePromise<void> {
        return this.httpRequest.request({
            method: 'GET',
            url: '/monitor/detection/deleteASMDetections',
            errors: {
                401: `Need proper authorization, it's usually acheived by getting the right permission.`,
            },
        });
    }
    /**
     * @returns void
     * @throws ApiError
     */
    public getBrandProtectionDetections(): CancelablePromise<void> {
        return this.httpRequest.request({
            method: 'GET',
            url: '/monitor/detection/getBrandProtectionDetections',
            errors: {
                401: `Need proper authorization, it's usually acheived by getting the right permission.`,
            },
        });
    }
    /**
     * @returns void
     * @throws ApiError
     */
    public getBrandProtectionDetectionsByCategory(): CancelablePromise<void> {
        return this.httpRequest.request({
            method: 'GET',
            url: '/monitor/detection/getBrandProtectionDetectionsByCategory',
            errors: {
                401: `Need proper authorization, it's usually acheived by getting the right permission.`,
            },
        });
    }
    /**
     * @returns void
     * @throws ApiError
     */
    public getBrandProtectionStatusByCount(): CancelablePromise<void> {
        return this.httpRequest.request({
            method: 'GET',
            url: '/monitor/detection/getBrandProtectionStatusByCount',
            errors: {
                401: `Need proper authorization, it's usually acheived by getting the right permission.`,
            },
        });
    }
    /**
     * @returns void
     * @throws ApiError
     */
    public getDashboardStats(): CancelablePromise<void> {
        return this.httpRequest.request({
            method: 'GET',
            url: '/monitor/detection/getDashboardStats',
            errors: {
                401: `Need proper authorization, it's usually acheived by getting the right permission.`,
            },
        });
    }
    /**
     * @returns void
     * @throws ApiError
     */
    public getGlobalStats(): CancelablePromise<void> {
        return this.httpRequest.request({
            method: 'GET',
            url: '/monitor/detection/getGlobalStats',
            errors: {
                401: `Need proper authorization, it's usually acheived by getting the right permission.`,
            },
        });
    }
    /**
     * @returns void
     * @throws ApiError
     */
    public getClassificationConfig(): CancelablePromise<void> {
        return this.httpRequest.request({
            method: 'GET',
            url: '/monitor/detection/getClassificationConfig',
            errors: {
                401: `Need proper authorization, it's usually acheived by getting the right permission.`,
            },
        });
    }
    /**
     * @returns void
     * @throws ApiError
     */
    public autoClassify(): CancelablePromise<void> {
        return this.httpRequest.request({
            method: 'GET',
            url: '/monitor/detection/autoClassify',
            errors: {
                401: `Need proper authorization, it's usually acheived by getting the right permission.`,
            },
        });
    }
    /**
     * @returns void
     * @throws ApiError
     */
    public canAutoClassify(): CancelablePromise<void> {
        return this.httpRequest.request({
            method: 'GET',
            url: '/monitor/detection/canAutoClassify',
            errors: {
                401: `Need proper authorization, it's usually acheived by getting the right permission.`,
            },
        });
    }
    /**
     * @returns void
     * @throws ApiError
     */
    public getAutoClassificationHistory(): CancelablePromise<void> {
        return this.httpRequest.request({
            method: 'GET',
            url: '/monitor/detection/getAutoClassificationHistory',
            errors: {
                401: `Need proper authorization, it's usually acheived by getting the right permission.`,
            },
        });
    }
    /**
     * @returns void
     * @throws ApiError
     */
    public acceptAutoClassification(): CancelablePromise<void> {
        return this.httpRequest.request({
            method: 'GET',
            url: '/monitor/detection/acceptAutoClassification',
            errors: {
                401: `Need proper authorization, it's usually acheived by getting the right permission.`,
            },
        });
    }
    /**
     * @returns void
     * @throws ApiError
     */
    public findUnclassifiedDetections(data?: Record<string, any>): CancelablePromise<void> {
        return this.httpRequest.request({
            method: 'POST',
            url: '/monitor/detection/findUnclassifiedDetections',
            body: data,
            errors: {
                401: `Need proper authorization, it's usually acheived by getting the right permission.`,
            },
        });
    }
    /**
     * @returns void
     * @throws ApiError
     */
    public executeAiPrompt(data?: { prompt?: string; useCache?: boolean }): CancelablePromise<void> {
        return this.httpRequest.request({
            method: 'POST',
            url: '/monitor/detection/executeAIPrompt',
            body: data,
            errors: {
                401: `Need proper authorization, it's usually acheived by getting the right permission.`,
            },
        });
    }
    /**
     * Get all detections with actionable_by_client status (or custom statuses)
     * and include the total audit log count per detection.
     * @returns void
     * @throws ApiError
     */
    public getDetectionsByStatusWithAuditCount(data?: {
        statuses?: string[];
        start?: number;
        end?: number;
    }): CancelablePromise<void> {
        return this.httpRequest.request({
            method: 'POST',
            url: '/monitor/detection/getDetectionsByStatusWithAuditCount',
            body: data,
            errors: {
                401: `Need proper authorization, it's usually acheived by getting the right permission.`,
            },
        });
    }
}