@aws-sdk/client-cloudwatch-logs 3.454.0 → 3.460.0

package/dist-types/commands/CreateLogAnomalyDetectorCommand.d.ts

@@ -0,0 +1,129 @@
+import { EndpointParameterInstructions } from "@smithy/middleware-endpoint";
+import { Command as $Command } from "@smithy/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@smithy/types";
+import { CloudWatchLogsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudWatchLogsClient";
+import { CreateLogAnomalyDetectorRequest, CreateLogAnomalyDetectorResponse } from "../models/models_0";
+/**
+ * @public
+ */
+export { __MetadataBearer, $Command };
+/**
+ * @public
+ *
+ * The input for {@link CreateLogAnomalyDetectorCommand}.
+ */
+export interface CreateLogAnomalyDetectorCommandInput extends CreateLogAnomalyDetectorRequest {
+}
+/**
+ * @public
+ *
+ * The output of {@link CreateLogAnomalyDetectorCommand}.
+ */
+export interface CreateLogAnomalyDetectorCommandOutput extends CreateLogAnomalyDetectorResponse, __MetadataBearer {
+}
+/**
+ * @public
+ * <p>Creates an <i>anomaly detector</i> that regularly scans one or more
+ *         log groups and look for patterns
+ *       and anomalies in the logs.</p>
+ *          <p>An anomaly detector can help surface issues by automatically discovering anomalies in your log event traffic.
+ *        An anomaly detector uses machine learning algorithms to scan log events and find <i>patterns</i>.
+ *
+ *        A pattern is a shared text structure that recurs among your log fields.  Patterns provide a useful tool for
+ *        analyzing large sets of logs because a large number of log events can often be
+ *        compressed into a few patterns.</p>
+ *          <p>The anomaly detector uses pattern recognition to find <code>anomalies</code>, which are unusual log
+ *        events. It uses the <code>evaluationFrequency</code> to compare current log events and patterns
+ *        with trained baselines. </p>
+ *          <p>Fields within a pattern are called <i>tokens</i>.
+ *        Fields that vary within a pattern, such as a
+ *        request ID or timestamp, are referred to as <i>dynamic tokens</i> and
+ *        represented by <code><*></code>. </p>
+ *          <p>The following is an example of a pattern:</p>
+ *          <p>
+ *             <code>[INFO] Request time: <*> ms</code>
+ *          </p>
+ *          <p>This pattern
+ *        represents log events like <code>[INFO] Request time: 327 ms</code> and other similar log events
+ *        that differ only by the number, in this csse 327. When the pattern is displayed, the different numbers are replaced
+ *        by <code><*></code>
+ *          </p>
+ *          <note>
+ *             <p>Any parts of log events that are masked as sensitive data are not scanned for anomalies. For more information
+ *      about masking sensitive data, see
+ *      <a href="https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/mask-sensitive-log-data.html">Help protect sensitive log data with
+ *      masking</a>.
+ *    </p>
+ *          </note>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CloudWatchLogsClient, CreateLogAnomalyDetectorCommand } from "@aws-sdk/client-cloudwatch-logs"; // ES Modules import
+ * // const { CloudWatchLogsClient, CreateLogAnomalyDetectorCommand } = require("@aws-sdk/client-cloudwatch-logs"); // CommonJS import
+ * const client = new CloudWatchLogsClient(config);
+ * const input = { // CreateLogAnomalyDetectorRequest
+ *   logGroupArnList: [ // LogGroupArnList // required
+ *     "STRING_VALUE",
+ *   ],
+ *   detectorName: "STRING_VALUE",
+ *   evaluationFrequency: "ONE_MIN" || "FIVE_MIN" || "TEN_MIN" || "FIFTEEN_MIN" || "THIRTY_MIN" || "ONE_HOUR",
+ *   filterPattern: "STRING_VALUE",
+ *   kmsKeyId: "STRING_VALUE",
+ *   anomalyVisibilityTime: Number("long"),
+ *   tags: { // Tags
+ *     "<keys>": "STRING_VALUE",
+ *   },
+ * };
+ * const command = new CreateLogAnomalyDetectorCommand(input);
+ * const response = await client.send(command);
+ * // { // CreateLogAnomalyDetectorResponse
+ * //   anomalyDetectorArn: "STRING_VALUE",
+ * // };
+ *
+ * ```
+ *
+ * @param CreateLogAnomalyDetectorCommandInput - {@link CreateLogAnomalyDetectorCommandInput}
+ * @returns {@link CreateLogAnomalyDetectorCommandOutput}
+ * @see {@link CreateLogAnomalyDetectorCommandInput} for command's `input` shape.
+ * @see {@link CreateLogAnomalyDetectorCommandOutput} for command's `response` shape.
+ * @see {@link CloudWatchLogsClientResolvedConfig | config} for CloudWatchLogsClient's `config` shape.
+ *
+ * @throws {@link InvalidParameterException} (client fault)
+ *  <p>A parameter is specified incorrectly.</p>
+ *
+ * @throws {@link LimitExceededException} (client fault)
+ *  <p>You have reached the maximum number of resources that can be created.</p>
+ *
+ * @throws {@link OperationAbortedException} (client fault)
+ *  <p>Multiple concurrent requests to update the same resource were in conflict.</p>
+ *
+ * @throws {@link ResourceNotFoundException} (client fault)
+ *  <p>The specified resource does not exist.</p>
+ *
+ * @throws {@link ServiceUnavailableException} (server fault)
+ *  <p>The service cannot complete the request.</p>
+ *
+ * @throws {@link CloudWatchLogsServiceException}
+ * <p>Base exception class for all service exceptions from CloudWatchLogs service.</p>
+ *
+ */
+export declare class CreateLogAnomalyDetectorCommand extends $Command<CreateLogAnomalyDetectorCommandInput, CreateLogAnomalyDetectorCommandOutput, CloudWatchLogsClientResolvedConfig> {
+    readonly input: CreateLogAnomalyDetectorCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
+    constructor(input: CreateLogAnomalyDetectorCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudWatchLogsClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateLogAnomalyDetectorCommandInput, CreateLogAnomalyDetectorCommandOutput>;
+    /**
+     * @internal
+     */
+    private serialize;
+    /**
+     * @internal
+     */
+    private deserialize;
+}

package/dist-types/commands/CreateLogGroupCommand.d.ts

@@ -64,6 +64,7 @@ export interface CreateLogGroupCommandOutput extends __MetadataBearer {
  *   tags: { // Tags
  *     "<keys>": "STRING_VALUE",
  *   },
+ *   logGroupClass: "STANDARD" || "INFREQUENT_ACCESS",
  * };
  * const command = new CreateLogGroupCommand(input);
  * const response = await client.send(command);

package/dist-types/commands/DeleteLogAnomalyDetectorCommand.d.ts

@@ -0,0 +1,83 @@
+import { EndpointParameterInstructions } from "@smithy/middleware-endpoint";
+import { Command as $Command } from "@smithy/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@smithy/types";
+import { CloudWatchLogsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudWatchLogsClient";
+import { DeleteLogAnomalyDetectorRequest } from "../models/models_0";
+/**
+ * @public
+ */
+export { __MetadataBearer, $Command };
+/**
+ * @public
+ *
+ * The input for {@link DeleteLogAnomalyDetectorCommand}.
+ */
+export interface DeleteLogAnomalyDetectorCommandInput extends DeleteLogAnomalyDetectorRequest {
+}
+/**
+ * @public
+ *
+ * The output of {@link DeleteLogAnomalyDetectorCommand}.
+ */
+export interface DeleteLogAnomalyDetectorCommandOutput extends __MetadataBearer {
+}
+/**
+ * @public
+ * <p>Deletes the specified CloudWatch Logs anomaly detector.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CloudWatchLogsClient, DeleteLogAnomalyDetectorCommand } from "@aws-sdk/client-cloudwatch-logs"; // ES Modules import
+ * // const { CloudWatchLogsClient, DeleteLogAnomalyDetectorCommand } = require("@aws-sdk/client-cloudwatch-logs"); // CommonJS import
+ * const client = new CloudWatchLogsClient(config);
+ * const input = { // DeleteLogAnomalyDetectorRequest
+ *   anomalyDetectorArn: "STRING_VALUE", // required
+ * };
+ * const command = new DeleteLogAnomalyDetectorCommand(input);
+ * const response = await client.send(command);
+ * // {};
+ *
+ * ```
+ *
+ * @param DeleteLogAnomalyDetectorCommandInput - {@link DeleteLogAnomalyDetectorCommandInput}
+ * @returns {@link DeleteLogAnomalyDetectorCommandOutput}
+ * @see {@link DeleteLogAnomalyDetectorCommandInput} for command's `input` shape.
+ * @see {@link DeleteLogAnomalyDetectorCommandOutput} for command's `response` shape.
+ * @see {@link CloudWatchLogsClientResolvedConfig | config} for CloudWatchLogsClient's `config` shape.
+ *
+ * @throws {@link InvalidParameterException} (client fault)
+ *  <p>A parameter is specified incorrectly.</p>
+ *
+ * @throws {@link OperationAbortedException} (client fault)
+ *  <p>Multiple concurrent requests to update the same resource were in conflict.</p>
+ *
+ * @throws {@link ResourceNotFoundException} (client fault)
+ *  <p>The specified resource does not exist.</p>
+ *
+ * @throws {@link ServiceUnavailableException} (server fault)
+ *  <p>The service cannot complete the request.</p>
+ *
+ * @throws {@link CloudWatchLogsServiceException}
+ * <p>Base exception class for all service exceptions from CloudWatchLogs service.</p>
+ *
+ */
+export declare class DeleteLogAnomalyDetectorCommand extends $Command<DeleteLogAnomalyDetectorCommandInput, DeleteLogAnomalyDetectorCommandOutput, CloudWatchLogsClientResolvedConfig> {
+    readonly input: DeleteLogAnomalyDetectorCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
+    constructor(input: DeleteLogAnomalyDetectorCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudWatchLogsClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteLogAnomalyDetectorCommandInput, DeleteLogAnomalyDetectorCommandOutput>;
+    /**
+     * @internal
+     */
+    private serialize;
+    /**
+     * @internal
+     */
+    private deserialize;
+}

package/dist-types/commands/DescribeLogGroupsCommand.d.ts

@@ -50,6 +50,7 @@ export interface DescribeLogGroupsCommandOutput extends DescribeLogGroupsRespons
  *   nextToken: "STRING_VALUE",
  *   limit: Number("int"),
  *   includeLinkedAccounts: true || false,
+ *   logGroupClass: "STANDARD" || "INFREQUENT_ACCESS",
  * };
  * const command = new DescribeLogGroupsCommand(input);
  * const response = await client.send(command);
@@ -67,6 +68,7 @@ export interface DescribeLogGroupsCommandOutput extends DescribeLogGroupsRespons
  * //       inheritedProperties: [ // InheritedProperties
  * //         "ACCOUNT_DATA_PROTECTION",
  * //       ],
+ * //       logGroupClass: "STANDARD" || "INFREQUENT_ACCESS",
  * //     },
  * //   ],
  * //   nextToken: "STRING_VALUE",

package/dist-types/commands/GetLogAnomalyDetectorCommand.d.ts

@@ -0,0 +1,95 @@
+import { EndpointParameterInstructions } from "@smithy/middleware-endpoint";
+import { Command as $Command } from "@smithy/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@smithy/types";
+import { CloudWatchLogsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudWatchLogsClient";
+import { GetLogAnomalyDetectorRequest, GetLogAnomalyDetectorResponse } from "../models/models_0";
+/**
+ * @public
+ */
+export { __MetadataBearer, $Command };
+/**
+ * @public
+ *
+ * The input for {@link GetLogAnomalyDetectorCommand}.
+ */
+export interface GetLogAnomalyDetectorCommandInput extends GetLogAnomalyDetectorRequest {
+}
+/**
+ * @public
+ *
+ * The output of {@link GetLogAnomalyDetectorCommand}.
+ */
+export interface GetLogAnomalyDetectorCommandOutput extends GetLogAnomalyDetectorResponse, __MetadataBearer {
+}
+/**
+ * @public
+ * <p>Retrieves information about the log anomaly detector that you specify.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CloudWatchLogsClient, GetLogAnomalyDetectorCommand } from "@aws-sdk/client-cloudwatch-logs"; // ES Modules import
+ * // const { CloudWatchLogsClient, GetLogAnomalyDetectorCommand } = require("@aws-sdk/client-cloudwatch-logs"); // CommonJS import
+ * const client = new CloudWatchLogsClient(config);
+ * const input = { // GetLogAnomalyDetectorRequest
+ *   anomalyDetectorArn: "STRING_VALUE", // required
+ * };
+ * const command = new GetLogAnomalyDetectorCommand(input);
+ * const response = await client.send(command);
+ * // { // GetLogAnomalyDetectorResponse
+ * //   detectorName: "STRING_VALUE",
+ * //   logGroupArnList: [ // LogGroupArnList
+ * //     "STRING_VALUE",
+ * //   ],
+ * //   evaluationFrequency: "ONE_MIN" || "FIVE_MIN" || "TEN_MIN" || "FIFTEEN_MIN" || "THIRTY_MIN" || "ONE_HOUR",
+ * //   filterPattern: "STRING_VALUE",
+ * //   anomalyDetectorStatus: "INITIALIZING" || "TRAINING" || "ANALYZING" || "FAILED" || "DELETED" || "PAUSED",
+ * //   kmsKeyId: "STRING_VALUE",
+ * //   creationTimeStamp: Number("long"),
+ * //   lastModifiedTimeStamp: Number("long"),
+ * //   anomalyVisibilityTime: Number("long"),
+ * // };
+ *
+ * ```
+ *
+ * @param GetLogAnomalyDetectorCommandInput - {@link GetLogAnomalyDetectorCommandInput}
+ * @returns {@link GetLogAnomalyDetectorCommandOutput}
+ * @see {@link GetLogAnomalyDetectorCommandInput} for command's `input` shape.
+ * @see {@link GetLogAnomalyDetectorCommandOutput} for command's `response` shape.
+ * @see {@link CloudWatchLogsClientResolvedConfig | config} for CloudWatchLogsClient's `config` shape.
+ *
+ * @throws {@link InvalidParameterException} (client fault)
+ *  <p>A parameter is specified incorrectly.</p>
+ *
+ * @throws {@link OperationAbortedException} (client fault)
+ *  <p>Multiple concurrent requests to update the same resource were in conflict.</p>
+ *
+ * @throws {@link ResourceNotFoundException} (client fault)
+ *  <p>The specified resource does not exist.</p>
+ *
+ * @throws {@link ServiceUnavailableException} (server fault)
+ *  <p>The service cannot complete the request.</p>
+ *
+ * @throws {@link CloudWatchLogsServiceException}
+ * <p>Base exception class for all service exceptions from CloudWatchLogs service.</p>
+ *
+ */
+export declare class GetLogAnomalyDetectorCommand extends $Command<GetLogAnomalyDetectorCommandInput, GetLogAnomalyDetectorCommandOutput, CloudWatchLogsClientResolvedConfig> {
+    readonly input: GetLogAnomalyDetectorCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
+    constructor(input: GetLogAnomalyDetectorCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudWatchLogsClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetLogAnomalyDetectorCommandInput, GetLogAnomalyDetectorCommandOutput>;
+    /**
+     * @internal
+     */
+    private serialize;
+    /**
+     * @internal
+     */
+    private deserialize;
+}

package/dist-types/commands/ListAnomaliesCommand.d.ts

@@ -0,0 +1,127 @@
+import { EndpointParameterInstructions } from "@smithy/middleware-endpoint";
+import { Command as $Command } from "@smithy/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@smithy/types";
+import { CloudWatchLogsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudWatchLogsClient";
+import { ListAnomaliesRequest, ListAnomaliesResponse } from "../models/models_0";
+/**
+ * @public
+ */
+export { __MetadataBearer, $Command };
+/**
+ * @public
+ *
+ * The input for {@link ListAnomaliesCommand}.
+ */
+export interface ListAnomaliesCommandInput extends ListAnomaliesRequest {
+}
+/**
+ * @public
+ *
+ * The output of {@link ListAnomaliesCommand}.
+ */
+export interface ListAnomaliesCommandOutput extends ListAnomaliesResponse, __MetadataBearer {
+}
+/**
+ * @public
+ * <p>Returns a list of anomalies that log anomaly detectors have found. For details about the structure format of
+ *       each anomaly object that is returned, see the example in this section.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CloudWatchLogsClient, ListAnomaliesCommand } from "@aws-sdk/client-cloudwatch-logs"; // ES Modules import
+ * // const { CloudWatchLogsClient, ListAnomaliesCommand } = require("@aws-sdk/client-cloudwatch-logs"); // CommonJS import
+ * const client = new CloudWatchLogsClient(config);
+ * const input = { // ListAnomaliesRequest
+ *   anomalyDetectorArn: "STRING_VALUE",
+ *   suppressionState: "SUPPRESSED" || "UNSUPPRESSED",
+ *   limit: Number("int"),
+ *   nextToken: "STRING_VALUE",
+ * };
+ * const command = new ListAnomaliesCommand(input);
+ * const response = await client.send(command);
+ * // { // ListAnomaliesResponse
+ * //   anomalies: [ // Anomalies
+ * //     { // Anomaly
+ * //       anomalyId: "STRING_VALUE", // required
+ * //       patternId: "STRING_VALUE", // required
+ * //       anomalyDetectorArn: "STRING_VALUE", // required
+ * //       patternString: "STRING_VALUE", // required
+ * //       patternRegex: "STRING_VALUE",
+ * //       priority: "STRING_VALUE",
+ * //       firstSeen: Number("long"), // required
+ * //       lastSeen: Number("long"), // required
+ * //       description: "STRING_VALUE", // required
+ * //       active: true || false, // required
+ * //       state: "Active" || "Suppressed" || "Baseline", // required
+ * //       histogram: { // Histogram // required
+ * //         "<keys>": Number("long"),
+ * //       },
+ * //       logSamples: [ // LogSamples // required
+ * //         "STRING_VALUE",
+ * //       ],
+ * //       patternTokens: [ // PatternTokens // required
+ * //         { // PatternToken
+ * //           dynamicTokenPosition: Number("int"),
+ * //           isDynamic: true || false,
+ * //           tokenString: "STRING_VALUE",
+ * //           enumerations: { // Enumerations
+ * //             "<keys>": Number("long"),
+ * //           },
+ * //         },
+ * //       ],
+ * //       logGroupArnList: [ // LogGroupArnList // required
+ * //         "STRING_VALUE",
+ * //       ],
+ * //       suppressed: true || false,
+ * //       suppressedDate: Number("long"),
+ * //       suppressedUntil: Number("long"),
+ * //       isPatternLevelSuppression: true || false,
+ * //     },
+ * //   ],
+ * //   nextToken: "STRING_VALUE",
+ * // };
+ *
+ * ```
+ *
+ * @param ListAnomaliesCommandInput - {@link ListAnomaliesCommandInput}
+ * @returns {@link ListAnomaliesCommandOutput}
+ * @see {@link ListAnomaliesCommandInput} for command's `input` shape.
+ * @see {@link ListAnomaliesCommandOutput} for command's `response` shape.
+ * @see {@link CloudWatchLogsClientResolvedConfig | config} for CloudWatchLogsClient's `config` shape.
+ *
+ * @throws {@link InvalidParameterException} (client fault)
+ *  <p>A parameter is specified incorrectly.</p>
+ *
+ * @throws {@link OperationAbortedException} (client fault)
+ *  <p>Multiple concurrent requests to update the same resource were in conflict.</p>
+ *
+ * @throws {@link ResourceNotFoundException} (client fault)
+ *  <p>The specified resource does not exist.</p>
+ *
+ * @throws {@link ServiceUnavailableException} (server fault)
+ *  <p>The service cannot complete the request.</p>
+ *
+ * @throws {@link CloudWatchLogsServiceException}
+ * <p>Base exception class for all service exceptions from CloudWatchLogs service.</p>
+ *
+ */
+export declare class ListAnomaliesCommand extends $Command<ListAnomaliesCommandInput, ListAnomaliesCommandOutput, CloudWatchLogsClientResolvedConfig> {
+    readonly input: ListAnomaliesCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
+    constructor(input: ListAnomaliesCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudWatchLogsClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListAnomaliesCommandInput, ListAnomaliesCommandOutput>;
+    /**
+     * @internal
+     */
+    private serialize;
+    /**
+     * @internal
+     */
+    private deserialize;
+}

package/dist-types/commands/ListLogAnomalyDetectorsCommand.d.ts

@@ -0,0 +1,103 @@
+import { EndpointParameterInstructions } from "@smithy/middleware-endpoint";
+import { Command as $Command } from "@smithy/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@smithy/types";
+import { CloudWatchLogsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudWatchLogsClient";
+import { ListLogAnomalyDetectorsRequest, ListLogAnomalyDetectorsResponse } from "../models/models_0";
+/**
+ * @public
+ */
+export { __MetadataBearer, $Command };
+/**
+ * @public
+ *
+ * The input for {@link ListLogAnomalyDetectorsCommand}.
+ */
+export interface ListLogAnomalyDetectorsCommandInput extends ListLogAnomalyDetectorsRequest {
+}
+/**
+ * @public
+ *
+ * The output of {@link ListLogAnomalyDetectorsCommand}.
+ */
+export interface ListLogAnomalyDetectorsCommandOutput extends ListLogAnomalyDetectorsResponse, __MetadataBearer {
+}
+/**
+ * @public
+ * <p>Retrieves a list of the log anomaly detectors in the account.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CloudWatchLogsClient, ListLogAnomalyDetectorsCommand } from "@aws-sdk/client-cloudwatch-logs"; // ES Modules import
+ * // const { CloudWatchLogsClient, ListLogAnomalyDetectorsCommand } = require("@aws-sdk/client-cloudwatch-logs"); // CommonJS import
+ * const client = new CloudWatchLogsClient(config);
+ * const input = { // ListLogAnomalyDetectorsRequest
+ *   filterLogGroupArn: "STRING_VALUE",
+ *   limit: Number("int"),
+ *   nextToken: "STRING_VALUE",
+ * };
+ * const command = new ListLogAnomalyDetectorsCommand(input);
+ * const response = await client.send(command);
+ * // { // ListLogAnomalyDetectorsResponse
+ * //   anomalyDetectors: [ // AnomalyDetectors
+ * //     { // AnomalyDetector
+ * //       anomalyDetectorArn: "STRING_VALUE",
+ * //       detectorName: "STRING_VALUE",
+ * //       logGroupArnList: [ // LogGroupArnList
+ * //         "STRING_VALUE",
+ * //       ],
+ * //       evaluationFrequency: "ONE_MIN" || "FIVE_MIN" || "TEN_MIN" || "FIFTEEN_MIN" || "THIRTY_MIN" || "ONE_HOUR",
+ * //       filterPattern: "STRING_VALUE",
+ * //       anomalyDetectorStatus: "INITIALIZING" || "TRAINING" || "ANALYZING" || "FAILED" || "DELETED" || "PAUSED",
+ * //       kmsKeyId: "STRING_VALUE",
+ * //       creationTimeStamp: Number("long"),
+ * //       lastModifiedTimeStamp: Number("long"),
+ * //       anomalyVisibilityTime: Number("long"),
+ * //     },
+ * //   ],
+ * //   nextToken: "STRING_VALUE",
+ * // };
+ *
+ * ```
+ *
+ * @param ListLogAnomalyDetectorsCommandInput - {@link ListLogAnomalyDetectorsCommandInput}
+ * @returns {@link ListLogAnomalyDetectorsCommandOutput}
+ * @see {@link ListLogAnomalyDetectorsCommandInput} for command's `input` shape.
+ * @see {@link ListLogAnomalyDetectorsCommandOutput} for command's `response` shape.
+ * @see {@link CloudWatchLogsClientResolvedConfig | config} for CloudWatchLogsClient's `config` shape.
+ *
+ * @throws {@link InvalidParameterException} (client fault)
+ *  <p>A parameter is specified incorrectly.</p>
+ *
+ * @throws {@link OperationAbortedException} (client fault)
+ *  <p>Multiple concurrent requests to update the same resource were in conflict.</p>
+ *
+ * @throws {@link ResourceNotFoundException} (client fault)
+ *  <p>The specified resource does not exist.</p>
+ *
+ * @throws {@link ServiceUnavailableException} (server fault)
+ *  <p>The service cannot complete the request.</p>
+ *
+ * @throws {@link CloudWatchLogsServiceException}
+ * <p>Base exception class for all service exceptions from CloudWatchLogs service.</p>
+ *
+ */
+export declare class ListLogAnomalyDetectorsCommand extends $Command<ListLogAnomalyDetectorsCommandInput, ListLogAnomalyDetectorsCommandOutput, CloudWatchLogsClientResolvedConfig> {
+    readonly input: ListLogAnomalyDetectorsCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
+    constructor(input: ListLogAnomalyDetectorsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudWatchLogsClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListLogAnomalyDetectorsCommandInput, ListLogAnomalyDetectorsCommandOutput>;
+    /**
+     * @internal
+     */
+    private serialize;
+    /**
+     * @internal
+     */
+    private deserialize;
+}

package/dist-types/commands/PutDeliveryDestinationCommand.d.ts

@@ -55,7 +55,7 @@ export interface PutDeliveryDestinationCommandOutput extends PutDeliveryDestinat
  *        can also create multiple deliveries to configure multiple delivery sources to send logs to the same delivery destination.</p>
  *          <p>Only some Amazon Web Services services support being configured as a delivery source. These services are listed
  *        as <b>Supported [V2 Permissions]</b> in the table at
- *        <a href="https://docs.aws.amazon.com/     AmazonCloudWatch/latest/logs/AWS-logs-and-resource-policy.html#AWS-vended-logs-permissions">Enabling
+ *        <a href="https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/AWS-logs-and-resource-policy.html">Enabling
  *          logging from Amazon Web Services services.</a>
  *          </p>
  *          <p>If you use this operation to update an existing delivery destination, all the current delivery destination parameters are overwritten

package/dist-types/commands/PutDeliveryDestinationPolicyCommand.d.ts

@@ -49,7 +49,7 @@ export interface PutDeliveryDestinationPolicyCommandOutput extends PutDeliveryDe
  *          </ul>
  *          <p>Only some Amazon Web Services services support being configured as a delivery source. These services are listed
  *        as <b>Supported [V2 Permissions]</b> in the table at
- *        <a href="https://docs.aws.amazon.com/     AmazonCloudWatch/latest/logs/AWS-logs-and-resource-policy.html#AWS-vended-logs-permissions">Enabling
+ *        <a href="https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/AWS-logs-and-resource-policy.html">Enabling
  *          logging from Amazon Web Services services.</a>
  *          </p>
  *          <p>The contents of the policy must include two statements. One statement enables general logs delivery, and the other

package/dist-types/commands/PutDeliverySourceCommand.d.ts

@@ -54,7 +54,7 @@ export interface PutDeliverySourceCommandOutput extends PutDeliverySourceRespons
  *        can also create multiple deliveries to configure multiple delivery sources to send logs to the same delivery destination.</p>
  *          <p>Only some Amazon Web Services services support being configured as a delivery source. These services are listed
  *        as <b>Supported [V2 Permissions]</b> in the table at
- *        <a href="https://docs.aws.amazon.com/     AmazonCloudWatch/latest/logs/AWS-logs-and-resource-policy.html#AWS-vended-logs-permissions">Enabling
+ *        <a href="https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/AWS-logs-and-resource-policy.html">Enabling
  *        logging from Amazon Web Services services.</a>
  *          </p>
  *          <p>If you use this operation to update an existing delivery source, all the current delivery source parameters are overwritten