@datadog/datadog-api-client 1.12.0 → 1.14.0

package/dist/packages/datadog-api-client-v2/apis/SecurityMonitoringApi.d.ts

@@ -1,6 +1,13 @@
 import { BaseAPIRequestFactory } from "../../datadog-api-client-common/baseapi";
 import { Configuration } from "../../datadog-api-client-common/configuration";
 import { RequestContext, ResponseContext } from "../../datadog-api-client-common/http/http";
+import { Finding } from "../models/Finding";
+import { FindingEvaluation } from "../models/FindingEvaluation";
+import { FindingStatus } from "../models/FindingStatus";
+import { GetFindingResponse } from "../models/GetFindingResponse";
+import { ListFindingsResponse } from "../models/ListFindingsResponse";
+import { MuteFindingRequest } from "../models/MuteFindingRequest";
+import { MuteFindingResponse } from "../models/MuteFindingResponse";
 import { SecurityFilterCreateRequest } from "../models/SecurityFilterCreateRequest";
 import { SecurityFilterResponse } from "../models/SecurityFilterResponse";
 import { SecurityFiltersResponse } from "../models/SecurityFiltersResponse";
@@ -25,13 +32,16 @@ export declare class SecurityMonitoringApiRequestFactory extends BaseAPIRequestF
     editSecurityMonitoringSignalAssignee(signalId: string, body: SecurityMonitoringSignalAssigneeUpdateRequest, _options?: Configuration): Promise<RequestContext>;
     editSecurityMonitoringSignalIncidents(signalId: string, body: SecurityMonitoringSignalIncidentsUpdateRequest, _options?: Configuration): Promise<RequestContext>;
     editSecurityMonitoringSignalState(signalId: string, body: SecurityMonitoringSignalStateUpdateRequest, _options?: Configuration): Promise<RequestContext>;
+    getFinding(findingId: string, snapshotTimestamp?: number, _options?: Configuration): Promise<RequestContext>;
     getSecurityFilter(securityFilterId: string, _options?: Configuration): Promise<RequestContext>;
     getSecurityMonitoringRule(ruleId: string, _options?: Configuration): Promise<RequestContext>;
     getSecurityMonitoringSignal(signalId: string, _options?: Configuration): Promise<RequestContext>;
+    listFindings(pageLimit?: number, snapshotTimestamp?: number, pageCursor?: string, filterTags?: string, filterEvaluationChangedAt?: string, filterMuted?: boolean, filterRuleId?: string, filterRuleName?: string, filterResourceType?: string, filterDiscoveryTimestamp?: string, filterEvaluation?: FindingEvaluation, filterStatus?: FindingStatus, _options?: Configuration): Promise<RequestContext>;
     listSecurityFilters(_options?: Configuration): Promise<RequestContext>;
     listSecurityMonitoringRules(pageSize?: number, pageNumber?: number, _options?: Configuration): Promise<RequestContext>;
     listSecurityMonitoringSignals(filterQuery?: string, filterFrom?: Date, filterTo?: Date, sort?: SecurityMonitoringSignalsSort, pageCursor?: string, pageLimit?: number, _options?: Configuration): Promise<RequestContext>;
     searchSecurityMonitoringSignals(body?: SecurityMonitoringSignalListRequest, _options?: Configuration): Promise<RequestContext>;
+    updateFinding(findingId: string, body: MuteFindingRequest, _options?: Configuration): Promise<RequestContext>;
     updateSecurityFilter(securityFilterId: string, body: SecurityFilterUpdateRequest, _options?: Configuration): Promise<RequestContext>;
     updateSecurityMonitoringRule(ruleId: string, body: SecurityMonitoringRuleUpdatePayload, _options?: Configuration): Promise<RequestContext>;
 }
