@aws-sdk/client-cloudwatch-events 3.34.0 → 3.37.0

package/commands/ListTargetsByRuleCommand.ts

@@ -1,94 +0,0 @@
-import { CloudWatchEventsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudWatchEventsClient";
-import { ListTargetsByRuleRequest, ListTargetsByRuleResponse } from "../models/models_0";
-import {
-  deserializeAws_json1_1ListTargetsByRuleCommand,
-  serializeAws_json1_1ListTargetsByRuleCommand,
-} from "../protocols/Aws_json1_1";
-import { getSerdePlugin } from "@aws-sdk/middleware-serde";
-import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import {
-  FinalizeHandlerArguments,
-  Handler,
-  HandlerExecutionContext,
-  MiddlewareStack,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  SerdeContext as __SerdeContext,
-} from "@aws-sdk/types";
-
-export interface ListTargetsByRuleCommandInput extends ListTargetsByRuleRequest {}
-export interface ListTargetsByRuleCommandOutput extends ListTargetsByRuleResponse, __MetadataBearer {}
-
-/**
- * <p>Lists the targets assigned to the specified rule.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CloudWatchEventsClient, ListTargetsByRuleCommand } from "@aws-sdk/client-cloudwatch-events"; // ES Modules import
- * // const { CloudWatchEventsClient, ListTargetsByRuleCommand } = require("@aws-sdk/client-cloudwatch-events"); // CommonJS import
- * const client = new CloudWatchEventsClient(config);
- * const command = new ListTargetsByRuleCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListTargetsByRuleCommandInput} for command's `input` shape.
- * @see {@link ListTargetsByRuleCommandOutput} for command's `response` shape.
- * @see {@link CloudWatchEventsClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export class ListTargetsByRuleCommand extends $Command<
-  ListTargetsByRuleCommandInput,
-  ListTargetsByRuleCommandOutput,
-  CloudWatchEventsClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: ListTargetsByRuleCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: CloudWatchEventsClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<ListTargetsByRuleCommandInput, ListTargetsByRuleCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "CloudWatchEventsClient";
-    const commandName = "ListTargetsByRuleCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: ListTargetsByRuleRequest.filterSensitiveLog,
-      outputFilterSensitiveLog: ListTargetsByRuleResponse.filterSensitiveLog,
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve(
-      (request: FinalizeHandlerArguments<any>) =>
-        requestHandler.handle(request.request as __HttpRequest, options || {}),
-      handlerExecutionContext
-    );
-  }
-
-  private serialize(input: ListTargetsByRuleCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
-    return serializeAws_json1_1ListTargetsByRuleCommand(input, context);
-  }
-
-  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<ListTargetsByRuleCommandOutput> {
-    return deserializeAws_json1_1ListTargetsByRuleCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}

package/commands/PutEventsCommand.ts

@@ -1,91 +0,0 @@
-import { CloudWatchEventsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudWatchEventsClient";
-import { PutEventsRequest, PutEventsResponse } from "../models/models_0";
-import { deserializeAws_json1_1PutEventsCommand, serializeAws_json1_1PutEventsCommand } from "../protocols/Aws_json1_1";
-import { getSerdePlugin } from "@aws-sdk/middleware-serde";
-import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import {
-  FinalizeHandlerArguments,
-  Handler,
-  HandlerExecutionContext,
-  MiddlewareStack,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  SerdeContext as __SerdeContext,
-} from "@aws-sdk/types";
-
-export interface PutEventsCommandInput extends PutEventsRequest {}
-export interface PutEventsCommandOutput extends PutEventsResponse, __MetadataBearer {}
-
-/**
- * <p>Sends custom events to Amazon EventBridge so that they can be matched to rules.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CloudWatchEventsClient, PutEventsCommand } from "@aws-sdk/client-cloudwatch-events"; // ES Modules import
- * // const { CloudWatchEventsClient, PutEventsCommand } = require("@aws-sdk/client-cloudwatch-events"); // CommonJS import
- * const client = new CloudWatchEventsClient(config);
- * const command = new PutEventsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link PutEventsCommandInput} for command's `input` shape.
- * @see {@link PutEventsCommandOutput} for command's `response` shape.
- * @see {@link CloudWatchEventsClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export class PutEventsCommand extends $Command<
-  PutEventsCommandInput,
-  PutEventsCommandOutput,
-  CloudWatchEventsClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: PutEventsCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: CloudWatchEventsClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<PutEventsCommandInput, PutEventsCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "CloudWatchEventsClient";
-    const commandName = "PutEventsCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: PutEventsRequest.filterSensitiveLog,
-      outputFilterSensitiveLog: PutEventsResponse.filterSensitiveLog,
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve(
-      (request: FinalizeHandlerArguments<any>) =>
-        requestHandler.handle(request.request as __HttpRequest, options || {}),
-      handlerExecutionContext
-    );
-  }
-
-  private serialize(input: PutEventsCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
-    return serializeAws_json1_1PutEventsCommand(input, context);
-  }
-
-  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<PutEventsCommandOutput> {
-    return deserializeAws_json1_1PutEventsCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}

package/commands/PutPartnerEventsCommand.ts

@@ -1,95 +0,0 @@
-import { CloudWatchEventsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudWatchEventsClient";
-import { PutPartnerEventsRequest, PutPartnerEventsResponse } from "../models/models_0";
-import {
-  deserializeAws_json1_1PutPartnerEventsCommand,
-  serializeAws_json1_1PutPartnerEventsCommand,
-} from "../protocols/Aws_json1_1";
-import { getSerdePlugin } from "@aws-sdk/middleware-serde";
-import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import {
-  FinalizeHandlerArguments,
-  Handler,
-  HandlerExecutionContext,
-  MiddlewareStack,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  SerdeContext as __SerdeContext,
-} from "@aws-sdk/types";
-
-export interface PutPartnerEventsCommandInput extends PutPartnerEventsRequest {}
-export interface PutPartnerEventsCommandOutput extends PutPartnerEventsResponse, __MetadataBearer {}
-
-/**
- * <p>This is used by SaaS partners to write events to a customer's partner event bus. Amazon Web Services
- *       customers do not use this operation.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CloudWatchEventsClient, PutPartnerEventsCommand } from "@aws-sdk/client-cloudwatch-events"; // ES Modules import
- * // const { CloudWatchEventsClient, PutPartnerEventsCommand } = require("@aws-sdk/client-cloudwatch-events"); // CommonJS import
- * const client = new CloudWatchEventsClient(config);
- * const command = new PutPartnerEventsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link PutPartnerEventsCommandInput} for command's `input` shape.
- * @see {@link PutPartnerEventsCommandOutput} for command's `response` shape.
- * @see {@link CloudWatchEventsClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export class PutPartnerEventsCommand extends $Command<
-  PutPartnerEventsCommandInput,
-  PutPartnerEventsCommandOutput,
-  CloudWatchEventsClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: PutPartnerEventsCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: CloudWatchEventsClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<PutPartnerEventsCommandInput, PutPartnerEventsCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "CloudWatchEventsClient";
-    const commandName = "PutPartnerEventsCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: PutPartnerEventsRequest.filterSensitiveLog,
-      outputFilterSensitiveLog: PutPartnerEventsResponse.filterSensitiveLog,
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve(
-      (request: FinalizeHandlerArguments<any>) =>
-        requestHandler.handle(request.request as __HttpRequest, options || {}),
-      handlerExecutionContext
-    );
-  }
-
-  private serialize(input: PutPartnerEventsCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
-    return serializeAws_json1_1PutPartnerEventsCommand(input, context);
-  }
-
-  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<PutPartnerEventsCommandOutput> {
-    return deserializeAws_json1_1PutPartnerEventsCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}

package/commands/PutPermissionCommand.ts

@@ -1,113 +0,0 @@
-import { CloudWatchEventsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudWatchEventsClient";
-import { PutPermissionRequest } from "../models/models_0";
-import {
-  deserializeAws_json1_1PutPermissionCommand,
-  serializeAws_json1_1PutPermissionCommand,
-} from "../protocols/Aws_json1_1";
-import { getSerdePlugin } from "@aws-sdk/middleware-serde";
-import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import {
-  FinalizeHandlerArguments,
-  Handler,
-  HandlerExecutionContext,
-  MiddlewareStack,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  SerdeContext as __SerdeContext,
-} from "@aws-sdk/types";
-
-export interface PutPermissionCommandInput extends PutPermissionRequest {}
-export interface PutPermissionCommandOutput extends __MetadataBearer {}
-
-/**
- * <p>Running <code>PutPermission</code> permits the specified Amazon Web Services account or Amazon Web Services organization
- *       to put events to the specified <i>event bus</i>. Amazon EventBridge (CloudWatch
- *       Events) rules in your account are triggered by these events arriving to an event bus in your
- *       account. </p>
- *          <p>For another account to send events to your account, that external account must have an
- *       EventBridge rule with your account's event bus as a target.</p>
- *
- *          <p>To enable multiple Amazon Web Services accounts to put events to your event bus, run
- *         <code>PutPermission</code> once for each of these accounts. Or, if all the accounts are
- *       members of the same Amazon Web Services organization, you can run <code>PutPermission</code> once specifying
- *         <code>Principal</code> as "*" and specifying the Amazon Web Services organization ID in
- *         <code>Condition</code>, to grant permissions to all accounts in that organization.</p>
- *
- *          <p>If you grant permissions using an organization, then accounts in that organization must
- *       specify a <code>RoleArn</code> with proper permissions when they use <code>PutTarget</code> to
- *       add your account's event bus as a target. For more information, see <a href="https://docs.aws.amazon.com/eventbridge/latest/userguide/eventbridge-cross-account-event-delivery.html">Sending and
- *         Receiving Events Between Amazon Web Services Accounts</a> in the <i>Amazon EventBridge User
- *         Guide</i>.</p>
- *
- *          <p>The permission policy on the event bus cannot exceed 10 KB in size.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CloudWatchEventsClient, PutPermissionCommand } from "@aws-sdk/client-cloudwatch-events"; // ES Modules import
- * // const { CloudWatchEventsClient, PutPermissionCommand } = require("@aws-sdk/client-cloudwatch-events"); // CommonJS import
- * const client = new CloudWatchEventsClient(config);
- * const command = new PutPermissionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link PutPermissionCommandInput} for command's `input` shape.
- * @see {@link PutPermissionCommandOutput} for command's `response` shape.
- * @see {@link CloudWatchEventsClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export class PutPermissionCommand extends $Command<
-  PutPermissionCommandInput,
-  PutPermissionCommandOutput,
-  CloudWatchEventsClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: PutPermissionCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: CloudWatchEventsClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<PutPermissionCommandInput, PutPermissionCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "CloudWatchEventsClient";
-    const commandName = "PutPermissionCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: PutPermissionRequest.filterSensitiveLog,
-      outputFilterSensitiveLog: (output: any) => output,
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve(
-      (request: FinalizeHandlerArguments<any>) =>
-        requestHandler.handle(request.request as __HttpRequest, options || {}),
-      handlerExecutionContext
-    );
-  }
-
-  private serialize(input: PutPermissionCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
-    return serializeAws_json1_1PutPermissionCommand(input, context);
-  }
-
-  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<PutPermissionCommandOutput> {
-    return deserializeAws_json1_1PutPermissionCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}

package/commands/PutRuleCommand.ts

@@ -1,137 +0,0 @@
-import { CloudWatchEventsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudWatchEventsClient";
-import { PutRuleRequest, PutRuleResponse } from "../models/models_0";
-import { deserializeAws_json1_1PutRuleCommand, serializeAws_json1_1PutRuleCommand } from "../protocols/Aws_json1_1";
-import { getSerdePlugin } from "@aws-sdk/middleware-serde";
-import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import {
-  FinalizeHandlerArguments,
-  Handler,
-  HandlerExecutionContext,
-  MiddlewareStack,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  SerdeContext as __SerdeContext,
-} from "@aws-sdk/types";
-
-export interface PutRuleCommandInput extends PutRuleRequest {}
-export interface PutRuleCommandOutput extends PutRuleResponse, __MetadataBearer {}
-
-/**
- * <p>Creates or updates the specified rule. Rules are enabled by default, or based on value of
- *       the state. You can disable a rule using <a href="https://docs.aws.amazon.com/eventbridge/latest/APIReference/API_DisableRule.html">DisableRule</a>.</p>
- *
- *          <p>A single rule watches for events from a single event bus. Events generated by Amazon Web Services services
- *       go to your account's default event bus. Events generated by SaaS partner services or
- *       applications go to the matching partner event bus. If you have custom applications or
- *       services, you can specify whether their events go to your default event bus or a custom event
- *       bus that you have created. For more information, see <a href="https://docs.aws.amazon.com/eventbridge/latest/APIReference/API_CreateEventBus.html">CreateEventBus</a>.</p>
- *
- *          <p>If you are updating an existing rule, the rule is replaced with what you specify in this
- *         <code>PutRule</code> command. If you omit arguments in <code>PutRule</code>, the old values
- *       for those arguments are not kept. Instead, they are replaced with null values.</p>
- *
- *          <p>When you create or update a rule, incoming events might not immediately start matching to
- *       new or updated rules. Allow a short period of time for changes to take effect.</p>
- *
- *          <p>A rule must contain at least an EventPattern or ScheduleExpression. Rules with
- *       EventPatterns are triggered when a matching event is observed. Rules with ScheduleExpressions
- *       self-trigger based on the given schedule. A rule can have both an EventPattern and a
- *       ScheduleExpression, in which case the rule triggers on matching events as well as on a
- *       schedule.</p>
- *
- *          <p>When you initially create a rule, you can optionally assign one or more tags to the rule.
- *       Tags can help you organize and categorize your resources. You can also use them to scope user
- *       permissions, by granting a user permission to access or change only rules with certain tag
- *       values. To use the <code>PutRule</code> operation and assign tags, you must have both the
- *         <code>events:PutRule</code> and <code>events:TagResource</code> permissions.</p>
- *          <p>If you are updating an existing rule, any tags you specify in the <code>PutRule</code>
- *       operation are ignored. To update the tags of an existing rule, use <a href="https://docs.aws.amazon.com/eventbridge/latest/APIReference/API_TagResource.html">TagResource</a> and <a href="https://docs.aws.amazon.com/eventbridge/latest/APIReference/API_UntagResource.html">UntagResource</a>.</p>
- *
- *          <p>Most services in Amazon Web Services treat : or / as the same character in Amazon Resource Names (ARNs).
- *       However, EventBridge uses an exact match in event patterns and rules. Be sure to use the
- *       correct ARN characters when creating event patterns so that they match the ARN syntax in the
- *       event you want to match.</p>
- *
- *          <p>In EventBridge, it is possible to create rules that lead to infinite loops, where a rule
- *       is fired repeatedly. For example, a rule might detect that ACLs have changed on an S3 bucket,
- *       and trigger software to change them to the desired state. If the rule is not written
- *       carefully, the subsequent change to the ACLs fires the rule again, creating an infinite
- *       loop.</p>
- *          <p>To prevent this, write the rules so that the triggered actions do not re-fire the same
- *       rule. For example, your rule could fire only if ACLs are found to be in a bad state, instead
- *       of after any change. </p>
- *          <p>An infinite loop can quickly cause higher than expected charges. We recommend that you use
- *       budgeting, which alerts you when charges exceed your specified limit. For more information,
- *       see <a href="https://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/budgets-managing-costs.html">Managing Your Costs with
- *         Budgets</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CloudWatchEventsClient, PutRuleCommand } from "@aws-sdk/client-cloudwatch-events"; // ES Modules import
- * // const { CloudWatchEventsClient, PutRuleCommand } = require("@aws-sdk/client-cloudwatch-events"); // CommonJS import
- * const client = new CloudWatchEventsClient(config);
- * const command = new PutRuleCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link PutRuleCommandInput} for command's `input` shape.
- * @see {@link PutRuleCommandOutput} for command's `response` shape.
- * @see {@link CloudWatchEventsClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export class PutRuleCommand extends $Command<
-  PutRuleCommandInput,
-  PutRuleCommandOutput,
-  CloudWatchEventsClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: PutRuleCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: CloudWatchEventsClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<PutRuleCommandInput, PutRuleCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "CloudWatchEventsClient";
-    const commandName = "PutRuleCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: PutRuleRequest.filterSensitiveLog,
-      outputFilterSensitiveLog: PutRuleResponse.filterSensitiveLog,
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve(
-      (request: FinalizeHandlerArguments<any>) =>
-        requestHandler.handle(request.request as __HttpRequest, options || {}),
-      handlerExecutionContext
-    );
-  }
-
-  private serialize(input: PutRuleCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
-    return serializeAws_json1_1PutRuleCommand(input, context);
-  }
-
-  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<PutRuleCommandOutput> {
-    return deserializeAws_json1_1PutRuleCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}