@aws-sdk/client-cloudwatch-logs 3.693.0 → 3.698.0

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

@@ -0,0 +1,231 @@
+import { Command as $Command } from "@smithy/smithy-client";
+import { MetadataBearer as __MetadataBearer } from "@smithy/types";
+import { CloudWatchLogsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudWatchLogsClient";
+import { GetTransformerRequest, GetTransformerResponse } from "../models/models_0";
+/**
+ * @public
+ */
+export type { __MetadataBearer };
+export { $Command };
+/**
+ * @public
+ *
+ * The input for {@link GetTransformerCommand}.
+ */
+export interface GetTransformerCommandInput extends GetTransformerRequest {
+}
+/**
+ * @public
+ *
+ * The output of {@link GetTransformerCommand}.
+ */
+export interface GetTransformerCommandOutput extends GetTransformerResponse, __MetadataBearer {
+}
+declare const GetTransformerCommand_base: {
+    new (input: GetTransformerCommandInput): import("@smithy/smithy-client").CommandImpl<GetTransformerCommandInput, GetTransformerCommandOutput, CloudWatchLogsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes>;
+    new (__0_0: GetTransformerCommandInput): import("@smithy/smithy-client").CommandImpl<GetTransformerCommandInput, GetTransformerCommandOutput, CloudWatchLogsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes>;
+    getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
+/**
+ * <p>Returns the information about the log transformer associated with this log group.</p>
+ *          <p>This operation returns data only for transformers created at the log group level. To get information
+ *        for an account-level transformer, use <a href="https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_DescribeAccountPolicies.html">DescribeAccountPolicies</a>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CloudWatchLogsClient, GetTransformerCommand } from "@aws-sdk/client-cloudwatch-logs"; // ES Modules import
+ * // const { CloudWatchLogsClient, GetTransformerCommand } = require("@aws-sdk/client-cloudwatch-logs"); // CommonJS import
+ * const client = new CloudWatchLogsClient(config);
+ * const input = { // GetTransformerRequest
+ *   logGroupIdentifier: "STRING_VALUE", // required
+ * };
+ * const command = new GetTransformerCommand(input);
+ * const response = await client.send(command);
+ * // { // GetTransformerResponse
+ * //   logGroupIdentifier: "STRING_VALUE",
+ * //   creationTime: Number("long"),
+ * //   lastModifiedTime: Number("long"),
+ * //   transformerConfig: [ // Processors
+ * //     { // Processor
+ * //       addKeys: { // AddKeys
+ * //         entries: [ // AddKeyEntries // required
+ * //           { // AddKeyEntry
+ * //             key: "STRING_VALUE", // required
+ * //             value: "STRING_VALUE", // required
+ * //             overwriteIfExists: true || false,
+ * //           },
+ * //         ],
+ * //       },
+ * //       copyValue: { // CopyValue
+ * //         entries: [ // CopyValueEntries // required
+ * //           { // CopyValueEntry
+ * //             source: "STRING_VALUE", // required
+ * //             target: "STRING_VALUE", // required
+ * //             overwriteIfExists: true || false,
+ * //           },
+ * //         ],
+ * //       },
+ * //       csv: { // CSV
+ * //         quoteCharacter: "STRING_VALUE",
+ * //         delimiter: "STRING_VALUE",
+ * //         columns: [ // Columns
+ * //           "STRING_VALUE",
+ * //         ],
+ * //         source: "STRING_VALUE",
+ * //       },
+ * //       dateTimeConverter: { // DateTimeConverter
+ * //         source: "STRING_VALUE", // required
+ * //         target: "STRING_VALUE", // required
+ * //         targetFormat: "STRING_VALUE",
+ * //         matchPatterns: [ // MatchPatterns // required
+ * //           "STRING_VALUE",
+ * //         ],
+ * //         sourceTimezone: "STRING_VALUE",
+ * //         targetTimezone: "STRING_VALUE",
+ * //         locale: "STRING_VALUE",
+ * //       },
+ * //       deleteKeys: { // DeleteKeys
+ * //         withKeys: [ // DeleteWithKeys // required
+ * //           "STRING_VALUE",
+ * //         ],
+ * //       },
+ * //       grok: { // Grok
+ * //         source: "STRING_VALUE",
+ * //         match: "STRING_VALUE", // required
+ * //       },
+ * //       listToMap: { // ListToMap
+ * //         source: "STRING_VALUE", // required
+ * //         key: "STRING_VALUE", // required
+ * //         valueKey: "STRING_VALUE",
+ * //         target: "STRING_VALUE",
+ * //         flatten: true || false,
+ * //         flattenedElement: "first" || "last",
+ * //       },
+ * //       lowerCaseString: { // LowerCaseString
+ * //         withKeys: [ // LowerCaseStringWithKeys // required
+ * //           "STRING_VALUE",
+ * //         ],
+ * //       },
+ * //       moveKeys: { // MoveKeys
+ * //         entries: [ // MoveKeyEntries // required
+ * //           { // MoveKeyEntry
+ * //             source: "STRING_VALUE", // required
+ * //             target: "STRING_VALUE", // required
+ * //             overwriteIfExists: true || false,
+ * //           },
+ * //         ],
+ * //       },
+ * //       parseCloudfront: { // ParseCloudfront
+ * //         source: "STRING_VALUE",
+ * //       },
+ * //       parseJSON: { // ParseJSON
+ * //         source: "STRING_VALUE",
+ * //         destination: "STRING_VALUE",
+ * //       },
+ * //       parseKeyValue: { // ParseKeyValue
+ * //         source: "STRING_VALUE",
+ * //         destination: "STRING_VALUE",
+ * //         fieldDelimiter: "STRING_VALUE",
+ * //         keyValueDelimiter: "STRING_VALUE",
+ * //         keyPrefix: "STRING_VALUE",
+ * //         nonMatchValue: "STRING_VALUE",
+ * //         overwriteIfExists: true || false,
+ * //       },
+ * //       parseRoute53: { // ParseRoute53
+ * //         source: "STRING_VALUE",
+ * //       },
+ * //       parsePostgres: { // ParsePostgres
+ * //         source: "STRING_VALUE",
+ * //       },
+ * //       parseVPC: { // ParseVPC
+ * //         source: "STRING_VALUE",
+ * //       },
+ * //       parseWAF: { // ParseWAF
+ * //         source: "STRING_VALUE",
+ * //       },
+ * //       renameKeys: { // RenameKeys
+ * //         entries: [ // RenameKeyEntries // required
+ * //           { // RenameKeyEntry
+ * //             key: "STRING_VALUE", // required
+ * //             renameTo: "STRING_VALUE", // required
+ * //             overwriteIfExists: true || false,
+ * //           },
+ * //         ],
+ * //       },
+ * //       splitString: { // SplitString
+ * //         entries: [ // SplitStringEntries // required
+ * //           { // SplitStringEntry
+ * //             source: "STRING_VALUE", // required
+ * //             delimiter: "STRING_VALUE", // required
+ * //           },
+ * //         ],
+ * //       },
+ * //       substituteString: { // SubstituteString
+ * //         entries: [ // SubstituteStringEntries // required
+ * //           { // SubstituteStringEntry
+ * //             source: "STRING_VALUE", // required
+ * //             from: "STRING_VALUE", // required
+ * //             to: "STRING_VALUE", // required
+ * //           },
+ * //         ],
+ * //       },
+ * //       trimString: { // TrimString
+ * //         withKeys: [ // TrimStringWithKeys // required
+ * //           "STRING_VALUE",
+ * //         ],
+ * //       },
+ * //       typeConverter: { // TypeConverter
+ * //         entries: [ // TypeConverterEntries // required
+ * //           { // TypeConverterEntry
+ * //             key: "STRING_VALUE", // required
+ * //             type: "boolean" || "integer" || "double" || "string", // required
+ * //           },
+ * //         ],
+ * //       },
+ * //       upperCaseString: { // UpperCaseString
+ * //         withKeys: [ // UpperCaseStringWithKeys // required
+ * //           "STRING_VALUE",
+ * //         ],
+ * //       },
+ * //     },
+ * //   ],
+ * // };
+ *
+ * ```
+ *
+ * @param GetTransformerCommandInput - {@link GetTransformerCommandInput}
+ * @returns {@link GetTransformerCommandOutput}
+ * @see {@link GetTransformerCommandInput} for command's `input` shape.
+ * @see {@link GetTransformerCommandOutput} for command's `response` shape.
+ * @see {@link CloudWatchLogsClientResolvedConfig | config} for CloudWatchLogsClient's `config` shape.
+ *
+ * @throws {@link InvalidOperationException} (client fault)
+ *  <p>The operation is not valid on the specified resource.</p>
+ *
+ * @throws {@link InvalidParameterException} (client fault)
+ *  <p>A parameter is specified incorrectly.</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>
+ *
+ * @public
+ */
+export declare class GetTransformerCommand extends GetTransformerCommand_base {
+    /** @internal type navigation helper, not in runtime. */
+    protected static __types: {
+        api: {
+            input: GetTransformerRequest;
+            output: GetTransformerResponse;
+        };
+        sdk: {
+            input: GetTransformerCommandInput;
+            output: GetTransformerCommandOutput;
+        };
+    };
+}

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

@@ -0,0 +1,92 @@
+import { Command as $Command } from "@smithy/smithy-client";
+import { MetadataBearer as __MetadataBearer } from "@smithy/types";
+import { CloudWatchLogsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudWatchLogsClient";
+import { ListLogGroupsForQueryRequest, ListLogGroupsForQueryResponse } from "../models/models_0";
+/**
+ * @public
+ */
+export type { __MetadataBearer };
+export { $Command };
+/**
+ * @public
+ *
+ * The input for {@link ListLogGroupsForQueryCommand}.
+ */
+export interface ListLogGroupsForQueryCommandInput extends ListLogGroupsForQueryRequest {
+}
+/**
+ * @public
+ *
+ * The output of {@link ListLogGroupsForQueryCommand}.
+ */
+export interface ListLogGroupsForQueryCommandOutput extends ListLogGroupsForQueryResponse, __MetadataBearer {
+}
+declare const ListLogGroupsForQueryCommand_base: {
+    new (input: ListLogGroupsForQueryCommandInput): import("@smithy/smithy-client").CommandImpl<ListLogGroupsForQueryCommandInput, ListLogGroupsForQueryCommandOutput, CloudWatchLogsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes>;
+    new (__0_0: ListLogGroupsForQueryCommandInput): import("@smithy/smithy-client").CommandImpl<ListLogGroupsForQueryCommandInput, ListLogGroupsForQueryCommandOutput, CloudWatchLogsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes>;
+    getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
+/**
+ * <p>Returns a list of the log groups that were analyzed during a single CloudWatch Logs Insights query. This can be useful for queries
+ *     that use
+ *     log group name prefixes or the <code>filterIndex</code> command, because the log groups are dynamically selected in these cases.</p>
+ *          <p>For more information about field indexes, see
+ *       <a href="https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CloudWatchLogs-Field-Indexing.html">Create field indexes to improve query performance and reduce costs</a>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CloudWatchLogsClient, ListLogGroupsForQueryCommand } from "@aws-sdk/client-cloudwatch-logs"; // ES Modules import
+ * // const { CloudWatchLogsClient, ListLogGroupsForQueryCommand } = require("@aws-sdk/client-cloudwatch-logs"); // CommonJS import
+ * const client = new CloudWatchLogsClient(config);
+ * const input = { // ListLogGroupsForQueryRequest
+ *   queryId: "STRING_VALUE", // required
+ *   nextToken: "STRING_VALUE",
+ *   maxResults: Number("int"),
+ * };
+ * const command = new ListLogGroupsForQueryCommand(input);
+ * const response = await client.send(command);
+ * // { // ListLogGroupsForQueryResponse
+ * //   logGroupIdentifiers: [ // LogGroupIdentifiers
+ * //     "STRING_VALUE",
+ * //   ],
+ * //   nextToken: "STRING_VALUE",
+ * // };
+ *
+ * ```
+ *
+ * @param ListLogGroupsForQueryCommandInput - {@link ListLogGroupsForQueryCommandInput}
+ * @returns {@link ListLogGroupsForQueryCommandOutput}
+ * @see {@link ListLogGroupsForQueryCommandInput} for command's `input` shape.
+ * @see {@link ListLogGroupsForQueryCommandOutput} for command's `response` shape.
+ * @see {@link CloudWatchLogsClientResolvedConfig | config} for CloudWatchLogsClient's `config` shape.
+ *
+ * @throws {@link AccessDeniedException} (client fault)
+ *  <p>You don't have sufficient permissions to perform this action.</p>
+ *
+ * @throws {@link InvalidParameterException} (client fault)
+ *  <p>A parameter is specified incorrectly.</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>
+ *
+ * @public
+ */
+export declare class ListLogGroupsForQueryCommand extends ListLogGroupsForQueryCommand_base {
+    /** @internal type navigation helper, not in runtime. */
+    protected static __types: {
+        api: {
+            input: ListLogGroupsForQueryRequest;
+            output: ListLogGroupsForQueryResponse;
+        };
+        sdk: {
+            input: ListLogGroupsForQueryCommandInput;
+            output: ListLogGroupsForQueryCommandOutput;
+        };
+    };
+}

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

@@ -27,7 +27,8 @@ declare const PutAccountPolicyCommand_base: {
     getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
 };
 /**
- * <p>Creates an account-level data protection policy or subscription filter policy that applies to all log groups
+ * <p>Creates an account-level data protection policy, subscription filter policy, or field index policy
+ *       that applies to all log groups
  *       or a subset of log groups in the account.</p>
  *          <p>
  *             <b>Data protection policy</b>
@@ -88,6 +89,66 @@ declare const PutAccountPolicyCommand_base: {
  *       If you are updating an existing filter, you must specify the correct name in <code>PolicyName</code>.
  *       To perform a <code>PutAccountPolicy</code> subscription filter operation for any destination except a Lambda
  *       function, you must also have the <code>iam:PassRole</code> permission.</p>
+ *          <p>
+ *             <b>Transformer policy</b>
+ *          </p>
+ *          <p>Creates or updates a <i>log transformer policy</i> for your account. You use log transformers to transform log events into
+ *       a different format, making them easier for you to process and analyze. You can also transform logs from different sources into standardized formats that
+ *       contain
+ *       relevant, source-specific information. After you have created a transformer,
+ *       CloudWatch Logs performs this transformation at the time of log ingestion. You can then refer to the transformed versions of the logs during
+ *       operations such as querying with CloudWatch Logs Insights or creating metric filters or subscription filters.</p>
+ *          <p>You can also use a transformer to copy metadata from metadata keys into the log events themselves. This metadata can include log group name,
+ *       log stream name, account ID and Region.</p>
+ *          <p>A transformer for a log group is a series of processors, where each processor applies one type of transformation to the log events
+ *       ingested into this log group. For more information about the available processors to use in a transformer, see <a href="https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CloudWatch-Logs-Transformation.html#CloudWatch-Logs-Transformation-Processors">
+ *         Processors that you can use</a>.</p>
+ *          <p>Having log events in standardized format enables visibility across your applications for your log analysis, reporting, and alarming needs.
+ *       CloudWatch Logs provides transformation for common log types with out-of-the-box transformation templates for major Amazon Web Services log sources such
+ *       as VPC flow logs, Lambda, and Amazon RDS. You can use pre-built transformation templates or create custom transformation policies.</p>
+ *          <p>You can create transformers only for the log groups in the Standard log class.</p>
+ *          <p>You can have one account-level transformer policy that applies to all log groups in the account.
+ *       Or you can create as many as 20 account-level transformer policies that are each scoped to a subset of log groups with
+ *       the <code>selectionCriteria</code> parameter. If you have multiple
+ *       account-level transformer policies with selection criteria, no two of them can use the same or overlapping log group name prefixes.
+ *       For example, if you have one policy filtered to log groups that start with <code>my-log</code>, you can't have another field index
+ *       policy filtered to <code>my-logpprod</code> or <code>my-logging</code>.</p>
+ *          <p>You can also set up a transformer at the log-group level. For more information, see
+ *       <a href="https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_PutTransformer.html">PutTransformer</a>. If there is both a
+ *       log-group level transformer created with <code>PutTransformer</code> and an account-level transformer that could apply to the same log
+ *       group, the log group uses only the log-group level transformer. It ignores the account-level transformer.</p>
+ *          <p>
+ *             <b>Field index policy</b>
+ *          </p>
+ *          <p>You can use field index policies to create indexes on fields found in
+ *       log events in the log group. Creating field indexes can help lower the scan volume for CloudWatch Logs Insights queries that reference
+ *       those fields, because these queries attempt to skip the processing of log events that are known to not match the indexed field.
+ *       Good fields to index are fields that you often need to query for and fields or values that match only a small fraction of the total log events.
+ *       Common examples of indexes
+ *       include request ID, session ID, user IDs, or instance IDs. For more information, see
+ *       <a href="https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CloudWatchLogs-Field-Indexing.html">Create field indexes to improve query performance and reduce costs</a>
+ *          </p>
+ *          <p>To find the fields that are in your log group events, use the
+ *       <a href="https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_GetLogGroupFields.html">GetLogGroupFields</a>
+ *       operation.</p>
+ *          <p>For example, suppose you have created a field index for <code>requestId</code>. Then, any
+ *       CloudWatch Logs Insights query on that log group that includes <code>requestId = <i>value</i>
+ *             </code>
+ *       or <code>requestId in [<i>value</i>, <i>value</i>, ...]</code> will attempt to process only the log events where
+ *       the indexed field matches the specified value.</p>
+ *          <p>Matches of log events to the names of indexed fields are case-sensitive. For example, an indexed field
+ *       of <code>RequestId</code> won't match a log event containing <code>requestId</code>.</p>
+ *          <p>You can have one account-level field index policy that applies to all log groups in the account.
+ *       Or you can create as many as 20 account-level field index policies that are each scoped to a subset of log groups with
+ *       the <code>selectionCriteria</code> parameter. If you have multiple
+ *     account-level index policies with selection criteria, no two of them can use the same or overlapping log group name prefixes.
+ *     For example, if you have one policy filtered to log groups that start with <code>my-log</code>, you can't have another field index
+ *     policy filtered to <code>my-logpprod</code> or <code>my-logging</code>.</p>
+ *          <p>If you create an account-level field index policy in a monitoring account in cross-account observability, the policy is applied only
+ *     to the monitoring account and not to any source accounts.</p>
+ *          <p>If you want to create a field index policy for a single log group, you can use <a href="https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_PutIndexPolicy.html">PutIndexPolicy</a> instead of
+ *       <code>PutAccountPolicy</code>. If you do so, that log group will use only that log-group level policy, and will ignore the account-level policy
+ *       that you create with <a href="https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_PutAccountPolicy.html">PutAccountPolicy</a>.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
  * ```javascript
@@ -97,7 +158,7 @@ declare const PutAccountPolicyCommand_base: {
  * const input = { // PutAccountPolicyRequest
  *   policyName: "STRING_VALUE", // required
  *   policyDocument: "STRING_VALUE", // required
- *   policyType: "DATA_PROTECTION_POLICY" || "SUBSCRIPTION_FILTER_POLICY", // required
+ *   policyType: "DATA_PROTECTION_POLICY" || "SUBSCRIPTION_FILTER_POLICY" || "FIELD_INDEX_POLICY" || "TRANSFORMER_POLICY", // required
  *   scope: "ALL",
  *   selectionCriteria: "STRING_VALUE",
  * };
@@ -108,7 +169,7 @@ declare const PutAccountPolicyCommand_base: {
  * //     policyName: "STRING_VALUE",
  * //     policyDocument: "STRING_VALUE",
  * //     lastUpdatedTime: Number("long"),
- * //     policyType: "DATA_PROTECTION_POLICY" || "SUBSCRIPTION_FILTER_POLICY",
+ * //     policyType: "DATA_PROTECTION_POLICY" || "SUBSCRIPTION_FILTER_POLICY" || "FIELD_INDEX_POLICY" || "TRANSFORMER_POLICY",
  * //     scope: "ALL",
  * //     selectionCriteria: "STRING_VALUE",
  * //     accountId: "STRING_VALUE",

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

@@ -0,0 +1,125 @@
+import { Command as $Command } from "@smithy/smithy-client";
+import { MetadataBearer as __MetadataBearer } from "@smithy/types";
+import { CloudWatchLogsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudWatchLogsClient";
+import { PutIndexPolicyRequest, PutIndexPolicyResponse } from "../models/models_0";
+/**
+ * @public
+ */
+export type { __MetadataBearer };
+export { $Command };
+/**
+ * @public
+ *
+ * The input for {@link PutIndexPolicyCommand}.
+ */
+export interface PutIndexPolicyCommandInput extends PutIndexPolicyRequest {
+}
+/**
+ * @public
+ *
+ * The output of {@link PutIndexPolicyCommand}.
+ */
+export interface PutIndexPolicyCommandOutput extends PutIndexPolicyResponse, __MetadataBearer {
+}
+declare const PutIndexPolicyCommand_base: {
+    new (input: PutIndexPolicyCommandInput): import("@smithy/smithy-client").CommandImpl<PutIndexPolicyCommandInput, PutIndexPolicyCommandOutput, CloudWatchLogsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes>;
+    new (__0_0: PutIndexPolicyCommandInput): import("@smithy/smithy-client").CommandImpl<PutIndexPolicyCommandInput, PutIndexPolicyCommandOutput, CloudWatchLogsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes>;
+    getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
+/**
+ * <p>Creates or updates a <i>field index policy</i> for the specified log group. Only log groups
+ *     in the Standard log class support field index policies. For more information about log classes, see
+ *       <a href="https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CloudWatch_Logs_Log_Classes.html">Log classes</a>.</p>
+ *          <p>You can use field index policies to create <i>field indexes</i> on fields found in
+ *       log events in the log group. Creating field indexes speeds up and lowers the costs for CloudWatch Logs Insights queries that reference
+ *       those field indexes, because these queries attempt to skip the processing of log events that are known to not match the indexed field.
+ *       Good fields to index are fields that you often need to query for and fields or values that match only a small fraction of the total log events.
+ *       Common examples of indexes
+ *       include request ID, session ID, userID, and instance IDs. For more information, see <a href="https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CloudWatchLogs-Field-Indexing.html">Create field indexes to improve query performance and reduce costs</a>.</p>
+ *          <p>To find the fields that are in your log group events, use the
+ *       <a href="https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_GetLogGroupFields.html">GetLogGroupFields</a>
+ *     operation.</p>
+ *          <p>For example, suppose you have created a field index for <code>requestId</code>. Then, any
+ *       CloudWatch Logs Insights query on that log group that includes <code>requestId = <i>value</i>
+ *             </code>
+ *       or <code>requestId IN [<i>value</i>, <i>value</i>, ...]</code> will process fewer log events
+ *       to reduce costs, and have improved performance.</p>
+ *          <p>Each index policy has the following quotas and restrictions:</p>
+ *          <ul>
+ *             <li>
+ *                <p>As many as 20 fields can be included in the policy.</p>
+ *             </li>
+ *             <li>
+ *                <p>Each field name can include as many as 100 characters.</p>
+ *             </li>
+ *          </ul>
+ *          <p>Matches of log events to the names of indexed fields are case-sensitive. For example, a field index
+ *     of <code>RequestId</code> won't match a log event containing <code>requestId</code>.</p>
+ *          <p>Log group-level field index policies created with <code>PutIndexPolicy</code> override account-level field
+ *       index policies created with <a href="https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_PutAccountPolicy.html">PutAccountPolicy</a>. If you use
+ *       <code>PutIndexPolicy</code> to create a field
+ *     index policy for a log group, that log group uses only that policy. The log group ignores any account-wide
+ *     field index policy that you might have created.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CloudWatchLogsClient, PutIndexPolicyCommand } from "@aws-sdk/client-cloudwatch-logs"; // ES Modules import
+ * // const { CloudWatchLogsClient, PutIndexPolicyCommand } = require("@aws-sdk/client-cloudwatch-logs"); // CommonJS import
+ * const client = new CloudWatchLogsClient(config);
+ * const input = { // PutIndexPolicyRequest
+ *   logGroupIdentifier: "STRING_VALUE", // required
+ *   policyDocument: "STRING_VALUE", // required
+ * };
+ * const command = new PutIndexPolicyCommand(input);
+ * const response = await client.send(command);
+ * // { // PutIndexPolicyResponse
+ * //   indexPolicy: { // IndexPolicy
+ * //     logGroupIdentifier: "STRING_VALUE",
+ * //     lastUpdateTime: Number("long"),
+ * //     policyDocument: "STRING_VALUE",
+ * //     policyName: "STRING_VALUE",
+ * //     source: "ACCOUNT" || "LOG_GROUP",
+ * //   },
+ * // };
+ *
+ * ```
+ *
+ * @param PutIndexPolicyCommandInput - {@link PutIndexPolicyCommandInput}
+ * @returns {@link PutIndexPolicyCommandOutput}
+ * @see {@link PutIndexPolicyCommandInput} for command's `input` shape.
+ * @see {@link PutIndexPolicyCommandOutput} 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>
+ *
+ * @public
+ */
+export declare class PutIndexPolicyCommand extends PutIndexPolicyCommand_base {
+    /** @internal type navigation helper, not in runtime. */
+    protected static __types: {
+        api: {
+            input: PutIndexPolicyRequest;
+            output: PutIndexPolicyResponse;
+        };
+        sdk: {
+            input: PutIndexPolicyCommandInput;
+            output: PutIndexPolicyCommandOutput;
+        };
+    };
+}

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

@@ -33,7 +33,7 @@ declare const PutMetricFilterCommand_base: {
  *          <p>The maximum number of metric filters that can be associated with a log group is
  *       100.</p>
  *          <p>Using regular expressions to create metric filters is supported. For these filters,
- *       there is a quotas of quota of two regular expression patterns within a single filter pattern. There
+ *       there is a quota of two regular expression patterns within a single filter pattern. There
  *       is also a quota of five regular expression patterns per log group.
  *     For more information about using regular expressions in metric filters,
  *     see <a href="https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/FilterAndPatternSyntax.html">
@@ -77,6 +77,7 @@ declare const PutMetricFilterCommand_base: {
  *       unit: "Seconds" || "Microseconds" || "Milliseconds" || "Bytes" || "Kilobytes" || "Megabytes" || "Gigabytes" || "Terabytes" || "Bits" || "Kilobits" || "Megabits" || "Gigabits" || "Terabits" || "Percent" || "Count" || "Bytes/Second" || "Kilobytes/Second" || "Megabytes/Second" || "Gigabytes/Second" || "Terabytes/Second" || "Bits/Second" || "Kilobits/Second" || "Megabits/Second" || "Gigabits/Second" || "Terabits/Second" || "Count/Second" || "None",
  *     },
  *   ],
+ *   applyOnTransformedLogs: true || false,
  * };
  * const command = new PutMetricFilterCommand(input);
  * const response = await client.send(command);
@@ -90,6 +91,9 @@ declare const PutMetricFilterCommand_base: {
  * @see {@link PutMetricFilterCommandOutput} for command's `response` shape.
  * @see {@link CloudWatchLogsClientResolvedConfig | config} for CloudWatchLogsClient's `config` shape.
  *
+ * @throws {@link InvalidOperationException} (client fault)
+ *  <p>The operation is not valid on the specified resource.</p>
+ *
  * @throws {@link InvalidParameterException} (client fault)
  *  <p>A parameter is specified incorrectly.</p>
  *

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

@@ -76,6 +76,7 @@ declare const PutSubscriptionFilterCommand_base: {
  *   destinationArn: "STRING_VALUE", // required
  *   roleArn: "STRING_VALUE",
  *   distribution: "Random" || "ByLogStream",
+ *   applyOnTransformedLogs: true || false,
  * };
  * const command = new PutSubscriptionFilterCommand(input);
  * const response = await client.send(command);
@@ -89,6 +90,9 @@ declare const PutSubscriptionFilterCommand_base: {
  * @see {@link PutSubscriptionFilterCommandOutput} for command's `response` shape.
  * @see {@link CloudWatchLogsClientResolvedConfig | config} for CloudWatchLogsClient's `config` shape.
  *
+ * @throws {@link InvalidOperationException} (client fault)
+ *  <p>The operation is not valid on the specified resource.</p>
+ *
  * @throws {@link InvalidParameterException} (client fault)
  *  <p>A parameter is specified incorrectly.</p>
  *