@@ -92,6 +102,14 @@ export declare class SecurityMonitoringApiResponseProcessor {
      * @throws ApiException if the response code was not in [200, 299]
      */
     editSecurityMonitoringSignalState(response: ResponseContext): Promise<SecurityMonitoringSignalTriageUpdateResponse>;
+    /**
+     * 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 getFinding
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+    getFinding(response: ResponseContext): Promise<GetFindingResponse>;
     /**
      * Unwraps the actual response sent by the server from the response context and deserializes the response content
      * to the expected objects
@@ -116,6 +134,14 @@ export declare class SecurityMonitoringApiResponseProcessor {
      * @throws ApiException if the response code was not in [200, 299]
      */
     getSecurityMonitoringSignal(response: ResponseContext): Promise<SecurityMonitoringSignal>;
+    /**
+     * 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 listFindings
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+    listFindings(response: ResponseContext): Promise<ListFindingsResponse>;
     /**
      * Unwraps the actual response sent by the server from the response context and deserializes the response content
      * to the expected objects
@@ -148,6 +174,14 @@ export declare class SecurityMonitoringApiResponseProcessor {
      * @throws ApiException if the response code was not in [200, 299]
      */
     searchSecurityMonitoringSignals(response: ResponseContext): Promise<SecurityMonitoringSignalsListResponse>;
+    /**
+     * 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 updateFinding
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+    updateFinding(response: ResponseContext): Promise<MuteFindingResponse>;
     /**
      * Unwraps the actual response sent by the server from the response context and deserializes the response content
      * to the expected objects
@@ -228,6 +262,18 @@ export interface SecurityMonitoringApiEditSecurityMonitoringSignalStateRequest {
      */
     body: SecurityMonitoringSignalStateUpdateRequest;
 }
+export interface SecurityMonitoringApiGetFindingRequest {
+    /**
+     * The ID of the finding.
+     * @type string
+     */
+    findingId: string;
+    /**
+     * Return the finding for a given snapshot of time (Unix ms).
+     * @type number
+     */
+    snapshotTimestamp?: number;
+}
 export interface SecurityMonitoringApiGetSecurityFilterRequest {
     /**
      * The ID of the security filter.
@@ -249,9 +295,71 @@ export interface SecurityMonitoringApiGetSecurityMonitoringSignalRequest {
      */
     signalId: string;
 }
