diff --git a/.generator/schemas/v2/openapi.yaml b/.generator/schemas/v2/openapi.yaml index cb3f6062e016..21b4b1eb3c68 100644 --- a/.generator/schemas/v2/openapi.yaml +++ b/.generator/schemas/v2/openapi.yaml @@ -433,6 +433,13 @@ components: required: true schema: type: string + HistoricalSignalID: + description: The ID of the historical signal. + in: path + name: histsignal_id + required: true + schema: + type: string IncidentAttachmentFilterQueryParameter: description: Specifies which types of attachments are included in the response. explode: false @@ -745,6 +752,58 @@ components: required: true schema: type: string + QueryFilterFrom: + description: The minimum timestamp for requested security signals. + example: '2019-01-02T09:42:36.320Z' + in: query + name: filter[from] + required: false + schema: + format: date-time + type: string + QueryFilterSearch: + description: The search query for security signals. + example: security:attack status:high + in: query + name: filter[query] + required: false + schema: + type: string + QueryFilterTo: + description: The maximum timestamp for requested security signals. + example: '2019-01-03T09:42:36.320Z' + in: query + name: filter[to] + required: false + schema: + format: date-time + type: string + QueryPageCursor: + description: A list of results using the cursor provided in the previous query. + example: eyJzdGFydEF0IjoiQVFBQUFYS2tMS3pPbm40NGV3QUFBQUJCV0V0clRFdDZVbG8zY3pCRmNsbHJiVmxDWlEifQ== + in: query + name: page[cursor] + required: false + schema: + type: string + QueryPageLimit: + description: The maximum number of security signals in the response. + example: 25 + in: query + name: page[limit] + required: false + schema: + default: 10 + format: int32 + maximum: 1000 + type: integer + QuerySort: + description: The order of the security signals in results. + in: query + name: sort + required: false + schema: + $ref: '#/components/schemas/SecurityMonitoringSignalsSort' RelationInclude: description: Include relationship data. explode: true @@ -65338,52 +65397,12 @@ paths: security signals.' operationId: ListSecurityMonitoringSignals parameters: - - description: The search query for security signals. - example: security:attack status:high - in: query - name: filter[query] - required: false - schema: - type: string - - description: The minimum timestamp for requested security signals. - example: '2019-01-02T09:42:36.320Z' - in: query - name: filter[from] - required: false - schema: - format: date-time - type: string - - description: The maximum timestamp for requested security signals. - example: '2019-01-03T09:42:36.320Z' - in: query - name: filter[to] - required: false - schema: - format: date-time - type: string - - description: The order of the security signals in results. - in: query - name: sort - required: false - schema: - $ref: '#/components/schemas/SecurityMonitoringSignalsSort' - - description: A list of results using the cursor provided in the previous query. - example: eyJzdGFydEF0IjoiQVFBQUFYS2tMS3pPbm40NGV3QUFBQUJCV0V0clRFdDZVbG8zY3pCRmNsbHJiVmxDWlEifQ== - in: query - name: page[cursor] - required: false - schema: - type: string - - description: The maximum number of security signals in the response. - example: 25 - in: query - name: page[limit] - required: false - schema: - default: 10 - format: int32 - maximum: 1000 - type: integer + - $ref: '#/components/parameters/QueryFilterSearch' + - $ref: '#/components/parameters/QueryFilterFrom' + - $ref: '#/components/parameters/QueryFilterTo' + - $ref: '#/components/parameters/QuerySort' + - $ref: '#/components/parameters/QueryPageCursor' + - $ref: '#/components/parameters/QueryPageLimit' responses: '200': content: @@ -66664,6 +66683,123 @@ paths: permissions: - incident_settings_write x-unstable: '**Note**: This endpoint is deprecated.' + /api/v2/siem-historical-detections/histsignals: + get: + description: List hist signals. + operationId: ListSecurityMonitoringHistsignals + parameters: + - $ref: '#/components/parameters/QueryFilterSearch' + - $ref: '#/components/parameters/QueryFilterFrom' + - $ref: '#/components/parameters/QueryFilterTo' + - $ref: '#/components/parameters/QuerySort' + - $ref: '#/components/parameters/QueryPageCursor' + - $ref: '#/components/parameters/QueryPageLimit' + responses: + '200': + content: + application/json: + schema: + $ref: '#/components/schemas/SecurityMonitoringSignalsListResponse' + description: OK + '400': + $ref: '#/components/responses/BadRequestResponse' + '403': + $ref: '#/components/responses/NotAuthorizedResponse' + '404': + $ref: '#/components/responses/NotFoundResponse' + '429': + $ref: '#/components/responses/TooManyRequestsResponse' + security: + - apiKeyAuth: [] + appKeyAuth: [] + - AuthZ: + - security_monitoring_signals_read + summary: List hist signals + tags: + - Security Monitoring + x-permission: + operator: OR + permissions: + - security_monitoring_signals_read + x-unstable: '**Note**: This endpoint is in beta and may be subject to changes. + + Please check the documentation regularly for updates.' + /api/v2/siem-historical-detections/histsignals/search: + get: + description: Search hist signals. + operationId: SearchSecurityMonitoringHistsignals + requestBody: + content: + application/json: + schema: + $ref: '#/components/schemas/SecurityMonitoringSignalListRequest' + required: false + responses: + '200': + content: + application/json: + schema: + $ref: '#/components/schemas/SecurityMonitoringSignalsListResponse' + description: OK + '400': + $ref: '#/components/responses/BadRequestResponse' + '403': + $ref: '#/components/responses/NotAuthorizedResponse' + '404': + $ref: '#/components/responses/NotFoundResponse' + '429': + $ref: '#/components/responses/TooManyRequestsResponse' + security: + - apiKeyAuth: [] + appKeyAuth: [] + - AuthZ: + - security_monitoring_signals_read + summary: Search hist signals + tags: + - Security Monitoring + x-permission: + operator: OR + permissions: + - security_monitoring_signals_read + x-unstable: '**Note**: This endpoint is in beta and may be subject to changes. + + Please check the documentation regularly for updates.' + /api/v2/siem-historical-detections/histsignals/{histsignal_id}: + get: + description: Get a hist signal's details. + operationId: GetSecurityMonitoringHistsignal + parameters: + - $ref: '#/components/parameters/HistoricalSignalID' + responses: + '200': + content: + application/json: + schema: + $ref: '#/components/schemas/SecurityMonitoringSignalResponse' + description: OK + '400': + $ref: '#/components/responses/BadRequestResponse' + '403': + $ref: '#/components/responses/NotAuthorizedResponse' + '404': + $ref: '#/components/responses/NotFoundResponse' + '429': + $ref: '#/components/responses/TooManyRequestsResponse' + security: + - apiKeyAuth: [] + appKeyAuth: [] + - AuthZ: + - security_monitoring_signals_read + summary: Get a hist signal's details + tags: + - Security Monitoring + x-permission: + operator: OR + permissions: + - security_monitoring_signals_read + x-unstable: '**Note**: This endpoint is in beta and may be subject to changes. + + Please check the documentation regularly for updates.' /api/v2/siem-historical-detections/jobs: get: description: List historical jobs. @@ -66885,6 +67021,48 @@ paths: - security_monitoring_rules_write x-unstable: '**Note**: This endpoint is in beta and may be subject to changes. + Please check the documentation regularly for updates.' + /api/v2/siem-historical-detections/jobs/{job_id}/histsignals: + get: + description: Get a job's hist signals. + operationId: GetSecurityMonitoringHistsignalsByJobId + parameters: + - $ref: '#/components/parameters/HistoricalJobID' + - $ref: '#/components/parameters/QueryFilterSearch' + - $ref: '#/components/parameters/QueryFilterFrom' + - $ref: '#/components/parameters/QueryFilterTo' + - $ref: '#/components/parameters/QuerySort' + - $ref: '#/components/parameters/QueryPageCursor' + - $ref: '#/components/parameters/QueryPageLimit' + responses: + '200': + content: + application/json: + schema: + $ref: '#/components/schemas/SecurityMonitoringSignalsListResponse' + description: OK + '400': + $ref: '#/components/responses/BadRequestResponse' + '403': + $ref: '#/components/responses/NotAuthorizedResponse' + '404': + $ref: '#/components/responses/NotFoundResponse' + '429': + $ref: '#/components/responses/TooManyRequestsResponse' + security: + - apiKeyAuth: [] + appKeyAuth: [] + - AuthZ: + - security_monitoring_signals_read + summary: Get a job's hist signals + tags: + - Security Monitoring + x-permission: + operator: OR + permissions: + - security_monitoring_signals_read + x-unstable: '**Note**: This endpoint is in beta and may be subject to changes. + Please check the documentation regularly for updates.' /api/v2/slo/report: post: diff --git a/examples/v2/security-monitoring/GetSecurityMonitoringHistsignal.ts b/examples/v2/security-monitoring/GetSecurityMonitoringHistsignal.ts new file mode 100644 index 000000000000..b966f9782558 --- /dev/null +++ b/examples/v2/security-monitoring/GetSecurityMonitoringHistsignal.ts @@ -0,0 +1,22 @@ +/** + * Get a hist signal's details returns "OK" response + */ + +import { client, v2 } from "@datadog/datadog-api-client"; + +const configuration = client.createConfiguration(); +configuration.unstableOperations["v2.getSecurityMonitoringHistsignal"] = true; +const apiInstance = new v2.SecurityMonitoringApi(configuration); + +const params: v2.SecurityMonitoringApiGetSecurityMonitoringHistsignalRequest = { + histsignalId: "histsignal_id", +}; + +apiInstance + .getSecurityMonitoringHistsignal(params) + .then((data: v2.SecurityMonitoringSignalResponse) => { + console.log( + "API called successfully. Returned data: " + JSON.stringify(data) + ); + }) + .catch((error: any) => console.error(error)); diff --git a/examples/v2/security-monitoring/GetSecurityMonitoringHistsignalsByJobId.ts b/examples/v2/security-monitoring/GetSecurityMonitoringHistsignalsByJobId.ts new file mode 100644 index 000000000000..de7957072ada --- /dev/null +++ b/examples/v2/security-monitoring/GetSecurityMonitoringHistsignalsByJobId.ts @@ -0,0 +1,24 @@ +/** + * Get a job's hist signals returns "OK" response + */ + +import { client, v2 } from "@datadog/datadog-api-client"; + +const configuration = client.createConfiguration(); +configuration.unstableOperations["v2.getSecurityMonitoringHistsignalsByJobId"] = + true; +const apiInstance = new v2.SecurityMonitoringApi(configuration); + +const params: v2.SecurityMonitoringApiGetSecurityMonitoringHistsignalsByJobIdRequest = + { + jobId: "job_id", + }; + +apiInstance + .getSecurityMonitoringHistsignalsByJobId(params) + .then((data: v2.SecurityMonitoringSignalsListResponse) => { + console.log( + "API called successfully. Returned data: " + JSON.stringify(data) + ); + }) + .catch((error: any) => console.error(error)); diff --git a/examples/v2/security-monitoring/ListSecurityMonitoringHistsignals.ts b/examples/v2/security-monitoring/ListSecurityMonitoringHistsignals.ts new file mode 100644 index 000000000000..681b3142982e --- /dev/null +++ b/examples/v2/security-monitoring/ListSecurityMonitoringHistsignals.ts @@ -0,0 +1,18 @@ +/** + * List hist signals returns "OK" response + */ + +import { client, v2 } from "@datadog/datadog-api-client"; + +const configuration = client.createConfiguration(); +configuration.unstableOperations["v2.listSecurityMonitoringHistsignals"] = true; +const apiInstance = new v2.SecurityMonitoringApi(configuration); + +apiInstance + .listSecurityMonitoringHistsignals() + .then((data: v2.SecurityMonitoringSignalsListResponse) => { + console.log( + "API called successfully. Returned data: " + JSON.stringify(data) + ); + }) + .catch((error: any) => console.error(error)); diff --git a/examples/v2/security-monitoring/SearchSecurityMonitoringHistsignals.ts b/examples/v2/security-monitoring/SearchSecurityMonitoringHistsignals.ts new file mode 100644 index 000000000000..aba78d1d8be3 --- /dev/null +++ b/examples/v2/security-monitoring/SearchSecurityMonitoringHistsignals.ts @@ -0,0 +1,36 @@ +/** + * Search hist signals returns "OK" response + */ + +import { client, v2 } from "@datadog/datadog-api-client"; + +const configuration = client.createConfiguration(); +configuration.unstableOperations["v2.searchSecurityMonitoringHistsignals"] = + true; +const apiInstance = new v2.SecurityMonitoringApi(configuration); + +const params: v2.SecurityMonitoringApiSearchSecurityMonitoringHistsignalsRequest = + { + body: { + filter: { + from: new Date(2019, 1, 2, 9, 42, 36, 320000), + query: "security:attack status:high", + to: new Date(2019, 1, 3, 9, 42, 36, 320000), + }, + page: { + cursor: + "eyJzdGFydEF0IjoiQVFBQUFYS2tMS3pPbm40NGV3QUFBQUJCV0V0clRFdDZVbG8zY3pCRmNsbHJiVmxDWlEifQ==", + limit: 25, + }, + sort: "timestamp", + }, + }; + +apiInstance + .searchSecurityMonitoringHistsignals(params) + .then((data: v2.SecurityMonitoringSignalsListResponse) => { + console.log( + "API called successfully. Returned data: " + JSON.stringify(data) + ); + }) + .catch((error: any) => console.error(error)); diff --git a/features/support/scenarios_model_mapping.ts b/features/support/scenarios_model_mapping.ts index 8aec01ebe814..7ce3496cb60b 100644 --- a/features/support/scenarios_model_mapping.ts +++ b/features/support/scenarios_model_mapping.ts @@ -4098,6 +4098,47 @@ export const ScenariosModelMappings: {[key: string]: {[key: string]: any}} = { }, "operationResponseType": "SecurityMonitoringSignalTriageUpdateResponse", }, + "v2.ListSecurityMonitoringHistsignals": { + "filterQuery": { + "type": "string", + "format": "", + }, + "filterFrom": { + "type": "Date", + "format": "date-time", + }, + "filterTo": { + "type": "Date", + "format": "date-time", + }, + "sort": { + "type": "SecurityMonitoringSignalsSort", + "format": "", + }, + "pageCursor": { + "type": "string", + "format": "", + }, + "pageLimit": { + "type": "number", + "format": "int32", + }, + "operationResponseType": "SecurityMonitoringSignalsListResponse", + }, + "v2.SearchSecurityMonitoringHistsignals": { + "body": { + "type": "SecurityMonitoringSignalListRequest", + "format": "", + }, + "operationResponseType": "SecurityMonitoringSignalsListResponse", + }, + "v2.GetSecurityMonitoringHistsignal": { + "histsignalId": { + "type": "string", + "format": "", + }, + "operationResponseType": "SecurityMonitoringSignalResponse", + }, "v2.ListHistoricalJobs": { "pageSize": { "type": "number", @@ -4152,6 +4193,37 @@ export const ScenariosModelMappings: {[key: string]: {[key: string]: any}} = { }, "operationResponseType": "{}", }, + "v2.GetSecurityMonitoringHistsignalsByJobId": { + "jobId": { + "type": "string", + "format": "", + }, + "filterQuery": { + "type": "string", + "format": "", + }, + "filterFrom": { + "type": "Date", + "format": "date-time", + }, + "filterTo": { + "type": "Date", + "format": "date-time", + }, + "sort": { + "type": "SecurityMonitoringSignalsSort", + "format": "", + }, + "pageCursor": { + "type": "string", + "format": "", + }, + "pageLimit": { + "type": "number", + "format": "int32", + }, + "operationResponseType": "SecurityMonitoringSignalsListResponse", + }, "v2.ListContainerImages": { "filterTags": { "type": "string", diff --git a/features/v2/security_monitoring.feature b/features/v2/security_monitoring.feature index 89424290ce17..c06b0abac08b 100644 --- a/features/v2/security_monitoring.feature +++ b/features/v2/security_monitoring.feature @@ -591,6 +591,30 @@ Feature: Security Monitoring Then the response status is 200 OK And the response "data.attributes.evaluation" is equal to "pass" + @generated @skip @team:DataDog/k9-cloud-security-platform + Scenario: Get a hist signal's details returns "Bad Request" response + Given operation "GetSecurityMonitoringHistsignal" enabled + And new "GetSecurityMonitoringHistsignal" request + And request contains "histsignal_id" parameter from "REPLACE.ME" + When the request is sent + Then the response status is 400 Bad Request + + @generated @skip @team:DataDog/k9-cloud-security-platform + Scenario: Get a hist signal's details returns "Not Found" response + Given operation "GetSecurityMonitoringHistsignal" enabled + And new "GetSecurityMonitoringHistsignal" request + And request contains "histsignal_id" parameter from "REPLACE.ME" + When the request is sent + Then the response status is 404 Not Found + + @generated @skip @team:DataDog/k9-cloud-security-platform + Scenario: Get a hist signal's details returns "OK" response + Given operation "GetSecurityMonitoringHistsignal" enabled + And new "GetSecurityMonitoringHistsignal" request + And request contains "histsignal_id" parameter from "REPLACE.ME" + When the request is sent + Then the response status is 200 OK + @team:DataDog/k9-cloud-security-platform Scenario: Get a job's details returns "Bad Request" response Given operation "GetHistoricalJob" enabled @@ -617,6 +641,30 @@ Feature: Security Monitoring When the request is sent Then the response status is 200 OK + @generated @skip @team:DataDog/k9-cloud-security-platform + Scenario: Get a job's hist signals returns "Bad Request" response + Given operation "GetSecurityMonitoringHistsignalsByJobId" enabled + And new "GetSecurityMonitoringHistsignalsByJobId" request + And request contains "job_id" parameter from "REPLACE.ME" + When the request is sent + Then the response status is 400 Bad Request + + @generated @skip @team:DataDog/k9-cloud-security-platform + Scenario: Get a job's hist signals returns "Not Found" response + Given operation "GetSecurityMonitoringHistsignalsByJobId" enabled + And new "GetSecurityMonitoringHistsignalsByJobId" request + And request contains "job_id" parameter from "REPLACE.ME" + When the request is sent + Then the response status is 404 Not Found + + @generated @skip @team:DataDog/k9-cloud-security-platform + Scenario: Get a job's hist signals returns "OK" response + Given operation "GetSecurityMonitoringHistsignalsByJobId" enabled + And new "GetSecurityMonitoringHistsignalsByJobId" request + And request contains "job_id" parameter from "REPLACE.ME" + When the request is sent + Then the response status is 200 OK + @generated @skip @team:DataDog/k9-cloud-security-platform Scenario: Get a list of security signals returns "Bad Request" response Given new "SearchSecurityMonitoringSignals" request @@ -942,6 +990,27 @@ Feature: Security Monitoring When the request is sent Then the response status is 200 OK + @generated @skip @team:DataDog/k9-cloud-security-platform + Scenario: List hist signals returns "Bad Request" response + Given operation "ListSecurityMonitoringHistsignals" enabled + And new "ListSecurityMonitoringHistsignals" request + When the request is sent + Then the response status is 400 Bad Request + + @generated @skip @team:DataDog/k9-cloud-security-platform + Scenario: List hist signals returns "Not Found" response + Given operation "ListSecurityMonitoringHistsignals" enabled + And new "ListSecurityMonitoringHistsignals" request + When the request is sent + Then the response status is 404 Not Found + + @generated @skip @team:DataDog/k9-cloud-security-platform + Scenario: List hist signals returns "OK" response + Given operation "ListSecurityMonitoringHistsignals" enabled + And new "ListSecurityMonitoringHistsignals" request + When the request is sent + Then the response status is 200 OK + @generated @skip @team:DataDog/k9-cloud-security-platform Scenario: List historical jobs returns "Bad Request" response Given operation "ListHistoricalJobs" enabled @@ -1186,6 +1255,30 @@ Feature: Security Monitoring When the request is sent Then the response status is 201 Status created + @generated @skip @team:DataDog/k9-cloud-security-platform + Scenario: Search hist signals returns "Bad Request" response + Given operation "SearchSecurityMonitoringHistsignals" enabled + And new "SearchSecurityMonitoringHistsignals" request + And body with value {"filter": {"from": "2019-01-02T09:42:36.320Z", "query": "security:attack status:high", "to": "2019-01-03T09:42:36.320Z"}, "page": {"cursor": "eyJzdGFydEF0IjoiQVFBQUFYS2tMS3pPbm40NGV3QUFBQUJCV0V0clRFdDZVbG8zY3pCRmNsbHJiVmxDWlEifQ==", "limit": 25}, "sort": "timestamp"} + When the request is sent + Then the response status is 400 Bad Request + + @generated @skip @team:DataDog/k9-cloud-security-platform + Scenario: Search hist signals returns "Not Found" response + Given operation "SearchSecurityMonitoringHistsignals" enabled + And new "SearchSecurityMonitoringHistsignals" request + And body with value {"filter": {"from": "2019-01-02T09:42:36.320Z", "query": "security:attack status:high", "to": "2019-01-03T09:42:36.320Z"}, "page": {"cursor": "eyJzdGFydEF0IjoiQVFBQUFYS2tMS3pPbm40NGV3QUFBQUJCV0V0clRFdDZVbG8zY3pCRmNsbHJiVmxDWlEifQ==", "limit": 25}, "sort": "timestamp"} + When the request is sent + Then the response status is 404 Not Found + + @generated @skip @team:DataDog/k9-cloud-security-platform + Scenario: Search hist signals returns "OK" response + Given operation "SearchSecurityMonitoringHistsignals" enabled + And new "SearchSecurityMonitoringHistsignals" request + And body with value {"filter": {"from": "2019-01-02T09:42:36.320Z", "query": "security:attack status:high", "to": "2019-01-03T09:42:36.320Z"}, "page": {"cursor": "eyJzdGFydEF0IjoiQVFBQUFYS2tMS3pPbm40NGV3QUFBQUJCV0V0clRFdDZVbG8zY3pCRmNsbHJiVmxDWlEifQ==", "limit": 25}, "sort": "timestamp"} + When the request is sent + Then the response status is 200 OK + @skip @team:DataDog/k9-cloud-security-platform Scenario: Test a rule returns "Bad Request" response Given new "TestSecurityMonitoringRule" request diff --git a/features/v2/undo.json b/features/v2/undo.json index 3ae6306bca4a..b3731714ef65 100644 --- a/features/v2/undo.json +++ b/features/v2/undo.json @@ -3362,6 +3362,24 @@ "type": "idempotent" } }, + "ListSecurityMonitoringHistsignals": { + "tag": "Security Monitoring", + "undo": { + "type": "safe" + } + }, + "SearchSecurityMonitoringHistsignals": { + "tag": "Security Monitoring", + "undo": { + "type": "safe" + } + }, + "GetSecurityMonitoringHistsignal": { + "tag": "Security Monitoring", + "undo": { + "type": "safe" + } + }, "ListHistoricalJobs": { "tag": "Security Monitoring", "undo": { @@ -3398,6 +3416,12 @@ "type": "idempotent" } }, + "GetSecurityMonitoringHistsignalsByJobId": { + "tag": "Security Monitoring", + "undo": { + "type": "safe" + } + }, "CreateSLOReportJob": { "tag": "Service Level Objectives", "undo": { diff --git a/packages/datadog-api-client-common/configuration.ts b/packages/datadog-api-client-common/configuration.ts index 1612f9ee9e13..6f61e6bf7a7f 100644 --- a/packages/datadog-api-client-common/configuration.ts +++ b/packages/datadog-api-client-common/configuration.ts @@ -234,13 +234,17 @@ export function createConfiguration( "v2.getHistoricalJob": false, "v2.getRuleVersionHistory": false, "v2.getSBOM": false, + "v2.getSecurityMonitoringHistsignal": false, + "v2.getSecurityMonitoringHistsignalsByJobId": false, "v2.listAssetsSBOMs": false, "v2.listFindings": false, "v2.listHistoricalJobs": false, + "v2.listSecurityMonitoringHistsignals": false, "v2.listVulnerabilities": false, "v2.listVulnerableAssets": false, "v2.muteFindings": false, "v2.runHistoricalJob": false, + "v2.searchSecurityMonitoringHistsignals": false, "v2.createDataset": false, "v2.deleteDataset": false, "v2.getAllDatasets": false, diff --git a/packages/datadog-api-client-v2/apis/SecurityMonitoringApi.ts b/packages/datadog-api-client-v2/apis/SecurityMonitoringApi.ts index 1f171c3a01fa..55ed1dc0339d 100644 --- a/packages/datadog-api-client-v2/apis/SecurityMonitoringApi.ts +++ b/packages/datadog-api-client-v2/apis/SecurityMonitoringApi.ts @@ -1289,6 +1289,152 @@ export class SecurityMonitoringApiRequestFactory extends BaseAPIRequestFactory { return requestContext; } + public async getSecurityMonitoringHistsignal( + histsignalId: string, + _options?: Configuration + ): Promise { + const _config = _options || this.configuration; + + logger.warn("Using unstable operation 'getSecurityMonitoringHistsignal'"); + if (!_config.unstableOperations["v2.getSecurityMonitoringHistsignal"]) { + throw new Error( + "Unstable operation 'getSecurityMonitoringHistsignal' is disabled" + ); + } + + // verify required parameter 'histsignalId' is not null or undefined + if (histsignalId === null || histsignalId === undefined) { + throw new RequiredError( + "histsignalId", + "getSecurityMonitoringHistsignal" + ); + } + + // Path Params + const localVarPath = + "/api/v2/siem-historical-detections/histsignals/{histsignal_id}".replace( + "{histsignal_id}", + encodeURIComponent(String(histsignalId)) + ); + + // Make Request Context + const requestContext = _config + .getServer("v2.SecurityMonitoringApi.getSecurityMonitoringHistsignal") + .makeRequestContext(localVarPath, HttpMethod.GET); + requestContext.setHeaderParam("Accept", "application/json"); + requestContext.setHttpConfig(_config.httpConfig); + + // Apply auth methods + applySecurityAuthentication(_config, requestContext, [ + "apiKeyAuth", + "appKeyAuth", + "AuthZ", + ]); + + return requestContext; + } + + public async getSecurityMonitoringHistsignalsByJobId( + jobId: string, + filterQuery?: string, + filterFrom?: Date, + filterTo?: Date, + sort?: SecurityMonitoringSignalsSort, + pageCursor?: string, + pageLimit?: number, + _options?: Configuration + ): Promise { + const _config = _options || this.configuration; + + logger.warn( + "Using unstable operation 'getSecurityMonitoringHistsignalsByJobId'" + ); + if ( + !_config.unstableOperations["v2.getSecurityMonitoringHistsignalsByJobId"] + ) { + throw new Error( + "Unstable operation 'getSecurityMonitoringHistsignalsByJobId' is disabled" + ); + } + + // verify required parameter 'jobId' is not null or undefined + if (jobId === null || jobId === undefined) { + throw new RequiredError( + "jobId", + "getSecurityMonitoringHistsignalsByJobId" + ); + } + + // Path Params + const localVarPath = + "/api/v2/siem-historical-detections/jobs/{job_id}/histsignals".replace( + "{job_id}", + encodeURIComponent(String(jobId)) + ); + + // Make Request Context + const requestContext = _config + .getServer( + "v2.SecurityMonitoringApi.getSecurityMonitoringHistsignalsByJobId" + ) + .makeRequestContext(localVarPath, HttpMethod.GET); + requestContext.setHeaderParam("Accept", "application/json"); + requestContext.setHttpConfig(_config.httpConfig); + + // Query Params + if (filterQuery !== undefined) { + requestContext.setQueryParam( + "filter[query]", + ObjectSerializer.serialize(filterQuery, "string", ""), + "" + ); + } + if (filterFrom !== undefined) { + requestContext.setQueryParam( + "filter[from]", + ObjectSerializer.serialize(filterFrom, "Date", "date-time"), + "" + ); + } + if (filterTo !== undefined) { + requestContext.setQueryParam( + "filter[to]", + ObjectSerializer.serialize(filterTo, "Date", "date-time"), + "" + ); + } + if (sort !== undefined) { + requestContext.setQueryParam( + "sort", + ObjectSerializer.serialize(sort, "SecurityMonitoringSignalsSort", ""), + "" + ); + } + if (pageCursor !== undefined) { + requestContext.setQueryParam( + "page[cursor]", + ObjectSerializer.serialize(pageCursor, "string", ""), + "" + ); + } + if (pageLimit !== undefined) { + requestContext.setQueryParam( + "page[limit]", + ObjectSerializer.serialize(pageLimit, "number", "int32"), + "" + ); + } + + // Apply auth methods + applySecurityAuthentication(_config, requestContext, [ + "apiKeyAuth", + "appKeyAuth", + "AuthZ", + ]); + + return requestContext; + } + public async getSecurityMonitoringRule( ruleId: string, _options?: Configuration @@ -1939,6 +2085,88 @@ export class SecurityMonitoringApiRequestFactory extends BaseAPIRequestFactory { return requestContext; } + public async listSecurityMonitoringHistsignals( + filterQuery?: string, + filterFrom?: Date, + filterTo?: Date, + sort?: SecurityMonitoringSignalsSort, + pageCursor?: string, + pageLimit?: number, + _options?: Configuration + ): Promise { + const _config = _options || this.configuration; + + logger.warn("Using unstable operation 'listSecurityMonitoringHistsignals'"); + if (!_config.unstableOperations["v2.listSecurityMonitoringHistsignals"]) { + throw new Error( + "Unstable operation 'listSecurityMonitoringHistsignals' is disabled" + ); + } + + // Path Params + const localVarPath = "/api/v2/siem-historical-detections/histsignals"; + + // Make Request Context + const requestContext = _config + .getServer("v2.SecurityMonitoringApi.listSecurityMonitoringHistsignals") + .makeRequestContext(localVarPath, HttpMethod.GET); + requestContext.setHeaderParam("Accept", "application/json"); + requestContext.setHttpConfig(_config.httpConfig); + + // Query Params + if (filterQuery !== undefined) { + requestContext.setQueryParam( + "filter[query]", + ObjectSerializer.serialize(filterQuery, "string", ""), + "" + ); + } + if (filterFrom !== undefined) { + requestContext.setQueryParam( + "filter[from]", + ObjectSerializer.serialize(filterFrom, "Date", "date-time"), + "" + ); + } + if (filterTo !== undefined) { + requestContext.setQueryParam( + "filter[to]", + ObjectSerializer.serialize(filterTo, "Date", "date-time"), + "" + ); + } + if (sort !== undefined) { + requestContext.setQueryParam( + "sort", + ObjectSerializer.serialize(sort, "SecurityMonitoringSignalsSort", ""), + "" + ); + } + if (pageCursor !== undefined) { + requestContext.setQueryParam( + "page[cursor]", + ObjectSerializer.serialize(pageCursor, "string", ""), + "" + ); + } + if (pageLimit !== undefined) { + requestContext.setQueryParam( + "page[limit]", + ObjectSerializer.serialize(pageLimit, "number", "int32"), + "" + ); + } + + // Apply auth methods + applySecurityAuthentication(_config, requestContext, [ + "apiKeyAuth", + "appKeyAuth", + "AuthZ", + ]); + + return requestContext; + } + public async listSecurityMonitoringRules( pageSize?: number, pageNumber?: number, @@ -2872,6 +3100,57 @@ export class SecurityMonitoringApiRequestFactory extends BaseAPIRequestFactory { return requestContext; } + public async searchSecurityMonitoringHistsignals( + body?: SecurityMonitoringSignalListRequest, + _options?: Configuration + ): Promise { + const _config = _options || this.configuration; + + logger.warn( + "Using unstable operation 'searchSecurityMonitoringHistsignals'" + ); + if (!_config.unstableOperations["v2.searchSecurityMonitoringHistsignals"]) { + throw new Error( + "Unstable operation 'searchSecurityMonitoringHistsignals' is disabled" + ); + } + + // Path Params + const localVarPath = + "/api/v2/siem-historical-detections/histsignals/search"; + + // Make Request Context + const requestContext = _config + .getServer("v2.SecurityMonitoringApi.searchSecurityMonitoringHistsignals") + .makeRequestContext(localVarPath, HttpMethod.GET); + requestContext.setHeaderParam("Accept", "application/json"); + requestContext.setHttpConfig(_config.httpConfig); + + // Body Params + const contentType = ObjectSerializer.getPreferredMediaType([ + "application/json", + ]); + requestContext.setHeaderParam("Content-Type", contentType); + const serializedBody = ObjectSerializer.stringify( + ObjectSerializer.serialize( + body, + "SecurityMonitoringSignalListRequest", + "" + ), + contentType + ); + requestContext.setBody(serializedBody); + + // Apply auth methods + applySecurityAuthentication(_config, requestContext, [ + "apiKeyAuth", + "appKeyAuth", + "AuthZ", + ]); + + return requestContext; + } + public async searchSecurityMonitoringSignals( body?: SecurityMonitoringSignalListRequest, _options?: Configuration @@ -5027,6 +5306,136 @@ export class SecurityMonitoringApiResponseProcessor { ); } + /** + * Unwraps the actual response sent by the server from the response context and deserializes the response content + * to the expected objects + * + * @params response Response returned by the server for a request to getSecurityMonitoringHistsignal + * @throws ApiException if the response code was not in [200, 299] + */ + public async getSecurityMonitoringHistsignal( + response: ResponseContext + ): Promise { + const contentType = ObjectSerializer.normalizeMediaType( + response.headers["content-type"] + ); + if (response.httpStatusCode === 200) { + const body: SecurityMonitoringSignalResponse = + ObjectSerializer.deserialize( + ObjectSerializer.parse(await response.body.text(), contentType), + "SecurityMonitoringSignalResponse" + ) as SecurityMonitoringSignalResponse; + return body; + } + if ( + response.httpStatusCode === 400 || + response.httpStatusCode === 403 || + response.httpStatusCode === 404 || + response.httpStatusCode === 429 + ) { + const bodyText = ObjectSerializer.parse( + await response.body.text(), + contentType + ); + let body: APIErrorResponse; + try { + body = ObjectSerializer.deserialize( + bodyText, + "APIErrorResponse" + ) as APIErrorResponse; + } catch (error) { + logger.debug(`Got error deserializing error: ${error}`); + throw new ApiException( + response.httpStatusCode, + bodyText + ); + } + throw new ApiException(response.httpStatusCode, body); + } + + // Work around for missing responses in specification, e.g. for petstore.yaml + if (response.httpStatusCode >= 200 && response.httpStatusCode <= 299) { + const body: SecurityMonitoringSignalResponse = + ObjectSerializer.deserialize( + ObjectSerializer.parse(await response.body.text(), contentType), + "SecurityMonitoringSignalResponse", + "" + ) as SecurityMonitoringSignalResponse; + return body; + } + + const body = (await response.body.text()) || ""; + throw new ApiException( + response.httpStatusCode, + 'Unknown API Status Code!\nBody: "' + body + '"' + ); + } + + /** + * Unwraps the actual response sent by the server from the response context and deserializes the response content + * to the expected objects + * + * @params response Response returned by the server for a request to getSecurityMonitoringHistsignalsByJobId + * @throws ApiException if the response code was not in [200, 299] + */ + public async getSecurityMonitoringHistsignalsByJobId( + response: ResponseContext + ): Promise { + const contentType = ObjectSerializer.normalizeMediaType( + response.headers["content-type"] + ); + if (response.httpStatusCode === 200) { + const body: SecurityMonitoringSignalsListResponse = + ObjectSerializer.deserialize( + ObjectSerializer.parse(await response.body.text(), contentType), + "SecurityMonitoringSignalsListResponse" + ) as SecurityMonitoringSignalsListResponse; + return body; + } + if ( + response.httpStatusCode === 400 || + response.httpStatusCode === 403 || + response.httpStatusCode === 404 || + response.httpStatusCode === 429 + ) { + const bodyText = ObjectSerializer.parse( + await response.body.text(), + contentType + ); + let body: APIErrorResponse; + try { + body = ObjectSerializer.deserialize( + bodyText, + "APIErrorResponse" + ) as APIErrorResponse; + } catch (error) { + logger.debug(`Got error deserializing error: ${error}`); + throw new ApiException( + response.httpStatusCode, + bodyText + ); + } + throw new ApiException(response.httpStatusCode, body); + } + + // Work around for missing responses in specification, e.g. for petstore.yaml + if (response.httpStatusCode >= 200 && response.httpStatusCode <= 299) { + const body: SecurityMonitoringSignalsListResponse = + ObjectSerializer.deserialize( + ObjectSerializer.parse(await response.body.text(), contentType), + "SecurityMonitoringSignalsListResponse", + "" + ) as SecurityMonitoringSignalsListResponse; + return body; + } + + const body = (await response.body.text()) || ""; + throw new ApiException( + response.httpStatusCode, + 'Unknown API Status Code!\nBody: "' + body + '"' + ); + } + /** * Unwraps the actual response sent by the server from the response context and deserializes the response content * to the expected objects @@ -5806,13 +6215,77 @@ export class SecurityMonitoringApiResponseProcessor { response.headers["content-type"] ); if (response.httpStatusCode === 200) { - const body: SecurityFiltersResponse = ObjectSerializer.deserialize( - ObjectSerializer.parse(await response.body.text(), contentType), - "SecurityFiltersResponse" - ) as SecurityFiltersResponse; + const body: SecurityFiltersResponse = ObjectSerializer.deserialize( + ObjectSerializer.parse(await response.body.text(), contentType), + "SecurityFiltersResponse" + ) as SecurityFiltersResponse; + return body; + } + if (response.httpStatusCode === 403 || response.httpStatusCode === 429) { + const bodyText = ObjectSerializer.parse( + await response.body.text(), + contentType + ); + let body: APIErrorResponse; + try { + body = ObjectSerializer.deserialize( + bodyText, + "APIErrorResponse" + ) as APIErrorResponse; + } catch (error) { + logger.debug(`Got error deserializing error: ${error}`); + throw new ApiException( + response.httpStatusCode, + bodyText + ); + } + throw new ApiException(response.httpStatusCode, body); + } + + // Work around for missing responses in specification, e.g. for petstore.yaml + if (response.httpStatusCode >= 200 && response.httpStatusCode <= 299) { + const body: SecurityFiltersResponse = ObjectSerializer.deserialize( + ObjectSerializer.parse(await response.body.text(), contentType), + "SecurityFiltersResponse", + "" + ) as SecurityFiltersResponse; + return body; + } + + const body = (await response.body.text()) || ""; + throw new ApiException( + response.httpStatusCode, + 'Unknown API Status Code!\nBody: "' + body + '"' + ); + } + + /** + * Unwraps the actual response sent by the server from the response context and deserializes the response content + * to the expected objects + * + * @params response Response returned by the server for a request to listSecurityMonitoringHistsignals + * @throws ApiException if the response code was not in [200, 299] + */ + public async listSecurityMonitoringHistsignals( + response: ResponseContext + ): Promise { + const contentType = ObjectSerializer.normalizeMediaType( + response.headers["content-type"] + ); + if (response.httpStatusCode === 200) { + const body: SecurityMonitoringSignalsListResponse = + ObjectSerializer.deserialize( + ObjectSerializer.parse(await response.body.text(), contentType), + "SecurityMonitoringSignalsListResponse" + ) as SecurityMonitoringSignalsListResponse; return body; } - if (response.httpStatusCode === 403 || response.httpStatusCode === 429) { + if ( + response.httpStatusCode === 400 || + response.httpStatusCode === 403 || + response.httpStatusCode === 404 || + response.httpStatusCode === 429 + ) { const bodyText = ObjectSerializer.parse( await response.body.text(), contentType @@ -5835,11 +6308,12 @@ export class SecurityMonitoringApiResponseProcessor { // Work around for missing responses in specification, e.g. for petstore.yaml if (response.httpStatusCode >= 200 && response.httpStatusCode <= 299) { - const body: SecurityFiltersResponse = ObjectSerializer.deserialize( - ObjectSerializer.parse(await response.body.text(), contentType), - "SecurityFiltersResponse", - "" - ) as SecurityFiltersResponse; + const body: SecurityMonitoringSignalsListResponse = + ObjectSerializer.deserialize( + ObjectSerializer.parse(await response.body.text(), contentType), + "SecurityMonitoringSignalsListResponse", + "" + ) as SecurityMonitoringSignalsListResponse; return body; } @@ -6507,6 +6981,71 @@ export class SecurityMonitoringApiResponseProcessor { ); } + /** + * Unwraps the actual response sent by the server from the response context and deserializes the response content + * to the expected objects + * + * @params response Response returned by the server for a request to searchSecurityMonitoringHistsignals + * @throws ApiException if the response code was not in [200, 299] + */ + public async searchSecurityMonitoringHistsignals( + response: ResponseContext + ): Promise { + const contentType = ObjectSerializer.normalizeMediaType( + response.headers["content-type"] + ); + if (response.httpStatusCode === 200) { + const body: SecurityMonitoringSignalsListResponse = + ObjectSerializer.deserialize( + ObjectSerializer.parse(await response.body.text(), contentType), + "SecurityMonitoringSignalsListResponse" + ) as SecurityMonitoringSignalsListResponse; + return body; + } + if ( + response.httpStatusCode === 400 || + response.httpStatusCode === 403 || + response.httpStatusCode === 404 || + response.httpStatusCode === 429 + ) { + const bodyText = ObjectSerializer.parse( + await response.body.text(), + contentType + ); + let body: APIErrorResponse; + try { + body = ObjectSerializer.deserialize( + bodyText, + "APIErrorResponse" + ) as APIErrorResponse; + } catch (error) { + logger.debug(`Got error deserializing error: ${error}`); + throw new ApiException( + response.httpStatusCode, + bodyText + ); + } + throw new ApiException(response.httpStatusCode, body); + } + + // Work around for missing responses in specification, e.g. for petstore.yaml + if (response.httpStatusCode >= 200 && response.httpStatusCode <= 299) { + const body: SecurityMonitoringSignalsListResponse = + ObjectSerializer.deserialize( + ObjectSerializer.parse(await response.body.text(), contentType), + "SecurityMonitoringSignalsListResponse", + "" + ) as SecurityMonitoringSignalsListResponse; + return body; + } + + const body = (await response.body.text()) || ""; + throw new ApiException( + response.httpStatusCode, + 'Unknown API Status Code!\nBody: "' + body + '"' + ); + } + /** * Unwraps the actual response sent by the server from the response context and deserializes the response content * to the expected objects @@ -7404,6 +7943,52 @@ export interface SecurityMonitoringApiGetSecurityFilterRequest { securityFilterId: string; } +export interface SecurityMonitoringApiGetSecurityMonitoringHistsignalRequest { + /** + * The ID of the historical signal. + * @type string + */ + histsignalId: string; +} + +export interface SecurityMonitoringApiGetSecurityMonitoringHistsignalsByJobIdRequest { + /** + * The ID of the job. + * @type string + */ + jobId: string; + /** + * The search query for security signals. + * @type string + */ + filterQuery?: string; + /** + * The minimum timestamp for requested security signals. + * @type Date + */ + filterFrom?: Date; + /** + * The maximum timestamp for requested security signals. + * @type Date + */ + filterTo?: Date; + /** + * The order of the security signals in results. + * @type SecurityMonitoringSignalsSort + */ + sort?: SecurityMonitoringSignalsSort; + /** + * A list of results using the cursor provided in the previous query. + * @type string + */ + pageCursor?: string; + /** + * The maximum number of security signals in the response. + * @type number + */ + pageLimit?: number; +} + export interface SecurityMonitoringApiGetSecurityMonitoringRuleRequest { /** * The ID of the rule. @@ -7603,6 +8188,39 @@ export interface SecurityMonitoringApiListHistoricalJobsRequest { filterQuery?: string; } +export interface SecurityMonitoringApiListSecurityMonitoringHistsignalsRequest { + /** + * The search query for security signals. + * @type string + */ + filterQuery?: string; + /** + * The minimum timestamp for requested security signals. + * @type Date + */ + filterFrom?: Date; + /** + * The maximum timestamp for requested security signals. + * @type Date + */ + filterTo?: Date; + /** + * The order of the security signals in results. + * @type SecurityMonitoringSignalsSort + */ + sort?: SecurityMonitoringSignalsSort; + /** + * A list of results using the cursor provided in the previous query. + * @type string + */ + pageCursor?: string; + /** + * The maximum number of security signals in the response. + * @type number + */ + pageLimit?: number; +} + export interface SecurityMonitoringApiListSecurityMonitoringRulesRequest { /** * Size for a given page. The maximum allowed value is 100. @@ -7998,6 +8616,13 @@ export interface SecurityMonitoringApiRunHistoricalJobRequest { body: RunHistoricalJobRequest; } +export interface SecurityMonitoringApiSearchSecurityMonitoringHistsignalsRequest { + /** + * @type SecurityMonitoringSignalListRequest + */ + body?: SecurityMonitoringSignalListRequest; +} + export interface SecurityMonitoringApiSearchSecurityMonitoringSignalsRequest { /** * @type SecurityMonitoringSignalListRequest @@ -8736,6 +9361,60 @@ export class SecurityMonitoringApi { }); } + /** + * Get a hist signal's details. + * @param param The request object + */ + public getSecurityMonitoringHistsignal( + param: SecurityMonitoringApiGetSecurityMonitoringHistsignalRequest, + options?: Configuration + ): Promise { + const requestContextPromise = + this.requestFactory.getSecurityMonitoringHistsignal( + param.histsignalId, + options + ); + return requestContextPromise.then((requestContext) => { + return this.configuration.httpApi + .send(requestContext) + .then((responseContext) => { + return this.responseProcessor.getSecurityMonitoringHistsignal( + responseContext + ); + }); + }); + } + + /** + * Get a job's hist signals. + * @param param The request object + */ + public getSecurityMonitoringHistsignalsByJobId( + param: SecurityMonitoringApiGetSecurityMonitoringHistsignalsByJobIdRequest, + options?: Configuration + ): Promise { + const requestContextPromise = + this.requestFactory.getSecurityMonitoringHistsignalsByJobId( + param.jobId, + param.filterQuery, + param.filterFrom, + param.filterTo, + param.sort, + param.pageCursor, + param.pageLimit, + options + ); + return requestContextPromise.then((requestContext) => { + return this.configuration.httpApi + .send(requestContext) + .then((responseContext) => { + return this.responseProcessor.getSecurityMonitoringHistsignalsByJobId( + responseContext + ); + }); + }); + } + /** * Get a rule's details. * @param param The request object @@ -9159,6 +9838,35 @@ export class SecurityMonitoringApi { }); } + /** + * List hist signals. + * @param param The request object + */ + public listSecurityMonitoringHistsignals( + param: SecurityMonitoringApiListSecurityMonitoringHistsignalsRequest = {}, + options?: Configuration + ): Promise { + const requestContextPromise = + this.requestFactory.listSecurityMonitoringHistsignals( + param.filterQuery, + param.filterFrom, + param.filterTo, + param.sort, + param.pageCursor, + param.pageLimit, + options + ); + return requestContextPromise.then((requestContext) => { + return this.configuration.httpApi + .send(requestContext) + .then((responseContext) => { + return this.responseProcessor.listSecurityMonitoringHistsignals( + responseContext + ); + }); + }); + } + /** * List rules. * @param param The request object @@ -9576,6 +10284,30 @@ export class SecurityMonitoringApi { }); } + /** + * Search hist signals. + * @param param The request object + */ + public searchSecurityMonitoringHistsignals( + param: SecurityMonitoringApiSearchSecurityMonitoringHistsignalsRequest = {}, + options?: Configuration + ): Promise { + const requestContextPromise = + this.requestFactory.searchSecurityMonitoringHistsignals( + param.body, + options + ); + return requestContextPromise.then((requestContext) => { + return this.configuration.httpApi + .send(requestContext) + .then((responseContext) => { + return this.responseProcessor.searchSecurityMonitoringHistsignals( + responseContext + ); + }); + }); + } + /** * Returns security signals that match a search query. * Both this endpoint and the GET endpoint can be used interchangeably for listing diff --git a/packages/datadog-api-client-v2/index.ts b/packages/datadog-api-client-v2/index.ts index e436f8bd6597..dd08ae93d91f 100644 --- a/packages/datadog-api-client-v2/index.ts +++ b/packages/datadog-api-client-v2/index.ts @@ -606,6 +606,8 @@ export { SecurityMonitoringApiGetRuleVersionHistoryRequest, SecurityMonitoringApiGetSBOMRequest, SecurityMonitoringApiGetSecurityFilterRequest, + SecurityMonitoringApiGetSecurityMonitoringHistsignalRequest, + SecurityMonitoringApiGetSecurityMonitoringHistsignalsByJobIdRequest, SecurityMonitoringApiGetSecurityMonitoringRuleRequest, SecurityMonitoringApiGetSecurityMonitoringSignalRequest, SecurityMonitoringApiGetSecurityMonitoringSuppressionRequest, @@ -616,6 +618,7 @@ export { SecurityMonitoringApiListAssetsSBOMsRequest, SecurityMonitoringApiListFindingsRequest, SecurityMonitoringApiListHistoricalJobsRequest, + SecurityMonitoringApiListSecurityMonitoringHistsignalsRequest, SecurityMonitoringApiListSecurityMonitoringRulesRequest, SecurityMonitoringApiListSecurityMonitoringSignalsRequest, SecurityMonitoringApiListVulnerabilitiesRequest, @@ -624,6 +627,7 @@ export { SecurityMonitoringApiPatchSignalNotificationRuleRequest, SecurityMonitoringApiPatchVulnerabilityNotificationRuleRequest, SecurityMonitoringApiRunHistoricalJobRequest, + SecurityMonitoringApiSearchSecurityMonitoringHistsignalsRequest, SecurityMonitoringApiSearchSecurityMonitoringSignalsRequest, SecurityMonitoringApiTestExistingSecurityMonitoringRuleRequest, SecurityMonitoringApiTestSecurityMonitoringRuleRequest,