diff --git a/.generator/schemas/v2/openapi.yaml b/.generator/schemas/v2/openapi.yaml index 3ac7ae5f2b73..2231a2405db6 100644 --- a/.generator/schemas/v2/openapi.yaml +++ b/.generator/schemas/v2/openapi.yaml @@ -64029,6 +64029,38 @@ components: type: string x-enum-varnames: - SIGNAL + SecurityMonitoringSignalUpdateAttributes: + description: Attributes for updating one or more triage attributes of a security signal. + properties: + archive_comment: + $ref: "#/components/schemas/SecurityMonitoringSignalArchiveComment" + archive_reason: + $ref: "#/components/schemas/SecurityMonitoringSignalArchiveReason" + assignee: + $ref: "#/components/schemas/SecurityMonitoringTriageUser" + state: + $ref: "#/components/schemas/SecurityMonitoringSignalState" + version: + $ref: "#/components/schemas/SecurityMonitoringSignalVersion" + type: object + SecurityMonitoringSignalUpdateData: + description: Data containing the triage update for a security signal. + properties: + attributes: + $ref: "#/components/schemas/SecurityMonitoringSignalUpdateAttributes" + type: + $ref: "#/components/schemas/SecurityMonitoringSignalMetadataType" + required: + - attributes + type: object + SecurityMonitoringSignalUpdateRequest: + description: Request body for updating the triage attributes of a security signal. + properties: + data: + $ref: "#/components/schemas/SecurityMonitoringSignalUpdateData" + required: + - data + type: object SecurityMonitoringSignalVersion: description: Version of the updated signal. If server side version is higher, update will be rejected. format: int64 @@ -64182,6 +64214,33 @@ components: - count - events type: object + SecurityMonitoringSignalsBulkUpdateData: + description: Data for updating a single security signal in a bulk update operation. + properties: + attributes: + $ref: "#/components/schemas/SecurityMonitoringSignalUpdateAttributes" + id: + description: The unique ID of the security signal. + example: AAAAAWgN8Xwgr1vKDQAAAABBV2dOOFh3ZzZobm1mWXJFYTR0OA + type: string + type: + $ref: "#/components/schemas/SecurityMonitoringSignalType" + required: + - id + - attributes + type: object + SecurityMonitoringSignalsBulkUpdateRequest: + description: Request body for updating multiple attributes of multiple security signals. + properties: + data: + description: An array of signal updates. + items: + $ref: "#/components/schemas/SecurityMonitoringSignalsBulkUpdateData" + maxItems: 199 + type: array + required: + - data + type: object SecurityMonitoringSignalsListResponse: description: "The response object with all security signals matching the request\nand pagination information." properties: @@ -114190,6 +114249,51 @@ paths: operator: OR permissions: - security_monitoring_signals_write + /api/v2/security_monitoring/signals/bulk/update: + patch: + description: |- + Update one or more triage attributes of multiple security signals at once. + The maximum number of signals that can be updated in a single request is 199. + operationId: BulkEditSecurityMonitoringSignals + requestBody: + content: + application/json: + schema: + $ref: "#/components/schemas/SecurityMonitoringSignalsBulkUpdateRequest" + description: Attributes describing the signal updates. + required: true + responses: + "200": + content: + application/json: + schema: + $ref: "#/components/schemas/SecurityMonitoringSignalsBulkTriageUpdateResponse" + description: OK + "400": + content: + application/json: + schema: + $ref: "#/components/schemas/JSONAPIErrorResponse" + description: Bad Request + "403": + content: + application/json: + schema: + $ref: "#/components/schemas/JSONAPIErrorResponse" + description: Forbidden + "429": + $ref: "#/components/responses/TooManyRequestsResponse" + security: + - apiKeyAuth: [] + appKeyAuth: [] + - AuthZ: [] + summary: Bulk update security signals + tags: ["Security Monitoring"] + x-codegen-request-body-name: body + "x-permission": + operator: OR + permissions: + - security_monitoring_signals_write /api/v2/security_monitoring/signals/search: post: description: |- @@ -114479,6 +114583,58 @@ paths: permissions: - security_monitoring_rules_read - security_monitoring_signals_read + /api/v2/security_monitoring/signals/{signal_id}/update: + patch: + description: |- + Update one or more triage attributes of a security signal. + operationId: EditSecurityMonitoringSignal + parameters: + - $ref: "#/components/parameters/SignalID" + requestBody: + content: + application/json: + schema: + $ref: "#/components/schemas/SecurityMonitoringSignalUpdateRequest" + description: Attributes describing the signal triage update. + required: true + responses: + "200": + content: + application/json: + schema: + $ref: "#/components/schemas/SecurityMonitoringSignalTriageUpdateResponse" + description: OK + "400": + content: + application/json: + schema: + $ref: "#/components/schemas/JSONAPIErrorResponse" + description: Bad Request + "403": + content: + application/json: + schema: + $ref: "#/components/schemas/JSONAPIErrorResponse" + description: Forbidden + "404": + content: + application/json: + schema: + $ref: "#/components/schemas/JSONAPIErrorResponse" + description: Not Found + "429": + $ref: "#/components/responses/TooManyRequestsResponse" + security: + - apiKeyAuth: [] + appKeyAuth: [] + - AuthZ: [] + summary: Update a security signal's triage attributes + tags: ["Security Monitoring"] + x-codegen-request-body-name: body + "x-permission": + operator: OR + permissions: + - security_monitoring_signals_write /api/v2/security_monitoring/terraform/{resource_type}/bulk: post: description: |- diff --git a/examples/v2/security-monitoring/BulkEditSecurityMonitoringSignals.ts b/examples/v2/security-monitoring/BulkEditSecurityMonitoringSignals.ts new file mode 100644 index 000000000000..0503ad1b3a14 --- /dev/null +++ b/examples/v2/security-monitoring/BulkEditSecurityMonitoringSignals.ts @@ -0,0 +1,37 @@ +/** + * Bulk update security signals returns "OK" response + */ + +import { client, v2 } from "@datadog/datadog-api-client"; + +const configuration = client.createConfiguration(); +const apiInstance = new v2.SecurityMonitoringApi(configuration); + +const params: v2.SecurityMonitoringApiBulkEditSecurityMonitoringSignalsRequest = + { + body: { + data: [ + { + attributes: { + archiveReason: "none", + assignee: { + name: undefined, + uuid: "773b045d-ccf8-4808-bd3b-955ef6a8c940", + }, + state: "open", + }, + id: "AAAAAWgN8Xwgr1vKDQAAAABBV2dOOFh3ZzZobm1mWXJFYTR0OA", + type: "signal", + }, + ], + }, + }; + +apiInstance + .bulkEditSecurityMonitoringSignals(params) + .then((data: v2.SecurityMonitoringSignalsBulkTriageUpdateResponse) => { + console.log( + "API called successfully. Returned data: " + JSON.stringify(data) + ); + }) + .catch((error: any) => console.error(error)); diff --git a/examples/v2/security-monitoring/EditSecurityMonitoringSignal.ts b/examples/v2/security-monitoring/EditSecurityMonitoringSignal.ts new file mode 100644 index 000000000000..b0d37b399939 --- /dev/null +++ b/examples/v2/security-monitoring/EditSecurityMonitoringSignal.ts @@ -0,0 +1,34 @@ +/** + * Update a security signal's triage attributes returns "OK" response + */ + +import { client, v2 } from "@datadog/datadog-api-client"; + +const configuration = client.createConfiguration(); +const apiInstance = new v2.SecurityMonitoringApi(configuration); + +const params: v2.SecurityMonitoringApiEditSecurityMonitoringSignalRequest = { + body: { + data: { + attributes: { + archiveReason: "none", + assignee: { + name: undefined, + uuid: "773b045d-ccf8-4808-bd3b-955ef6a8c940", + }, + state: "open", + }, + type: "signal_metadata", + }, + }, + signalId: "signal_id", +}; + +apiInstance + .editSecurityMonitoringSignal(params) + .then((data: v2.SecurityMonitoringSignalTriageUpdateResponse) => { + 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 cda61d968950..304a682ef181 100644 --- a/features/support/scenarios_model_mapping.ts +++ b/features/support/scenarios_model_mapping.ts @@ -5166,6 +5166,13 @@ export const ScenariosModelMappings: {[key: string]: {[key: string]: any}} = { }, "operationResponseType": "SecurityMonitoringSignalsBulkTriageUpdateResponse", }, + "v2.BulkEditSecurityMonitoringSignals": { + "body": { + "type": "SecurityMonitoringSignalsBulkUpdateRequest", + "format": "", + }, + "operationResponseType": "SecurityMonitoringSignalsBulkTriageUpdateResponse", + }, "v2.SearchSecurityMonitoringSignals": { "body": { "type": "SecurityMonitoringSignalListRequest", @@ -5227,6 +5234,17 @@ export const ScenariosModelMappings: {[key: string]: {[key: string]: any}} = { }, "operationResponseType": "SecurityMonitoringSignalSuggestedActionsResponse", }, + "v2.EditSecurityMonitoringSignal": { + "signalId": { + "type": "string", + "format": "", + }, + "body": { + "type": "SecurityMonitoringSignalUpdateRequest", + "format": "", + }, + "operationResponseType": "SecurityMonitoringSignalTriageUpdateResponse", + }, "v2.BulkExportSecurityMonitoringTerraformResources": { "resourceType": { "type": "SecurityMonitoringTerraformResourceType", diff --git a/features/v2/security_monitoring.feature b/features/v2/security_monitoring.feature index 1da592aca20b..fe7c62475a9a 100644 --- a/features/v2/security_monitoring.feature +++ b/features/v2/security_monitoring.feature @@ -121,6 +121,20 @@ Feature: Security Monitoring When the request is sent Then the response status is 200 OK + @generated @skip @team:DataDog/k9-cloud-siem + Scenario: Bulk update security signals returns "Bad Request" response + Given new "BulkEditSecurityMonitoringSignals" request + And body with value {"data": [{"attributes": {"archive_reason": "none", "assignee": {"name": null, "uuid": "773b045d-ccf8-4808-bd3b-955ef6a8c940"}, "state": "open"}, "id": "AAAAAWgN8Xwgr1vKDQAAAABBV2dOOFh3ZzZobm1mWXJFYTR0OA", "type": "signal"}]} + When the request is sent + Then the response status is 400 Bad Request + + @generated @skip @team:DataDog/k9-cloud-siem + Scenario: Bulk update security signals returns "OK" response + Given new "BulkEditSecurityMonitoringSignals" request + And body with value {"data": [{"attributes": {"archive_reason": "none", "assignee": {"name": null, "uuid": "773b045d-ccf8-4808-bd3b-955ef6a8c940"}, "state": "open"}, "id": "AAAAAWgN8Xwgr1vKDQAAAABBV2dOOFh3ZzZobm1mWXJFYTR0OA", "type": "signal"}]} + When the request is sent + Then the response status is 200 OK + @skip @team:DataDog/k9-cloud-siem Scenario: Bulk update triage assignee of security signals returns "Bad Request" response Given operation "BulkEditSecurityMonitoringSignalsAssignee" enabled @@ -2188,6 +2202,30 @@ Feature: Security Monitoring And the response "data.attributes.filtered_data_type" is equal to "logs" And the response "data.attributes.name" is equal to "{{ unique }}" + @generated @skip @team:DataDog/k9-cloud-siem + Scenario: Update a security signal's triage attributes returns "Bad Request" response + Given new "EditSecurityMonitoringSignal" request + And request contains "signal_id" parameter from "REPLACE.ME" + And body with value {"data": {"attributes": {"archive_reason": "none", "assignee": {"name": null, "uuid": "773b045d-ccf8-4808-bd3b-955ef6a8c940"}, "state": "open"}, "type": "signal_metadata"}} + When the request is sent + Then the response status is 400 Bad Request + + @generated @skip @team:DataDog/k9-cloud-siem + Scenario: Update a security signal's triage attributes returns "Not Found" response + Given new "EditSecurityMonitoringSignal" request + And request contains "signal_id" parameter from "REPLACE.ME" + And body with value {"data": {"attributes": {"archive_reason": "none", "assignee": {"name": null, "uuid": "773b045d-ccf8-4808-bd3b-955ef6a8c940"}, "state": "open"}, "type": "signal_metadata"}} + When the request is sent + Then the response status is 404 Not Found + + @generated @skip @team:DataDog/k9-cloud-siem + Scenario: Update a security signal's triage attributes returns "OK" response + Given new "EditSecurityMonitoringSignal" request + And request contains "signal_id" parameter from "REPLACE.ME" + And body with value {"data": {"attributes": {"archive_reason": "none", "assignee": {"name": null, "uuid": "773b045d-ccf8-4808-bd3b-955ef6a8c940"}, "state": "open"}, "type": "signal_metadata"}} + When the request is sent + Then the response status is 200 OK + @generated @skip @team:DataDog/k9-cloud-siem Scenario: Update a suppression rule returns "Bad Request" response Given new "UpdateSecurityMonitoringSuppression" request diff --git a/features/v2/undo.json b/features/v2/undo.json index f78cd823b2cb..5dfdd19c83a9 100644 --- a/features/v2/undo.json +++ b/features/v2/undo.json @@ -5674,6 +5674,12 @@ "type": "idempotent" } }, + "BulkEditSecurityMonitoringSignals": { + "tag": "Security Monitoring", + "undo": { + "type": "idempotent" + } + }, "SearchSecurityMonitoringSignals": { "tag": "Security Monitoring", "undo": { @@ -5716,6 +5722,12 @@ "type": "safe" } }, + "EditSecurityMonitoringSignal": { + "tag": "Security Monitoring", + "undo": { + "type": "idempotent" + } + }, "BulkExportSecurityMonitoringTerraformResources": { "tag": "Security Monitoring", "undo": { diff --git a/packages/datadog-api-client-v2/apis/SecurityMonitoringApi.ts b/packages/datadog-api-client-v2/apis/SecurityMonitoringApi.ts index 1f18a65f7234..c0186ad95a27 100644 --- a/packages/datadog-api-client-v2/apis/SecurityMonitoringApi.ts +++ b/packages/datadog-api-client-v2/apis/SecurityMonitoringApi.ts @@ -100,11 +100,13 @@ import { SecurityMonitoringSignalResponse } from "../models/SecurityMonitoringSi import { SecurityMonitoringSignalsBulkAssigneeUpdateRequest } from "../models/SecurityMonitoringSignalsBulkAssigneeUpdateRequest"; import { SecurityMonitoringSignalsBulkStateUpdateRequest } from "../models/SecurityMonitoringSignalsBulkStateUpdateRequest"; import { SecurityMonitoringSignalsBulkTriageUpdateResponse } from "../models/SecurityMonitoringSignalsBulkTriageUpdateResponse"; +import { SecurityMonitoringSignalsBulkUpdateRequest } from "../models/SecurityMonitoringSignalsBulkUpdateRequest"; import { SecurityMonitoringSignalsListResponse } from "../models/SecurityMonitoringSignalsListResponse"; import { SecurityMonitoringSignalsSort } from "../models/SecurityMonitoringSignalsSort"; import { SecurityMonitoringSignalStateUpdateRequest } from "../models/SecurityMonitoringSignalStateUpdateRequest"; import { SecurityMonitoringSignalSuggestedActionsResponse } from "../models/SecurityMonitoringSignalSuggestedActionsResponse"; import { SecurityMonitoringSignalTriageUpdateResponse } from "../models/SecurityMonitoringSignalTriageUpdateResponse"; +import { SecurityMonitoringSignalUpdateRequest } from "../models/SecurityMonitoringSignalUpdateRequest"; import { SecurityMonitoringSuppressionCreateRequest } from "../models/SecurityMonitoringSuppressionCreateRequest"; import { SecurityMonitoringSuppressionResponse } from "../models/SecurityMonitoringSuppressionResponse"; import { SecurityMonitoringSuppressionSort } from "../models/SecurityMonitoringSuppressionSort"; @@ -258,6 +260,52 @@ export class SecurityMonitoringApiRequestFactory extends BaseAPIRequestFactory { return requestContext; } + public async bulkEditSecurityMonitoringSignals( + body: SecurityMonitoringSignalsBulkUpdateRequest, + _options?: Configuration + ): Promise { + const _config = _options || this.configuration; + + // verify required parameter 'body' is not null or undefined + if (body === null || body === undefined) { + throw new RequiredError("body", "bulkEditSecurityMonitoringSignals"); + } + + // Path Params + const localVarPath = "/api/v2/security_monitoring/signals/bulk/update"; + + // Make Request Context + const requestContext = _config + .getServer("v2.SecurityMonitoringApi.bulkEditSecurityMonitoringSignals") + .makeRequestContext(localVarPath, HttpMethod.PATCH); + 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, + "SecurityMonitoringSignalsBulkUpdateRequest", + "" + ), + contentType + ); + requestContext.setBody(serializedBody); + + // Apply auth methods + applySecurityAuthentication(_config, requestContext, [ + "apiKeyAuth", + "appKeyAuth", + "AuthZ", + ]); + + return requestContext; + } + public async bulkEditSecurityMonitoringSignalsAssignee( body: SecurityMonitoringSignalsBulkAssigneeUpdateRequest, _options?: Configuration @@ -1512,6 +1560,62 @@ export class SecurityMonitoringApiRequestFactory extends BaseAPIRequestFactory { return requestContext; } + public async editSecurityMonitoringSignal( + signalId: string, + body: SecurityMonitoringSignalUpdateRequest, + _options?: Configuration + ): Promise { + const _config = _options || this.configuration; + + // verify required parameter 'signalId' is not null or undefined + if (signalId === null || signalId === undefined) { + throw new RequiredError("signalId", "editSecurityMonitoringSignal"); + } + + // verify required parameter 'body' is not null or undefined + if (body === null || body === undefined) { + throw new RequiredError("body", "editSecurityMonitoringSignal"); + } + + // Path Params + const localVarPath = + "/api/v2/security_monitoring/signals/{signal_id}/update".replace( + "{signal_id}", + encodeURIComponent(String(signalId)) + ); + + // Make Request Context + const requestContext = _config + .getServer("v2.SecurityMonitoringApi.editSecurityMonitoringSignal") + .makeRequestContext(localVarPath, HttpMethod.PATCH); + 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, + "SecurityMonitoringSignalUpdateRequest", + "" + ), + contentType + ); + requestContext.setBody(serializedBody); + + // Apply auth methods + applySecurityAuthentication(_config, requestContext, [ + "apiKeyAuth", + "appKeyAuth", + "AuthZ", + ]); + + return requestContext; + } + public async editSecurityMonitoringSignalAssignee( signalId: string, body: SecurityMonitoringSignalAssigneeUpdateRequest, @@ -5400,6 +5504,89 @@ 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 bulkEditSecurityMonitoringSignals + * @throws ApiException if the response code was not in [200, 299] + */ + public async bulkEditSecurityMonitoringSignals( + response: ResponseContext + ): Promise { + const contentType = ObjectSerializer.normalizeMediaType( + response.headers["content-type"] + ); + if (response.httpStatusCode === 200) { + const body: SecurityMonitoringSignalsBulkTriageUpdateResponse = + ObjectSerializer.deserialize( + ObjectSerializer.parse(await response.body.text(), contentType), + "SecurityMonitoringSignalsBulkTriageUpdateResponse" + ) as SecurityMonitoringSignalsBulkTriageUpdateResponse; + return body; + } + if (response.httpStatusCode === 400 || response.httpStatusCode === 403) { + const bodyText = ObjectSerializer.parse( + await response.body.text(), + contentType + ); + let body: JSONAPIErrorResponse; + try { + body = ObjectSerializer.deserialize( + bodyText, + "JSONAPIErrorResponse" + ) as JSONAPIErrorResponse; + } catch (error) { + logger.debug(`Got error deserializing error: ${error}`); + throw new ApiException( + response.httpStatusCode, + bodyText + ); + } + throw new ApiException( + response.httpStatusCode, + body + ); + } + if (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: SecurityMonitoringSignalsBulkTriageUpdateResponse = + ObjectSerializer.deserialize( + ObjectSerializer.parse(await response.body.text(), contentType), + "SecurityMonitoringSignalsBulkTriageUpdateResponse", + "" + ) as SecurityMonitoringSignalsBulkTriageUpdateResponse; + 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 @@ -7107,6 +7294,93 @@ 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 editSecurityMonitoringSignal + * @throws ApiException if the response code was not in [200, 299] + */ + public async editSecurityMonitoringSignal( + response: ResponseContext + ): Promise { + const contentType = ObjectSerializer.normalizeMediaType( + response.headers["content-type"] + ); + if (response.httpStatusCode === 200) { + const body: SecurityMonitoringSignalTriageUpdateResponse = + ObjectSerializer.deserialize( + ObjectSerializer.parse(await response.body.text(), contentType), + "SecurityMonitoringSignalTriageUpdateResponse" + ) as SecurityMonitoringSignalTriageUpdateResponse; + return body; + } + if ( + response.httpStatusCode === 400 || + response.httpStatusCode === 403 || + response.httpStatusCode === 404 + ) { + const bodyText = ObjectSerializer.parse( + await response.body.text(), + contentType + ); + let body: JSONAPIErrorResponse; + try { + body = ObjectSerializer.deserialize( + bodyText, + "JSONAPIErrorResponse" + ) as JSONAPIErrorResponse; + } catch (error) { + logger.debug(`Got error deserializing error: ${error}`); + throw new ApiException( + response.httpStatusCode, + bodyText + ); + } + throw new ApiException( + response.httpStatusCode, + body + ); + } + if (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: SecurityMonitoringSignalTriageUpdateResponse = + ObjectSerializer.deserialize( + ObjectSerializer.parse(await response.body.text(), contentType), + "SecurityMonitoringSignalTriageUpdateResponse", + "" + ) as SecurityMonitoringSignalTriageUpdateResponse; + 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 @@ -11202,6 +11476,14 @@ export interface SecurityMonitoringApiAttachJiraIssueRequest { body: AttachJiraIssueRequest; } +export interface SecurityMonitoringApiBulkEditSecurityMonitoringSignalsRequest { + /** + * Attributes describing the signal updates. + * @type SecurityMonitoringSignalsBulkUpdateRequest + */ + body: SecurityMonitoringSignalsBulkUpdateRequest; +} + export interface SecurityMonitoringApiBulkEditSecurityMonitoringSignalsAssigneeRequest { /** * Attributes describing the signal assignee updates. @@ -11435,6 +11717,19 @@ export interface SecurityMonitoringApiDetachCaseRequest { body: DetachCaseRequest; } +export interface SecurityMonitoringApiEditSecurityMonitoringSignalRequest { + /** + * The ID of the signal. + * @type string + */ + signalId: string; + /** + * Attributes describing the signal triage update. + * @type SecurityMonitoringSignalUpdateRequest + */ + body: SecurityMonitoringSignalUpdateRequest; +} + export interface SecurityMonitoringApiEditSecurityMonitoringSignalAssigneeRequest { /** * The ID of the signal. @@ -12662,6 +12957,31 @@ export class SecurityMonitoringApi { }); } + /** + * Update one or more triage attributes of multiple security signals at once. + * The maximum number of signals that can be updated in a single request is 199. + * @param param The request object + */ + public bulkEditSecurityMonitoringSignals( + param: SecurityMonitoringApiBulkEditSecurityMonitoringSignalsRequest, + options?: Configuration + ): Promise { + const requestContextPromise = + this.requestFactory.bulkEditSecurityMonitoringSignals( + param.body, + options + ); + return requestContextPromise.then((requestContext) => { + return this.configuration.httpApi + .send(requestContext) + .then((responseContext) => { + return this.responseProcessor.bulkEditSecurityMonitoringSignals( + responseContext + ); + }); + }); + } + /** * Change the triage assignees of multiple security signals at once. * The maximum number of signals that can be updated in a single request is 199. @@ -13322,6 +13642,31 @@ export class SecurityMonitoringApi { }); } + /** + * Update one or more triage attributes of a security signal. + * @param param The request object + */ + public editSecurityMonitoringSignal( + param: SecurityMonitoringApiEditSecurityMonitoringSignalRequest, + options?: Configuration + ): Promise { + const requestContextPromise = + this.requestFactory.editSecurityMonitoringSignal( + param.signalId, + param.body, + options + ); + return requestContextPromise.then((requestContext) => { + return this.configuration.httpApi + .send(requestContext) + .then((responseContext) => { + return this.responseProcessor.editSecurityMonitoringSignal( + responseContext + ); + }); + }); + } + /** * Modify the triage assignee of a security signal. * @param param The request object diff --git a/packages/datadog-api-client-v2/index.ts b/packages/datadog-api-client-v2/index.ts index 0986f592f6af..7b8518c2aa23 100644 --- a/packages/datadog-api-client-v2/index.ts +++ b/packages/datadog-api-client-v2/index.ts @@ -1009,6 +1009,7 @@ export { SecurityMonitoringApiActivateContentPackRequest, SecurityMonitoringApiAttachCaseRequest, SecurityMonitoringApiAttachJiraIssueRequest, + SecurityMonitoringApiBulkEditSecurityMonitoringSignalsRequest, SecurityMonitoringApiBulkEditSecurityMonitoringSignalsAssigneeRequest, SecurityMonitoringApiBulkEditSecurityMonitoringSignalsStateRequest, SecurityMonitoringApiBulkExportSecurityMonitoringRulesRequest, @@ -1037,6 +1038,7 @@ export { SecurityMonitoringApiDeleteThreatHuntingJobRequest, SecurityMonitoringApiDeleteVulnerabilityNotificationRuleRequest, SecurityMonitoringApiDetachCaseRequest, + SecurityMonitoringApiEditSecurityMonitoringSignalRequest, SecurityMonitoringApiEditSecurityMonitoringSignalAssigneeRequest, SecurityMonitoringApiEditSecurityMonitoringSignalIncidentsRequest, SecurityMonitoringApiEditSecurityMonitoringSignalStateRequest, @@ -5386,6 +5388,8 @@ export { SecurityMonitoringSignalsBulkTriageEvent } from "./models/SecurityMonit export { SecurityMonitoringSignalsBulkTriageEventAttributes } from "./models/SecurityMonitoringSignalsBulkTriageEventAttributes"; export { SecurityMonitoringSignalsBulkTriageUpdateResponse } from "./models/SecurityMonitoringSignalsBulkTriageUpdateResponse"; export { SecurityMonitoringSignalsBulkTriageUpdateResult } from "./models/SecurityMonitoringSignalsBulkTriageUpdateResult"; +export { SecurityMonitoringSignalsBulkUpdateData } from "./models/SecurityMonitoringSignalsBulkUpdateData"; +export { SecurityMonitoringSignalsBulkUpdateRequest } from "./models/SecurityMonitoringSignalsBulkUpdateRequest"; export { SecurityMonitoringSignalsListResponse } from "./models/SecurityMonitoringSignalsListResponse"; export { SecurityMonitoringSignalsListResponseLinks } from "./models/SecurityMonitoringSignalsListResponseLinks"; export { SecurityMonitoringSignalsListResponseMeta } from "./models/SecurityMonitoringSignalsListResponseMeta"; @@ -5403,6 +5407,9 @@ export { SecurityMonitoringSignalTriageAttributes } from "./models/SecurityMonit export { SecurityMonitoringSignalTriageUpdateData } from "./models/SecurityMonitoringSignalTriageUpdateData"; export { SecurityMonitoringSignalTriageUpdateResponse } from "./models/SecurityMonitoringSignalTriageUpdateResponse"; export { SecurityMonitoringSignalType } from "./models/SecurityMonitoringSignalType"; +export { SecurityMonitoringSignalUpdateAttributes } from "./models/SecurityMonitoringSignalUpdateAttributes"; +export { SecurityMonitoringSignalUpdateData } from "./models/SecurityMonitoringSignalUpdateData"; +export { SecurityMonitoringSignalUpdateRequest } from "./models/SecurityMonitoringSignalUpdateRequest"; export { SecurityMonitoringSKU } from "./models/SecurityMonitoringSKU"; export { SecurityMonitoringStandardDataSource } from "./models/SecurityMonitoringStandardDataSource"; export { SecurityMonitoringStandardRuleCreatePayload } from "./models/SecurityMonitoringStandardRuleCreatePayload"; diff --git a/packages/datadog-api-client-v2/models/ObjectSerializer.ts b/packages/datadog-api-client-v2/models/ObjectSerializer.ts index 744b19969ac2..1ce9bca8ad2a 100644 --- a/packages/datadog-api-client-v2/models/ObjectSerializer.ts +++ b/packages/datadog-api-client-v2/models/ObjectSerializer.ts @@ -3080,6 +3080,9 @@ import { SecurityMonitoringSignalSuggestedActionsResponse } from "./SecurityMoni import { SecurityMonitoringSignalTriageAttributes } from "./SecurityMonitoringSignalTriageAttributes"; import { SecurityMonitoringSignalTriageUpdateData } from "./SecurityMonitoringSignalTriageUpdateData"; import { SecurityMonitoringSignalTriageUpdateResponse } from "./SecurityMonitoringSignalTriageUpdateResponse"; +import { SecurityMonitoringSignalUpdateAttributes } from "./SecurityMonitoringSignalUpdateAttributes"; +import { SecurityMonitoringSignalUpdateData } from "./SecurityMonitoringSignalUpdateData"; +import { SecurityMonitoringSignalUpdateRequest } from "./SecurityMonitoringSignalUpdateRequest"; import { SecurityMonitoringSignalsBulkAssigneeUpdateAttributes } from "./SecurityMonitoringSignalsBulkAssigneeUpdateAttributes"; import { SecurityMonitoringSignalsBulkAssigneeUpdateData } from "./SecurityMonitoringSignalsBulkAssigneeUpdateData"; import { SecurityMonitoringSignalsBulkAssigneeUpdateRequest } from "./SecurityMonitoringSignalsBulkAssigneeUpdateRequest"; @@ -3089,6 +3092,8 @@ import { SecurityMonitoringSignalsBulkTriageEvent } from "./SecurityMonitoringSi import { SecurityMonitoringSignalsBulkTriageEventAttributes } from "./SecurityMonitoringSignalsBulkTriageEventAttributes"; import { SecurityMonitoringSignalsBulkTriageUpdateResponse } from "./SecurityMonitoringSignalsBulkTriageUpdateResponse"; import { SecurityMonitoringSignalsBulkTriageUpdateResult } from "./SecurityMonitoringSignalsBulkTriageUpdateResult"; +import { SecurityMonitoringSignalsBulkUpdateData } from "./SecurityMonitoringSignalsBulkUpdateData"; +import { SecurityMonitoringSignalsBulkUpdateRequest } from "./SecurityMonitoringSignalsBulkUpdateRequest"; import { SecurityMonitoringSignalsListResponse } from "./SecurityMonitoringSignalsListResponse"; import { SecurityMonitoringSignalsListResponseLinks } from "./SecurityMonitoringSignalsListResponseLinks"; import { SecurityMonitoringSignalsListResponseMeta } from "./SecurityMonitoringSignalsListResponseMeta"; @@ -9867,6 +9872,10 @@ const typeMap: { [index: string]: any } = { SecurityMonitoringSignalTriageUpdateData, SecurityMonitoringSignalTriageUpdateResponse: SecurityMonitoringSignalTriageUpdateResponse, + SecurityMonitoringSignalUpdateAttributes: + SecurityMonitoringSignalUpdateAttributes, + SecurityMonitoringSignalUpdateData: SecurityMonitoringSignalUpdateData, + SecurityMonitoringSignalUpdateRequest: SecurityMonitoringSignalUpdateRequest, SecurityMonitoringSignalsBulkAssigneeUpdateAttributes: SecurityMonitoringSignalsBulkAssigneeUpdateAttributes, SecurityMonitoringSignalsBulkAssigneeUpdateData: @@ -9885,6 +9894,10 @@ const typeMap: { [index: string]: any } = { SecurityMonitoringSignalsBulkTriageUpdateResponse, SecurityMonitoringSignalsBulkTriageUpdateResult: SecurityMonitoringSignalsBulkTriageUpdateResult, + SecurityMonitoringSignalsBulkUpdateData: + SecurityMonitoringSignalsBulkUpdateData, + SecurityMonitoringSignalsBulkUpdateRequest: + SecurityMonitoringSignalsBulkUpdateRequest, SecurityMonitoringSignalsListResponse: SecurityMonitoringSignalsListResponse, SecurityMonitoringSignalsListResponseLinks: SecurityMonitoringSignalsListResponseLinks, diff --git a/packages/datadog-api-client-v2/models/SecurityMonitoringSignalUpdateAttributes.ts b/packages/datadog-api-client-v2/models/SecurityMonitoringSignalUpdateAttributes.ts new file mode 100644 index 000000000000..cb68cd1f6c83 --- /dev/null +++ b/packages/datadog-api-client-v2/models/SecurityMonitoringSignalUpdateAttributes.ts @@ -0,0 +1,87 @@ +/** + * Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. + * This product includes software developed at Datadog (https://www.datadoghq.com/). + * Copyright 2020-Present Datadog, Inc. + */ +import { SecurityMonitoringSignalArchiveReason } from "./SecurityMonitoringSignalArchiveReason"; +import { SecurityMonitoringSignalState } from "./SecurityMonitoringSignalState"; +import { SecurityMonitoringTriageUser } from "./SecurityMonitoringTriageUser"; + +import { AttributeTypeMap } from "../../datadog-api-client-common/util"; + +/** + * Attributes for updating one or more triage attributes of a security signal. + */ +export class SecurityMonitoringSignalUpdateAttributes { + /** + * Optional comment to display on archived signals. + */ + "archiveComment"?: string; + /** + * Reason a signal is archived. + */ + "archiveReason"?: SecurityMonitoringSignalArchiveReason; + /** + * Object representing a given user entity. + */ + "assignee"?: SecurityMonitoringTriageUser; + /** + * The new triage state of the signal. + */ + "state"?: SecurityMonitoringSignalState; + /** + * Version of the updated signal. If server side version is higher, update will be rejected. + */ + "version"?: number; + + /** + * A container for additional, undeclared properties. + * This is a holder for any undeclared properties as specified with + * the 'additionalProperties' keyword in the OAS document. + */ + "additionalProperties"?: { [key: string]: any }; + + /** + * @ignore + */ + "_unparsed"?: boolean; + + /** + * @ignore + */ + static readonly attributeTypeMap: AttributeTypeMap = { + archiveComment: { + baseName: "archive_comment", + type: "string", + }, + archiveReason: { + baseName: "archive_reason", + type: "SecurityMonitoringSignalArchiveReason", + }, + assignee: { + baseName: "assignee", + type: "SecurityMonitoringTriageUser", + }, + state: { + baseName: "state", + type: "SecurityMonitoringSignalState", + }, + version: { + baseName: "version", + type: "number", + }, + additionalProperties: { + baseName: "additionalProperties", + type: "{ [key: string]: any; }", + }, + }; + + /** + * @ignore + */ + static getAttributeTypeMap(): AttributeTypeMap { + return SecurityMonitoringSignalUpdateAttributes.attributeTypeMap; + } + + public constructor() {} +} diff --git a/packages/datadog-api-client-v2/models/SecurityMonitoringSignalUpdateData.ts b/packages/datadog-api-client-v2/models/SecurityMonitoringSignalUpdateData.ts new file mode 100644 index 000000000000..90d556882379 --- /dev/null +++ b/packages/datadog-api-client-v2/models/SecurityMonitoringSignalUpdateData.ts @@ -0,0 +1,63 @@ +/** + * Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. + * This product includes software developed at Datadog (https://www.datadoghq.com/). + * Copyright 2020-Present Datadog, Inc. + */ +import { SecurityMonitoringSignalMetadataType } from "./SecurityMonitoringSignalMetadataType"; +import { SecurityMonitoringSignalUpdateAttributes } from "./SecurityMonitoringSignalUpdateAttributes"; + +import { AttributeTypeMap } from "../../datadog-api-client-common/util"; + +/** + * Data containing the triage update for a security signal. + */ +export class SecurityMonitoringSignalUpdateData { + /** + * Attributes for updating one or more triage attributes of a security signal. + */ + "attributes": SecurityMonitoringSignalUpdateAttributes; + /** + * The type of event. + */ + "type"?: SecurityMonitoringSignalMetadataType; + + /** + * A container for additional, undeclared properties. + * This is a holder for any undeclared properties as specified with + * the 'additionalProperties' keyword in the OAS document. + */ + "additionalProperties"?: { [key: string]: any }; + + /** + * @ignore + */ + "_unparsed"?: boolean; + + /** + * @ignore + */ + static readonly attributeTypeMap: AttributeTypeMap = { + attributes: { + baseName: "attributes", + type: "SecurityMonitoringSignalUpdateAttributes", + required: true, + }, + type: { + baseName: "type", + type: "SecurityMonitoringSignalMetadataType", + }, + additionalProperties: { + baseName: "additionalProperties", + type: "{ [key: string]: any; }", + }, + }; + + /** + * @ignore + */ + static getAttributeTypeMap(): AttributeTypeMap { + return SecurityMonitoringSignalUpdateData.attributeTypeMap; + } + + public constructor() {} +} diff --git a/packages/datadog-api-client-v2/models/SecurityMonitoringSignalUpdateRequest.ts b/packages/datadog-api-client-v2/models/SecurityMonitoringSignalUpdateRequest.ts new file mode 100644 index 000000000000..6e171b721d2c --- /dev/null +++ b/packages/datadog-api-client-v2/models/SecurityMonitoringSignalUpdateRequest.ts @@ -0,0 +1,54 @@ +/** + * Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. + * This product includes software developed at Datadog (https://www.datadoghq.com/). + * Copyright 2020-Present Datadog, Inc. + */ +import { SecurityMonitoringSignalUpdateData } from "./SecurityMonitoringSignalUpdateData"; + +import { AttributeTypeMap } from "../../datadog-api-client-common/util"; + +/** + * Request body for updating the triage attributes of a security signal. + */ +export class SecurityMonitoringSignalUpdateRequest { + /** + * Data containing the triage update for a security signal. + */ + "data": SecurityMonitoringSignalUpdateData; + + /** + * A container for additional, undeclared properties. + * This is a holder for any undeclared properties as specified with + * the 'additionalProperties' keyword in the OAS document. + */ + "additionalProperties"?: { [key: string]: any }; + + /** + * @ignore + */ + "_unparsed"?: boolean; + + /** + * @ignore + */ + static readonly attributeTypeMap: AttributeTypeMap = { + data: { + baseName: "data", + type: "SecurityMonitoringSignalUpdateData", + required: true, + }, + additionalProperties: { + baseName: "additionalProperties", + type: "{ [key: string]: any; }", + }, + }; + + /** + * @ignore + */ + static getAttributeTypeMap(): AttributeTypeMap { + return SecurityMonitoringSignalUpdateRequest.attributeTypeMap; + } + + public constructor() {} +} diff --git a/packages/datadog-api-client-v2/models/SecurityMonitoringSignalsBulkUpdateData.ts b/packages/datadog-api-client-v2/models/SecurityMonitoringSignalsBulkUpdateData.ts new file mode 100644 index 000000000000..55eef80f5132 --- /dev/null +++ b/packages/datadog-api-client-v2/models/SecurityMonitoringSignalsBulkUpdateData.ts @@ -0,0 +1,72 @@ +/** + * Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. + * This product includes software developed at Datadog (https://www.datadoghq.com/). + * Copyright 2020-Present Datadog, Inc. + */ +import { SecurityMonitoringSignalType } from "./SecurityMonitoringSignalType"; +import { SecurityMonitoringSignalUpdateAttributes } from "./SecurityMonitoringSignalUpdateAttributes"; + +import { AttributeTypeMap } from "../../datadog-api-client-common/util"; + +/** + * Data for updating a single security signal in a bulk update operation. + */ +export class SecurityMonitoringSignalsBulkUpdateData { + /** + * Attributes for updating one or more triage attributes of a security signal. + */ + "attributes": SecurityMonitoringSignalUpdateAttributes; + /** + * The unique ID of the security signal. + */ + "id": string; + /** + * The type of event. + */ + "type"?: SecurityMonitoringSignalType; + + /** + * A container for additional, undeclared properties. + * This is a holder for any undeclared properties as specified with + * the 'additionalProperties' keyword in the OAS document. + */ + "additionalProperties"?: { [key: string]: any }; + + /** + * @ignore + */ + "_unparsed"?: boolean; + + /** + * @ignore + */ + static readonly attributeTypeMap: AttributeTypeMap = { + attributes: { + baseName: "attributes", + type: "SecurityMonitoringSignalUpdateAttributes", + required: true, + }, + id: { + baseName: "id", + type: "string", + required: true, + }, + type: { + baseName: "type", + type: "SecurityMonitoringSignalType", + }, + additionalProperties: { + baseName: "additionalProperties", + type: "{ [key: string]: any; }", + }, + }; + + /** + * @ignore + */ + static getAttributeTypeMap(): AttributeTypeMap { + return SecurityMonitoringSignalsBulkUpdateData.attributeTypeMap; + } + + public constructor() {} +} diff --git a/packages/datadog-api-client-v2/models/SecurityMonitoringSignalsBulkUpdateRequest.ts b/packages/datadog-api-client-v2/models/SecurityMonitoringSignalsBulkUpdateRequest.ts new file mode 100644 index 000000000000..52f41be2a103 --- /dev/null +++ b/packages/datadog-api-client-v2/models/SecurityMonitoringSignalsBulkUpdateRequest.ts @@ -0,0 +1,54 @@ +/** + * Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. + * This product includes software developed at Datadog (https://www.datadoghq.com/). + * Copyright 2020-Present Datadog, Inc. + */ +import { SecurityMonitoringSignalsBulkUpdateData } from "./SecurityMonitoringSignalsBulkUpdateData"; + +import { AttributeTypeMap } from "../../datadog-api-client-common/util"; + +/** + * Request body for updating multiple attributes of multiple security signals. + */ +export class SecurityMonitoringSignalsBulkUpdateRequest { + /** + * An array of signal updates. + */ + "data": Array; + + /** + * A container for additional, undeclared properties. + * This is a holder for any undeclared properties as specified with + * the 'additionalProperties' keyword in the OAS document. + */ + "additionalProperties"?: { [key: string]: any }; + + /** + * @ignore + */ + "_unparsed"?: boolean; + + /** + * @ignore + */ + static readonly attributeTypeMap: AttributeTypeMap = { + data: { + baseName: "data", + type: "Array", + required: true, + }, + additionalProperties: { + baseName: "additionalProperties", + type: "{ [key: string]: any; }", + }, + }; + + /** + * @ignore + */ + static getAttributeTypeMap(): AttributeTypeMap { + return SecurityMonitoringSignalsBulkUpdateRequest.attributeTypeMap; + } + + public constructor() {} +}