+export interface SecurityMonitoringApiListFindingsRequest {
+    /**
+     * Limit the number of findings returned. Must be <= 1000.
+     * @type number
+     */
+    pageLimit?: number;
+    /**
+     * Return findings for a given snapshot of time (Unix ms).
+     * @type number
+     */
+    snapshotTimestamp?: number;
+    /**
+     * Return the next page of findings pointed to by the cursor.
+     * @type string
+     */
+    pageCursor?: string;
+    /**
+     * Return findings that have these associated tags (repeatable).
+     * @type string
+     */
+    filterTags?: string;
+    /**
+     * Return findings that have changed from pass to fail or vice versa on a specified date (Unix ms) or date range (using comparison operators).
+     * @type string
+     */
+    filterEvaluationChangedAt?: string;
+    /**
+     * Set to `true` to return findings that are muted. Set to `false` to return unmuted findings.
+     * @type boolean
+     */
+    filterMuted?: boolean;
+    /**
+     * Return findings for the specified rule ID.
+     * @type string
+     */
+    filterRuleId?: string;
+    /**
+     * Return findings for the specified rule.
+     * @type string
+     */
+    filterRuleName?: string;
+    /**
+     * Return only findings for the specified resource type.
+     * @type string
+     */
+    filterResourceType?: string;
+    /**
+     * Return findings that were found on a specified date (Unix ms) or date range (using comparison operators).
+     * @type string
+     */
+    filterDiscoveryTimestamp?: string;
+    /**
+     * Return only `pass` or `fail` findings.
+     * @type FindingEvaluation
+     */
+    filterEvaluation?: FindingEvaluation;
+    /**
+     * Return only findings with the specified status.
+     * @type FindingStatus
+     */
+    filterStatus?: FindingStatus;
+}
 export interface SecurityMonitoringApiListSecurityMonitoringRulesRequest {
     /**
-     * Size for a given page. The maximum allowed value is 5000.
+     * Size for a given page. The maximum allowed value is 100.
      * @type number
      */
     pageSize?: number;
@@ -299,6 +407,20 @@ export interface SecurityMonitoringApiSearchSecurityMonitoringSignalsRequest {
      */
     body?: SecurityMonitoringSignalListRequest;
 }
+export interface SecurityMonitoringApiUpdateFindingRequest {
+    /**
+     * The ID of the finding.
+     * @type string
+     */
+    findingId: string;
+    /**
+     * To mute or unmute a finding, the request body should include at least two attributes: `muted` and `reason`. The allowed reasons depend on whether the finding is being muted or unmuted:
+     * - To mute a finding: `PENDING_FIX`, `FALSE_POSITIVE`, `ACCEPTED_RISK`, `OTHER`.
+     * - To unmute a finding : `NO_PENDING_FIX`, `HUMAN_ERROR`, `NO_LONGER_ACCEPTED_RISK`, `OTHER`.
+     * @type MuteFindingRequest
+     */
+    body: MuteFindingRequest;
+}
 export interface SecurityMonitoringApiUpdateSecurityFilterRequest {
     /**
      * The ID of the security filter.
@@ -365,6 +487,11 @@ export declare class SecurityMonitoringApi {
      * @param param The request object
      */
     editSecurityMonitoringSignalState(param: SecurityMonitoringApiEditSecurityMonitoringSignalStateRequest, options?: Configuration): Promise<SecurityMonitoringSignalTriageUpdateResponse>;
+    /**
+     * Returns a single finding with message and resource configuration.
+     * @param param The request object
+     */
+    getFinding(param: SecurityMonitoringApiGetFindingRequest, options?: Configuration): Promise<GetFindingResponse>;
     /**
      * Get the details of a specific security filter.
      *
@@ -383,6 +510,44 @@ export declare class SecurityMonitoringApi {
      * @param param The request object
      */
     getSecurityMonitoringSignal(param: SecurityMonitoringApiGetSecurityMonitoringSignalRequest, options?: Configuration): Promise<SecurityMonitoringSignal>;
+    /**
+     * Get a list of CSPM findings.
+     *
+     * ### Filtering
+     *
+     * Filters can be applied by appending query parameters to the URL.
+     *
+     *   - Using a single filter: `?filter[attribute_key]=attribute_value`
+     *   - Chaining filters: `?filter[attribute_key]=attribute_value&filter[attribute_key]=attribute_value...`
+     *   - Filtering on tags: `?filter[tags]=tag_key:tag_value&filter[tags]=tag_key_2:tag_value_2`
+     *
+     * Here, `attribute_key` can be any of the filter keys described further below.
+     *
+     * Query parameters of type `integer` support comparison operators (`>`, `>=`, `<`, `<=`). This is particularly useful when filtering by `evaluation_changed_at` or `resource_discovery_timestamp`. For example: `?filter[evaluation_changed_at]=>20123123121`.
+     *
+     * You can also use the negation operator on strings. For example, use `filter[resource_type]=-aws*` to filter for any non-AWS resources.
+     *
+     * The operator must come after the equal sign. For example, to filter with the `>=` operator, add the operator after the equal sign: `filter[evaluation_changed_at]=>=1678809373257`.
+     *
+     * Query parameters must be only among the documented ones and with values of correct types. Duplicated query parameters (e.g. `filter[status]=low&filter[status]=info`) are not allowed.
+     *
+     * ### Response
+     *
+     * The response includes an array of finding objects, pagination metadata, and a count of items that match the query.
+     *
+     * Each finding object contains the following:
+     *
+     * - The finding ID that can be used in a `GetFinding` request to retrieve the full finding details.
+     * - Core attributes, including status, evaluation, high-level resource details, muted state, and rule details.
+     * - `evaluation_changed_at` and `resource_discovery_date` time stamps.
+     * - An array of associated tags.
+     * @param param The request object
+     */
+    listFindings(param?: SecurityMonitoringApiListFindingsRequest, options?: Configuration): Promise<ListFindingsResponse>;
+    /**
+     * Provide a paginated version of listFindings returning a generator with all the items.
+     */
+    listFindingsWithPagination(param?: SecurityMonitoringApiListFindingsRequest, options?: Configuration): AsyncGenerator<Finding>;
     /**
      * Get the list of configured security filters with their definitions.
      * @param param The request object
@@ -415,6 +580,12 @@ export declare class SecurityMonitoringApi {
      * Provide a paginated version of searchSecurityMonitoringSignals returning a generator with all the items.
      */
     searchSecurityMonitoringSignalsWithPagination(param?: SecurityMonitoringApiSearchSecurityMonitoringSignalsRequest, options?: Configuration): AsyncGenerator<SecurityMonitoringSignal>;
+    /**
+     * Mute or unmute a specific finding.
+     * The API returns the updated finding object when the request is successful.
+     * @param param The request object
+     */
+    updateFinding(param: SecurityMonitoringApiUpdateFindingRequest, options?: Configuration): Promise<MuteFindingResponse>;
     /**
      * Update a specific security filter.
      * Returns the security filter object when the request is successful.

package/dist/packages/datadog-api-client-v2/apis/SecurityMonitoringApi.js

@@ -229,6 +229,36 @@ class SecurityMonitoringApiRequestFactory extends baseapi_1.BaseAPIRequestFactor
             return requestContext;
         });
     }
+    getFinding(findingId, snapshotTimestamp, _options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const _config = _options || this.configuration;
+            logger_1.logger.warn("Using unstable operation 'getFinding'");
+            if (!_config.unstableOperations["v2.getFinding"]) {
+                throw new Error("Unstable operation 'getFinding' is disabled");
+            }
+            // verify required parameter 'findingId' is not null or undefined
+            if (findingId === null || findingId === undefined) {
+                throw new baseapi_1.RequiredError("findingId", "getFinding");
+            }
+            // Path Params
+            const localVarPath = "/api/v2/posture_management/findings/{finding_id}".replace("{finding_id}", encodeURIComponent(String(findingId)));
+            // Make Request Context
+            const requestContext = (0, configuration_1.getServer)(_config, "v2.SecurityMonitoringApi.getFinding").makeRequestContext(localVarPath, http_1.HttpMethod.GET);
+            requestContext.setHeaderParam("Accept", "application/json");
+            requestContext.setHttpConfig(_config.httpConfig);
+            // Query Params
+            if (snapshotTimestamp !== undefined) {
+                requestContext.setQueryParam("snapshot_timestamp", ObjectSerializer_1.ObjectSerializer.serialize(snapshotTimestamp, "number", "int64"));
+            }
+            // Apply auth methods
+            (0, configuration_1.applySecurityAuthentication)(_config, requestContext, [
+                "AuthZ",
+                "apiKeyAuth",
+                "appKeyAuth",
+            ]);
+            return requestContext;
+        });
+    }
     getSecurityFilter(securityFilterId, _options) {
         return __awaiter(this, void 0, void 0, function* () {
             const _config = _options || this.configuration;
@@ -295,6 +325,65 @@ class SecurityMonitoringApiRequestFactory extends baseapi_1.BaseAPIRequestFactor
             return requestContext;
         });
     }
+    listFindings(pageLimit, snapshotTimestamp, pageCursor, filterTags, filterEvaluationChangedAt, filterMuted, filterRuleId, filterRuleName, filterResourceType, filterDiscoveryTimestamp, filterEvaluation, filterStatus, _options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const _config = _options || this.configuration;
+            logger_1.logger.warn("Using unstable operation 'listFindings'");
+            if (!_config.unstableOperations["v2.listFindings"]) {
+                throw new Error("Unstable operation 'listFindings' is disabled");
+            }
+            // Path Params
+            const localVarPath = "/api/v2/posture_management/findings";
+            // Make Request Context
+            const requestContext = (0, configuration_1.getServer)(_config, "v2.SecurityMonitoringApi.listFindings").makeRequestContext(localVarPath, http_1.HttpMethod.GET);
+            requestContext.setHeaderParam("Accept", "application/json");
+            requestContext.setHttpConfig(_config.httpConfig);
+            // Query Params
+            if (pageLimit !== undefined) {
+                requestContext.setQueryParam("page[limit]", ObjectSerializer_1.ObjectSerializer.serialize(pageLimit, "number", "int64"));
+            }
+            if (snapshotTimestamp !== undefined) {
+                requestContext.setQueryParam("snapshot_timestamp", ObjectSerializer_1.ObjectSerializer.serialize(snapshotTimestamp, "number", "int64"));
+            }
+            if (pageCursor !== undefined) {
+                requestContext.setQueryParam("page[cursor]", ObjectSerializer_1.ObjectSerializer.serialize(pageCursor, "string", ""));
+            }
+            if (filterTags !== undefined) {
+                requestContext.setQueryParam("filter[tags]", ObjectSerializer_1.ObjectSerializer.serialize(filterTags, "string", ""));
+            }
+            if (filterEvaluationChangedAt !== undefined) {
+                requestContext.setQueryParam("filter[evaluation_changed_at]", ObjectSerializer_1.ObjectSerializer.serialize(filterEvaluationChangedAt, "string", ""));
+            }
+            if (filterMuted !== undefined) {
+                requestContext.setQueryParam("filter[muted]", ObjectSerializer_1.ObjectSerializer.serialize(filterMuted, "boolean", ""));
+            }
+            if (filterRuleId !== undefined) {
+                requestContext.setQueryParam("filter[rule_id]", ObjectSerializer_1.ObjectSerializer.serialize(filterRuleId, "string", ""));
+            }
+            if (filterRuleName !== undefined) {
+                requestContext.setQueryParam("filter[rule_name]", ObjectSerializer_1.ObjectSerializer.serialize(filterRuleName, "string", ""));
+            }
+            if (filterResourceType !== undefined) {
+                requestContext.setQueryParam("filter[resource_type]", ObjectSerializer_1.ObjectSerializer.serialize(filterResourceType, "string", ""));
+            }
+            if (filterDiscoveryTimestamp !== undefined) {
+                requestContext.setQueryParam("filter[discovery_timestamp]", ObjectSerializer_1.ObjectSerializer.serialize(filterDiscoveryTimestamp, "string", ""));
+            }
+            if (filterEvaluation !== undefined) {
+                requestContext.setQueryParam("filter[evaluation]", ObjectSerializer_1.ObjectSerializer.serialize(filterEvaluation, "FindingEvaluation", ""));
+            }
+            if (filterStatus !== undefined) {
+                requestContext.setQueryParam("filter[status]", ObjectSerializer_1.ObjectSerializer.serialize(filterStatus, "FindingStatus", ""));
+            }
+            // Apply auth methods
+            (0, configuration_1.applySecurityAuthentication)(_config, requestContext, [
+                "AuthZ",
+                "apiKeyAuth",
+                "appKeyAuth",
+            ]);
+            return requestContext;
+        });
+    }
     listSecurityFilters(_options) {
         return __awaiter(this, void 0, void 0, function* () {
             const _config = _options || this.configuration;
@@ -400,6 +489,43 @@ class SecurityMonitoringApiRequestFactory extends baseapi_1.BaseAPIRequestFactor
             return requestContext;
         });
     }
+    updateFinding(findingId, body, _options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const _config = _options || this.configuration;
+            logger_1.logger.warn("Using unstable operation 'updateFinding'");
+            if (!_config.unstableOperations["v2.updateFinding"]) {
+                throw new Error("Unstable operation 'updateFinding' is disabled");
+            }
+            // verify required parameter 'findingId' is not null or undefined
+            if (findingId === null || findingId === undefined) {
+                throw new baseapi_1.RequiredError("findingId", "updateFinding");
+            }
+            // verify required parameter 'body' is not null or undefined
+            if (body === null || body === undefined) {
+                throw new baseapi_1.RequiredError("body", "updateFinding");
+            }
+            // Path Params
+            const localVarPath = "/api/v2/posture_management/findings/{finding_id}".replace("{finding_id}", encodeURIComponent(String(findingId)));
+            // Make Request Context
+            const requestContext = (0, configuration_1.getServer)(_config, "v2.SecurityMonitoringApi.updateFinding").makeRequestContext(localVarPath, http_1.HttpMethod.PATCH);
+            requestContext.setHeaderParam("Accept", "application/json");
+            requestContext.setHttpConfig(_config.httpConfig);
+            // Body Params
+            const contentType = ObjectSerializer_1.ObjectSerializer.getPreferredMediaType([
+                "application/json",
+            ]);
+            requestContext.setHeaderParam("Content-Type", contentType);
+            const serializedBody = ObjectSerializer_1.ObjectSerializer.stringify(ObjectSerializer_1.ObjectSerializer.serialize(body, "MuteFindingRequest", ""), contentType);
+            requestContext.setBody(serializedBody);
+            // Apply auth methods
+            (0, configuration_1.applySecurityAuthentication)(_config, requestContext, [
+                "AuthZ",
+                "apiKeyAuth",
+                "appKeyAuth",
+            ]);
+            return requestContext;
+        });
+    }
     updateSecurityFilter(securityFilterId, body, _options) {
         return __awaiter(this, void 0, void 0, function* () {
             const _config = _options || this.configuration;
@@ -730,6 +856,44 @@ class SecurityMonitoringApiResponseProcessor {
             throw new exception_1.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 getFinding
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+    getFinding(response) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const contentType = ObjectSerializer_1.ObjectSerializer.normalizeMediaType(response.headers["content-type"]);
+            if (response.httpStatusCode == 200) {
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "GetFindingResponse");
+                return body;
+            }
+            if (response.httpStatusCode == 400 ||
+                response.httpStatusCode == 403 ||
+                response.httpStatusCode == 404 ||
+                response.httpStatusCode == 429) {
+                const bodyText = ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType);
+                let body;
+                try {
+                    body = ObjectSerializer_1.ObjectSerializer.deserialize(bodyText, "JSONAPIErrorResponse");
+                }
+                catch (error) {
+                    logger_1.logger.info(`Got error deserializing error: ${error}`);
+                    throw new exception_1.ApiException(response.httpStatusCode, bodyText);
+                }
+                throw new exception_1.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 = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "GetFindingResponse", "");
+                return body;
+            }
+            const body = (yield response.body.text()) || "";
+            throw new exception_1.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
@@ -837,6 +1001,44 @@ class SecurityMonitoringApiResponseProcessor {
             throw new exception_1.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 listFindings
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+    listFindings(response) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const contentType = ObjectSerializer_1.ObjectSerializer.normalizeMediaType(response.headers["content-type"]);
+            if (response.httpStatusCode == 200) {
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "ListFindingsResponse");
+                return body;
+            }
+            if (response.httpStatusCode == 400 ||
+                response.httpStatusCode == 403 ||
+                response.httpStatusCode == 404 ||
+                response.httpStatusCode == 429) {
+                const bodyText = ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType);
+                let body;
+                try {
+                    body = ObjectSerializer_1.ObjectSerializer.deserialize(bodyText, "JSONAPIErrorResponse");
+                }
+                catch (error) {
+                    logger_1.logger.info(`Got error deserializing error: ${error}`);
+                    throw new exception_1.ApiException(response.httpStatusCode, bodyText);
+                }
+                throw new exception_1.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 = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "ListFindingsResponse", "");
+                return body;
+            }
+            const body = (yield response.body.text()) || "";
+            throw new exception_1.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
@@ -981,6 +1183,46 @@ class SecurityMonitoringApiResponseProcessor {
             throw new exception_1.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 updateFinding
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+    updateFinding(response) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const contentType = ObjectSerializer_1.ObjectSerializer.normalizeMediaType(response.headers["content-type"]);
+            if (response.httpStatusCode == 200) {
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "MuteFindingResponse");
+                return body;
+            }
+            if (response.httpStatusCode == 400 ||
+                response.httpStatusCode == 403 ||
+                response.httpStatusCode == 404 ||
+                response.httpStatusCode == 409 ||
+                response.httpStatusCode == 422 ||
+                response.httpStatusCode == 429) {
+                const bodyText = ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType);
+                let body;
+                try {
+                    body = ObjectSerializer_1.ObjectSerializer.deserialize(bodyText, "JSONAPIErrorResponse");
+                }
+                catch (error) {
+                    logger_1.logger.info(`Got error deserializing error: ${error}`);
+                    throw new exception_1.ApiException(response.httpStatusCode, bodyText);
+                }
+                throw new exception_1.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 = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "MuteFindingResponse", "");
+                return body;
+            }
+            const body = (yield response.body.text()) || "";
+            throw new exception_1.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
@@ -1170,6 +1412,20 @@ class SecurityMonitoringApi {
             });
         });
     }
+    /**
+     * Returns a single finding with message and resource configuration.
+     * @param param The request object
+     */
+    getFinding(param, options) {
+        const requestContextPromise = this.requestFactory.getFinding(param.findingId, param.snapshotTimestamp, options);
+        return requestContextPromise.then((requestContext) => {
+            return this.configuration.httpApi
+                .send(requestContext)
+                .then((responseContext) => {
+                return this.responseProcessor.getFinding(responseContext);
+            });
+        });
+    }
     /**
      * Get the details of a specific security filter.
      *
@@ -1215,6 +1471,90 @@ class SecurityMonitoringApi {
             });
         });
     }
+    /**
+     * Get a list of CSPM findings.
+     *
+     * ### Filtering
+     *
+     * Filters can be applied by appending query parameters to the URL.
+     *
+     *   - Using a single filter: `?filter[attribute_key]=attribute_value`
+     *   - Chaining filters: `?filter[attribute_key]=attribute_value&filter[attribute_key]=attribute_value...`
+     *   - Filtering on tags: `?filter[tags]=tag_key:tag_value&filter[tags]=tag_key_2:tag_value_2`
+     *
+     * Here, `attribute_key` can be any of the filter keys described further below.
+     *
+     * Query parameters of type `integer` support comparison operators (`>`, `>=`, `<`, `<=`). This is particularly useful when filtering by `evaluation_changed_at` or `resource_discovery_timestamp`. For example: `?filter[evaluation_changed_at]=>20123123121`.
+     *
+     * You can also use the negation operator on strings. For example, use `filter[resource_type]=-aws*` to filter for any non-AWS resources.
+     *
+     * The operator must come after the equal sign. For example, to filter with the `>=` operator, add the operator after the equal sign: `filter[evaluation_changed_at]=>=1678809373257`.
+     *
+     * Query parameters must be only among the documented ones and with values of correct types. Duplicated query parameters (e.g. `filter[status]=low&filter[status]=info`) are not allowed.
+     *
+     * ### Response
+     *
+     * The response includes an array of finding objects, pagination metadata, and a count of items that match the query.
+     *
+     * Each finding object contains the following:
+     *
+     * - The finding ID that can be used in a `GetFinding` request to retrieve the full finding details.
+     * - Core attributes, including status, evaluation, high-level resource details, muted state, and rule details.
+     * - `evaluation_changed_at` and `resource_discovery_date` time stamps.
+     * - An array of associated tags.
+     * @param param The request object
+     */
+    listFindings(param = {}, options) {
+        const requestContextPromise = this.requestFactory.listFindings(param.pageLimit, param.snapshotTimestamp, param.pageCursor, param.filterTags, param.filterEvaluationChangedAt, param.filterMuted, param.filterRuleId, param.filterRuleName, param.filterResourceType, param.filterDiscoveryTimestamp, param.filterEvaluation, param.filterStatus, options);
+        return requestContextPromise.then((requestContext) => {
+            return this.configuration.httpApi
+                .send(requestContext)
+                .then((responseContext) => {
+                return this.responseProcessor.listFindings(responseContext);
+            });
+        });
+    }
+    /**
+     * Provide a paginated version of listFindings returning a generator with all the items.
+     */
+    listFindingsWithPagination(param = {}, options) {
+        return __asyncGenerator(this, arguments, function* listFindingsWithPagination_1() {
+            let pageSize = 100;
+            if (param.pageLimit !== undefined) {
+                pageSize = param.pageLimit;
+            }
+            param.pageLimit = pageSize;
+            while (true) {
+                const requestContext = yield __await(this.requestFactory.listFindings(param.pageLimit, param.snapshotTimestamp, param.pageCursor, param.filterTags, param.filterEvaluationChangedAt, param.filterMuted, param.filterRuleId, param.filterRuleName, param.filterResourceType, param.filterDiscoveryTimestamp, param.filterEvaluation, param.filterStatus, options));
+                const responseContext = yield __await(this.configuration.httpApi.send(requestContext));
+                const response = yield __await(this.responseProcessor.listFindings(responseContext));
+                const responseData = response.data;
+                if (responseData === undefined) {
+                    break;
+                }
+                const results = responseData;
+                for (const item of results) {
+                    yield yield __await(item);
+                }
+                if (results.length < pageSize) {
+                    break;
+                }
+                const cursorMeta = response.meta;
+                if (cursorMeta === undefined) {
+                    break;
+                }
+                const cursorMetaPage = cursorMeta.page;
+                if (cursorMetaPage === undefined) {
+                    break;
+                }
+                const cursorMetaPageCursor = cursorMetaPage.cursor;
+                if (cursorMetaPageCursor === undefined) {
+                    break;
+                }
+                param.pageCursor = cursorMetaPageCursor;
+            }
+        });
+    }
     /**
      * Get the list of configured security filters with their definitions.
      * @param param The request object
@@ -1363,6 +1703,21 @@ class SecurityMonitoringApi {
             }
         });
     }
+    /**
+     * Mute or unmute a specific finding.
+     * The API returns the updated finding object when the request is successful.
+     * @param param The request object
+     */
+    updateFinding(param, options) {
+        const requestContextPromise = this.requestFactory.updateFinding(param.findingId, param.body, options);
+        return requestContextPromise.then((requestContext) => {
+            return this.configuration.httpApi
+                .send(requestContext)
+                .then((responseContext) => {
+                return this.responseProcessor.updateFinding(responseContext);
+            });
+        });
+    }
     /**
      * Update a specific security filter.
      * Returns the security filter object when the request is successful.