From e02c1725e15bff98ab8a49bb8ed042e4a94c2333 Mon Sep 17 00:00:00 2001 From: "ci.datadog-api-spec" Date: Mon, 21 Sep 2026 17:28:54 +0000 Subject: [PATCH] Regenerate client from commit a160e5f of spec repo --- .generator/schemas/v2/openapi.yaml | 119 +++++++++++++ .../security-monitoring/GetMatchingSignals.ts | 23 +++ features/support/scenarios_model_mapping.ts | 11 ++ features/v2/security_monitoring.feature | 27 +++ features/v2/undo.json | 6 + .../configuration.ts | 1 + .../apis/SecurityMonitoringApi.ts | 159 ++++++++++++++++++ packages/datadog-api-client-v2/index.ts | 5 + .../models/MatchingSignalAttributes.ts | 81 +++++++++ .../models/MatchingSignalData.ts | 73 ++++++++ .../models/MatchingSignalType.ts | 14 ++ .../models/MatchingSignalsResponse.ts | 54 ++++++ .../models/ObjectSerializer.ts | 7 + 13 files changed, 580 insertions(+) create mode 100644 examples/v2/security-monitoring/GetMatchingSignals.ts create mode 100644 packages/datadog-api-client-v2/models/MatchingSignalAttributes.ts create mode 100644 packages/datadog-api-client-v2/models/MatchingSignalData.ts create mode 100644 packages/datadog-api-client-v2/models/MatchingSignalType.ts create mode 100644 packages/datadog-api-client-v2/models/MatchingSignalsResponse.ts diff --git a/.generator/schemas/v2/openapi.yaml b/.generator/schemas/v2/openapi.yaml index 81f698c5f321..70a13b03863d 100644 --- a/.generator/schemas/v2/openapi.yaml +++ b/.generator/schemas/v2/openapi.yaml @@ -68731,6 +68731,68 @@ components: type: string x-enum-varnames: - MANAGED_ORGS + MatchingSignalAttributes: + description: Attributes of a matching security signal. + properties: + event_tracker_id: + description: The tracker ID linking the signal back to the originating event. Distinct from `id`, which identifies the matching signal itself. + example: AAAAAWgOAX0mtsWfeQAAAABzX1RyYWNrZXJfMTIzNDU2Nzg5MA + type: string + severity: + description: The severity of the signal. + example: high + type: string + title: + description: The title of the signal. + example: Unusual login activity detected + type: string + trigger_time_ms: + description: The Unix timestamp (in milliseconds) at which the signal was triggered. + example: 1707393746000 + format: int64 + type: integer + required: + - event_tracker_id + - severity + - title + - trigger_time_ms + type: object + MatchingSignalData: + description: A security signal that matches the queried event. + properties: + attributes: + $ref: "#/components/schemas/MatchingSignalAttributes" + id: + description: The ID of the matching signal. + example: AAAAAWgN8Xwgr1vKDQAAAABBV2dOOFh3ZzZobm1mWXJFYTR0OA + type: string + type: + $ref: "#/components/schemas/MatchingSignalType" + required: + - id + - type + - attributes + type: object + MatchingSignalType: + default: matching_signal + description: The type of the resource. The value should always be `matching_signal`. + enum: + - matching_signal + example: matching_signal + type: string + x-enum-varnames: + - MATCHING_SIGNAL + MatchingSignalsResponse: + description: Response containing the list of security signals matching an event. + properties: + data: + description: Array of matching signals. + items: + $ref: "#/components/schemas/MatchingSignalData" + type: array + required: + - data + type: object MaxSessionDurationType: description: Data type of a maximum session duration update. enum: [max_session_duration] @@ -211106,6 +211168,63 @@ paths: x-unstable: |- **Note**: This endpoint is in Preview and is subject to change. If you have any feedback, contact [Datadog support](https://docs.datadoghq.com/help/). + /api/v2/security_monitoring/events/{event_id}/matching_signals: + get: + description: Returns the list of security signals that match a given event on the given track. + operationId: GetMatchingSignals + parameters: + - description: The ID of the event to find matching signals for. + in: path + name: event_id + required: true + schema: + type: string + - description: The product track that the event belongs to. + in: query + name: track + required: true + schema: + type: string + responses: + "200": + content: + application/json: + examples: + default: + value: + data: + - attributes: + event_tracker_id: AAAAAWgOAX0mtsWfeQAAAABzX1RyYWNrZXJfMTIzNDU2Nzg5MA + severity: high + title: Unusual login activity detected + trigger_time_ms: 1707393746000 + id: AAAAAWgN8Xwgr1vKDQAAAABBV2dOOFh3ZzZobm1mWXJFYTR0OA + type: matching_signal + schema: + $ref: "#/components/schemas/MatchingSignalsResponse" + 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 signals matching an event + tags: ["Security Monitoring"] + x-permission: + operator: OR + permissions: + - security_monitoring_signals_read + x-unstable: |- + **Note**: This endpoint is in preview and is subject to change. + If you have any feedback, contact [Datadog support](https://docs.datadoghq.com/help/). /api/v2/security_monitoring/rules: get: description: List rules. diff --git a/examples/v2/security-monitoring/GetMatchingSignals.ts b/examples/v2/security-monitoring/GetMatchingSignals.ts new file mode 100644 index 000000000000..7d4c90ce61b0 --- /dev/null +++ b/examples/v2/security-monitoring/GetMatchingSignals.ts @@ -0,0 +1,23 @@ +/** + * Get signals matching an event returns "OK" response + */ + +import { client, v2 } from "@datadog/datadog-api-client"; + +const configuration = client.createConfiguration(); +configuration.unstableOperations["v2.getMatchingSignals"] = true; +const apiInstance = new v2.SecurityMonitoringApi(configuration); + +const params: v2.SecurityMonitoringApiGetMatchingSignalsRequest = { + eventId: "event_id", + track: "track", +}; + +apiInstance + .getMatchingSignals(params) + .then((data: v2.MatchingSignalsResponse) => { + 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 0e2e788530f6..3c24dac6a25f 100644 --- a/features/support/scenarios_model_mapping.ts +++ b/features/support/scenarios_model_mapping.ts @@ -7189,6 +7189,17 @@ export const ScenariosModelMappings: {[key: string]: {[key: string]: any}} = { }, "operationResponseType": "SingleEntityContextResponse", }, + "v2.GetMatchingSignals": { + "eventId": { + "type": "string", + "format": "", + }, + "track": { + "type": "string", + "format": "", + }, + "operationResponseType": "MatchingSignalsResponse", + }, "v2.ListSecurityMonitoringRules": { "pageSize": { "type": "number", diff --git a/features/v2/security_monitoring.feature b/features/v2/security_monitoring.feature index a72d703edd34..bb21f193462b 100644 --- a/features/v2/security_monitoring.feature +++ b/features/v2/security_monitoring.feature @@ -2532,6 +2532,33 @@ Feature: Security Monitoring When the request is sent Then the response status is 200 OK + @generated @skip @team:DataDog/cloud-siem + Scenario: Get signals matching an event returns "Bad Request" response + Given operation "GetMatchingSignals" enabled + And new "GetMatchingSignals" request + And request contains "event_id" parameter from "REPLACE.ME" + And request contains "track" parameter from "REPLACE.ME" + When the request is sent + Then the response status is 400 Bad Request + + @generated @skip @team:DataDog/cloud-siem + Scenario: Get signals matching an event returns "Not Found" response + Given operation "GetMatchingSignals" enabled + And new "GetMatchingSignals" request + And request contains "event_id" parameter from "REPLACE.ME" + And request contains "track" parameter from "REPLACE.ME" + When the request is sent + Then the response status is 404 Not Found + + @generated @skip @team:DataDog/cloud-siem + Scenario: Get signals matching an event returns "OK" response + Given operation "GetMatchingSignals" enabled + And new "GetMatchingSignals" request + And request contains "event_id" parameter from "REPLACE.ME" + And request contains "track" parameter from "REPLACE.ME" + When the request is sent + Then the response status is 200 OK + @generated @skip @team:DataDog/cloud-siem Scenario: Get suggested actions for a signal returns "Not Found" response Given new "GetSuggestedActionsMatchingSignal" request diff --git a/features/v2/undo.json b/features/v2/undo.json index 1abefe2e9ed3..316bfc290bba 100644 --- a/features/v2/undo.json +++ b/features/v2/undo.json @@ -8745,6 +8745,12 @@ "type": "safe" } }, + "GetMatchingSignals": { + "tag": "Security Monitoring", + "undo": { + "type": "safe" + } + }, "ListSecurityMonitoringRules": { "tag": "Security Monitoring", "undo": { diff --git a/packages/datadog-api-client-common/configuration.ts b/packages/datadog-api-client-common/configuration.ts index 1b32eb217b52..5febe4e01e78 100644 --- a/packages/datadog-api-client-common/configuration.ts +++ b/packages/datadog-api-client-common/configuration.ts @@ -378,6 +378,7 @@ export function createConfiguration( "v2.getFinding": false, "v2.getHistoricalJob": false, "v2.getIndicatorOfCompromise": false, + "v2.getMatchingSignals": false, "v2.getRuleVersionHistory": false, "v2.getSecretsRules": false, "v2.getSecurityFindingsAutomationDefaultInboxRule": false, diff --git a/packages/datadog-api-client-v2/apis/SecurityMonitoringApi.ts b/packages/datadog-api-client-v2/apis/SecurityMonitoringApi.ts index 42297cd6f66f..8956e6ac03b3 100644 --- a/packages/datadog-api-client-v2/apis/SecurityMonitoringApi.ts +++ b/packages/datadog-api-client-v2/apis/SecurityMonitoringApi.ts @@ -84,6 +84,7 @@ import { ListHistoricalJobsResponse } from "../models/ListHistoricalJobsResponse import { ListSecurityFindingsResponse } from "../models/ListSecurityFindingsResponse"; import { ListVulnerabilitiesResponse } from "../models/ListVulnerabilitiesResponse"; import { ListVulnerableAssetsResponse } from "../models/ListVulnerableAssetsResponse"; +import { MatchingSignalsResponse } from "../models/MatchingSignalsResponse"; import { MuteFindingsRequest } from "../models/MuteFindingsRequest"; import { MuteFindingsResponse } from "../models/MuteFindingsResponse"; import { MuteRuleCreateRequest } from "../models/MuteRuleCreateRequest"; @@ -4371,6 +4372,66 @@ export class SecurityMonitoringApiRequestFactory extends BaseAPIRequestFactory { return requestContext; } + public async getMatchingSignals( + eventId: string, + track: string, + _options?: Configuration + ): Promise { + const _config = _options || this.configuration; + + logger.warn("Using unstable operation 'getMatchingSignals'"); + if (!_config.unstableOperations["v2.getMatchingSignals"]) { + throw new Error("Unstable operation 'getMatchingSignals' is disabled"); + } + + // verify required parameter 'eventId' is not null or undefined + if (eventId === null || eventId === undefined) { + throw new RequiredError("eventId", "getMatchingSignals"); + } + + // verify required parameter 'track' is not null or undefined + if (track === null || track === undefined) { + throw new RequiredError("track", "getMatchingSignals"); + } + + // Path Params + const localVarPath = + "/api/v2/security_monitoring/events/{event_id}/matching_signals".replace( + "{event_id}", + encodeURIComponent(String(eventId)) + ); + + // Make Request Context + const requestContext = _config + .getServer("v2.SecurityMonitoringApi.getMatchingSignals") + .makeRequestContext(localVarPath, HttpMethod.GET); + requestContext.setHeaderParam("Accept", "application/json"); + requestContext.setHttpConfig(_config.httpConfig); + + // Set IaC header + if (_config.isIaC) { + requestContext.setHeaderParam("X-Datadog-Managed-By", "iac"); + } + + // Query Params + if (track !== undefined) { + requestContext.setQueryParam( + "track", + ObjectSerializer.serialize(track, "string", ""), + "" + ); + } + + // Apply auth methods + applySecurityAuthentication(_config, requestContext, [ + "apiKeyAuth", + "appKeyAuth", + "AuthZ", + ]); + + return requestContext; + } + public async getResourceEvaluationFilters( cloudProvider?: string, accountId?: string, @@ -15572,6 +15633,69 @@ 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 getMatchingSignals + * @throws ApiException if the response code was not in [200, 299] + */ + public async getMatchingSignals( + response: ResponseContext + ): Promise { + const contentType = ObjectSerializer.normalizeMediaType( + response.headers["content-type"] + ); + if (response.httpStatusCode === 200) { + const body: MatchingSignalsResponse = ObjectSerializer.deserialize( + ObjectSerializer.parse(await response.body.text(), contentType), + "MatchingSignalsResponse" + ) as MatchingSignalsResponse; + 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: MatchingSignalsResponse = ObjectSerializer.deserialize( + ObjectSerializer.parse(await response.body.text(), contentType), + "MatchingSignalsResponse", + "" + ) as MatchingSignalsResponse; + 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 @@ -22843,6 +22967,19 @@ export interface SecurityMonitoringApiGetInvestigationLogQueriesMatchingSignalRe signalId: string; } +export interface SecurityMonitoringApiGetMatchingSignalsRequest { + /** + * The ID of the event to find matching signals for. + * @type string + */ + eventId: string; + /** + * The product track that the event belongs to. + * @type string + */ + track: string; +} + export interface SecurityMonitoringApiGetResourceEvaluationFiltersRequest { /** * Filter resource filters by cloud provider (e.g. aws, gcp, azure). @@ -26214,6 +26351,28 @@ export class SecurityMonitoringApi { }); } + /** + * Returns the list of security signals that match a given event on the given track. + * @param param The request object + */ + public getMatchingSignals( + param: SecurityMonitoringApiGetMatchingSignalsRequest, + options?: Configuration + ): Promise { + const requestContextPromise = this.requestFactory.getMatchingSignals( + param.eventId, + param.track, + options + ); + return requestContextPromise.then((requestContext) => { + return this.configuration.httpApi + .send(requestContext) + .then((responseContext) => { + return this.responseProcessor.getMatchingSignals(responseContext); + }); + }); + } + /** * List resource filters. * @param param The request object diff --git a/packages/datadog-api-client-v2/index.ts b/packages/datadog-api-client-v2/index.ts index d208335cb5a9..a6b3cbe50b59 100644 --- a/packages/datadog-api-client-v2/index.ts +++ b/packages/datadog-api-client-v2/index.ts @@ -1572,6 +1572,7 @@ export { SecurityMonitoringApiGetHistoricalJobRequest, SecurityMonitoringApiGetIndicatorOfCompromiseRequest, SecurityMonitoringApiGetInvestigationLogQueriesMatchingSignalRequest, + SecurityMonitoringApiGetMatchingSignalsRequest, SecurityMonitoringApiGetResourceEvaluationFiltersRequest, SecurityMonitoringApiGetRuleVersionHistoryRequest, SecurityMonitoringApiGetSBOMRequest, @@ -6056,6 +6057,10 @@ export { ManagedOrgsRelationshipToOrg } from "./models/ManagedOrgsRelationshipTo export { ManagedOrgsRelationshipToOrgs } from "./models/ManagedOrgsRelationshipToOrgs"; export { ManagedOrgsResponse } from "./models/ManagedOrgsResponse"; export { ManagedOrgsType } from "./models/ManagedOrgsType"; +export { MatchingSignalAttributes } from "./models/MatchingSignalAttributes"; +export { MatchingSignalData } from "./models/MatchingSignalData"; +export { MatchingSignalsResponse } from "./models/MatchingSignalsResponse"; +export { MatchingSignalType } from "./models/MatchingSignalType"; export { MaxSessionDurationType } from "./models/MaxSessionDurationType"; export { MaxSessionDurationUpdateAttributes } from "./models/MaxSessionDurationUpdateAttributes"; export { MaxSessionDurationUpdateData } from "./models/MaxSessionDurationUpdateData"; diff --git a/packages/datadog-api-client-v2/models/MatchingSignalAttributes.ts b/packages/datadog-api-client-v2/models/MatchingSignalAttributes.ts new file mode 100644 index 000000000000..195f67efce74 --- /dev/null +++ b/packages/datadog-api-client-v2/models/MatchingSignalAttributes.ts @@ -0,0 +1,81 @@ +/** + * 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 { AttributeTypeMap } from "../../datadog-api-client-common/util"; + +/** + * Attributes of a matching security signal. + */ +export class MatchingSignalAttributes { + /** + * The tracker ID linking the signal back to the originating event. Distinct from `id`, which identifies the matching signal itself. + */ + "eventTrackerId": string; + /** + * The severity of the signal. + */ + "severity": string; + /** + * The title of the signal. + */ + "title": string; + /** + * The Unix timestamp (in milliseconds) at which the signal was triggered. + */ + "triggerTimeMs": 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 = { + eventTrackerId: { + baseName: "event_tracker_id", + type: "string", + required: true, + }, + severity: { + baseName: "severity", + type: "string", + required: true, + }, + title: { + baseName: "title", + type: "string", + required: true, + }, + triggerTimeMs: { + baseName: "trigger_time_ms", + type: "number", + required: true, + format: "int64", + }, + additionalProperties: { + baseName: "additionalProperties", + type: "{ [key: string]: any; }", + }, + }; + + /** + * @ignore + */ + static getAttributeTypeMap(): AttributeTypeMap { + return MatchingSignalAttributes.attributeTypeMap; + } + + public constructor() {} +} diff --git a/packages/datadog-api-client-v2/models/MatchingSignalData.ts b/packages/datadog-api-client-v2/models/MatchingSignalData.ts new file mode 100644 index 000000000000..6b1a46303eda --- /dev/null +++ b/packages/datadog-api-client-v2/models/MatchingSignalData.ts @@ -0,0 +1,73 @@ +/** + * 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 { MatchingSignalAttributes } from "./MatchingSignalAttributes"; +import { MatchingSignalType } from "./MatchingSignalType"; + +import { AttributeTypeMap } from "../../datadog-api-client-common/util"; + +/** + * A security signal that matches the queried event. + */ +export class MatchingSignalData { + /** + * Attributes of a matching security signal. + */ + "attributes": MatchingSignalAttributes; + /** + * The ID of the matching signal. + */ + "id": string; + /** + * The type of the resource. The value should always be `matching_signal`. + */ + "type": MatchingSignalType; + + /** + * 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: "MatchingSignalAttributes", + required: true, + }, + id: { + baseName: "id", + type: "string", + required: true, + }, + type: { + baseName: "type", + type: "MatchingSignalType", + required: true, + }, + additionalProperties: { + baseName: "additionalProperties", + type: "{ [key: string]: any; }", + }, + }; + + /** + * @ignore + */ + static getAttributeTypeMap(): AttributeTypeMap { + return MatchingSignalData.attributeTypeMap; + } + + public constructor() {} +} diff --git a/packages/datadog-api-client-v2/models/MatchingSignalType.ts b/packages/datadog-api-client-v2/models/MatchingSignalType.ts new file mode 100644 index 000000000000..c2e86118792f --- /dev/null +++ b/packages/datadog-api-client-v2/models/MatchingSignalType.ts @@ -0,0 +1,14 @@ +/** + * 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 { UnparsedObject } from "../../datadog-api-client-common/util"; + +/** + * The type of the resource. The value should always be `matching_signal`. + */ + +export type MatchingSignalType = typeof MATCHING_SIGNAL | UnparsedObject; +export const MATCHING_SIGNAL = "matching_signal"; diff --git a/packages/datadog-api-client-v2/models/MatchingSignalsResponse.ts b/packages/datadog-api-client-v2/models/MatchingSignalsResponse.ts new file mode 100644 index 000000000000..850f8ae4ce10 --- /dev/null +++ b/packages/datadog-api-client-v2/models/MatchingSignalsResponse.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 { MatchingSignalData } from "./MatchingSignalData"; + +import { AttributeTypeMap } from "../../datadog-api-client-common/util"; + +/** + * Response containing the list of security signals matching an event. + */ +export class MatchingSignalsResponse { + /** + * Array of matching signals. + */ + "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 MatchingSignalsResponse.attributeTypeMap; + } + + public constructor() {} +} diff --git a/packages/datadog-api-client-v2/models/ObjectSerializer.ts b/packages/datadog-api-client-v2/models/ObjectSerializer.ts index d1ea28c8af37..0709c425b725 100644 --- a/packages/datadog-api-client-v2/models/ObjectSerializer.ts +++ b/packages/datadog-api-client-v2/models/ObjectSerializer.ts @@ -3203,6 +3203,9 @@ import { ManagedOrgsRelationshipToOrg } from "./ManagedOrgsRelationshipToOrg"; import { ManagedOrgsRelationshipToOrgs } from "./ManagedOrgsRelationshipToOrgs"; import { ManagedOrgsRelationships } from "./ManagedOrgsRelationships"; import { ManagedOrgsResponse } from "./ManagedOrgsResponse"; +import { MatchingSignalAttributes } from "./MatchingSignalAttributes"; +import { MatchingSignalData } from "./MatchingSignalData"; +import { MatchingSignalsResponse } from "./MatchingSignalsResponse"; import { MaxSessionDurationUpdateAttributes } from "./MaxSessionDurationUpdateAttributes"; import { MaxSessionDurationUpdateData } from "./MaxSessionDurationUpdateData"; import { MaxSessionDurationUpdateRequest } from "./MaxSessionDurationUpdateRequest"; @@ -7586,6 +7589,7 @@ const enumsMap: { [key: string]: any[] } = { ], MaintenanceWindowResourceType: ["maintenance_window"], ManagedOrgsType: ["managed_orgs"], + MatchingSignalType: ["matching_signal"], MaxSessionDurationType: ["max_session_duration"], McpScanRequestDataType: ["mcpscanrequest"], McpScanRequestResponseDataType: ["mcpscanrequestresponse"], @@ -13299,6 +13303,9 @@ const typeMap: { [index: string]: any } = { ManagedOrgsRelationshipToOrgs: ManagedOrgsRelationshipToOrgs, ManagedOrgsRelationships: ManagedOrgsRelationships, ManagedOrgsResponse: ManagedOrgsResponse, + MatchingSignalAttributes: MatchingSignalAttributes, + MatchingSignalData: MatchingSignalData, + MatchingSignalsResponse: MatchingSignalsResponse, MaxSessionDurationUpdateAttributes: MaxSessionDurationUpdateAttributes, MaxSessionDurationUpdateData: MaxSessionDurationUpdateData, MaxSessionDurationUpdateRequest: MaxSessionDurationUpdateRequest,