@aws-sdk/client-eventbridge 3.36.0 → 3.39.0

package/dist-types/ts3.4/commands/ListPartnerEventSourcesCommand.d.ts

@@ -6,30 +6,11 @@ export interface ListPartnerEventSourcesCommandInput extends ListPartnerEventSou
 }
 export interface ListPartnerEventSourcesCommandOutput extends ListPartnerEventSourcesResponse, __MetadataBearer {
 }
-/**
- * <p>An SaaS partner can use this operation to list all the partner event source names that
- *       they have created. This operation is not used by Amazon Web Services customers.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EventBridgeClient, ListPartnerEventSourcesCommand } from "@aws-sdk/client-eventbridge"; // ES Modules import
- * // const { EventBridgeClient, ListPartnerEventSourcesCommand } = require("@aws-sdk/client-eventbridge"); // CommonJS import
- * const client = new EventBridgeClient(config);
- * const command = new ListPartnerEventSourcesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListPartnerEventSourcesCommandInput} for command's `input` shape.
- * @see {@link ListPartnerEventSourcesCommandOutput} for command's `response` shape.
- * @see {@link EventBridgeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListPartnerEventSourcesCommand extends $Command<ListPartnerEventSourcesCommandInput, ListPartnerEventSourcesCommandOutput, EventBridgeClientResolvedConfig> {
     readonly input: ListPartnerEventSourcesCommandInput;
     constructor(input: ListPartnerEventSourcesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EventBridgeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListPartnerEventSourcesCommandInput, ListPartnerEventSourcesCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/ListReplaysCommand.d.ts

@@ -6,30 +6,11 @@ export interface ListReplaysCommandInput extends ListReplaysRequest {
 }
 export interface ListReplaysCommandOutput extends ListReplaysResponse, __MetadataBearer {
 }
-/**
- * <p>Lists your replays. You can either list all the replays or you can provide a prefix to
- *       match to the replay names. Filter parameters are exclusive.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EventBridgeClient, ListReplaysCommand } from "@aws-sdk/client-eventbridge"; // ES Modules import
- * // const { EventBridgeClient, ListReplaysCommand } = require("@aws-sdk/client-eventbridge"); // CommonJS import
- * const client = new EventBridgeClient(config);
- * const command = new ListReplaysCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListReplaysCommandInput} for command's `input` shape.
- * @see {@link ListReplaysCommandOutput} for command's `response` shape.
- * @see {@link EventBridgeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListReplaysCommand extends $Command<ListReplaysCommandInput, ListReplaysCommandOutput, EventBridgeClientResolvedConfig> {
     readonly input: ListReplaysCommandInput;
     constructor(input: ListReplaysCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EventBridgeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListReplaysCommandInput, ListReplaysCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/ListRuleNamesByTargetCommand.d.ts

@@ -6,30 +6,11 @@ export interface ListRuleNamesByTargetCommandInput extends ListRuleNamesByTarget
 }
 export interface ListRuleNamesByTargetCommandOutput extends ListRuleNamesByTargetResponse, __MetadataBearer {
 }
-/**
- * <p>Lists the rules for the specified target. You can see which of the rules in Amazon
- *       EventBridge can invoke a specific target in your account.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EventBridgeClient, ListRuleNamesByTargetCommand } from "@aws-sdk/client-eventbridge"; // ES Modules import
- * // const { EventBridgeClient, ListRuleNamesByTargetCommand } = require("@aws-sdk/client-eventbridge"); // CommonJS import
- * const client = new EventBridgeClient(config);
- * const command = new ListRuleNamesByTargetCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListRuleNamesByTargetCommandInput} for command's `input` shape.
- * @see {@link ListRuleNamesByTargetCommandOutput} for command's `response` shape.
- * @see {@link EventBridgeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListRuleNamesByTargetCommand extends $Command<ListRuleNamesByTargetCommandInput, ListRuleNamesByTargetCommandOutput, EventBridgeClientResolvedConfig> {
     readonly input: ListRuleNamesByTargetCommandInput;
     constructor(input: ListRuleNamesByTargetCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EventBridgeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListRuleNamesByTargetCommandInput, ListRuleNamesByTargetCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/ListRulesCommand.d.ts

@@ -6,33 +6,11 @@ export interface ListRulesCommandInput extends ListRulesRequest {
 }
 export interface ListRulesCommandOutput extends ListRulesResponse, __MetadataBearer {
 }
-/**
- * <p>Lists your Amazon EventBridge rules. You can either list all the rules or you can provide
- *       a prefix to match to the rule names.</p>
- *
- *          <p>ListRules does not list the targets of a rule. To see the targets associated with a rule,
- *       use <a href="https://docs.aws.amazon.com/eventbridge/latest/APIReference/API_ListTargetsByRule.html">ListTargetsByRule</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EventBridgeClient, ListRulesCommand } from "@aws-sdk/client-eventbridge"; // ES Modules import
- * // const { EventBridgeClient, ListRulesCommand } = require("@aws-sdk/client-eventbridge"); // CommonJS import
- * const client = new EventBridgeClient(config);
- * const command = new ListRulesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListRulesCommandInput} for command's `input` shape.
- * @see {@link ListRulesCommandOutput} for command's `response` shape.
- * @see {@link EventBridgeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListRulesCommand extends $Command<ListRulesCommandInput, ListRulesCommandOutput, EventBridgeClientResolvedConfig> {
     readonly input: ListRulesCommandInput;
     constructor(input: ListRulesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EventBridgeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListRulesCommandInput, ListRulesCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/ListTagsForResourceCommand.d.ts

@@ -6,30 +6,11 @@ export interface ListTagsForResourceCommandInput extends ListTagsForResourceRequ
 }
 export interface ListTagsForResourceCommandOutput extends ListTagsForResourceResponse, __MetadataBearer {
 }
-/**
- * <p>Displays the tags associated with an EventBridge resource. In EventBridge, rules and event
- *       buses can be tagged.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EventBridgeClient, ListTagsForResourceCommand } from "@aws-sdk/client-eventbridge"; // ES Modules import
- * // const { EventBridgeClient, ListTagsForResourceCommand } = require("@aws-sdk/client-eventbridge"); // CommonJS import
- * const client = new EventBridgeClient(config);
- * const command = new ListTagsForResourceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListTagsForResourceCommandInput} for command's `input` shape.
- * @see {@link ListTagsForResourceCommandOutput} for command's `response` shape.
- * @see {@link EventBridgeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListTagsForResourceCommand extends $Command<ListTagsForResourceCommandInput, ListTagsForResourceCommandOutput, EventBridgeClientResolvedConfig> {
     readonly input: ListTagsForResourceCommandInput;
     constructor(input: ListTagsForResourceCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EventBridgeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListTagsForResourceCommandInput, ListTagsForResourceCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/ListTargetsByRuleCommand.d.ts

@@ -6,29 +6,11 @@ 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 { EventBridgeClient, ListTargetsByRuleCommand } from "@aws-sdk/client-eventbridge"; // ES Modules import
- * // const { EventBridgeClient, ListTargetsByRuleCommand } = require("@aws-sdk/client-eventbridge"); // CommonJS import
- * const client = new EventBridgeClient(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 EventBridgeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListTargetsByRuleCommand extends $Command<ListTargetsByRuleCommandInput, ListTargetsByRuleCommandOutput, EventBridgeClientResolvedConfig> {
     readonly input: ListTargetsByRuleCommandInput;
     constructor(input: ListTargetsByRuleCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EventBridgeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListTargetsByRuleCommandInput, ListTargetsByRuleCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/PutEventsCommand.d.ts

@@ -6,29 +6,11 @@ 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 { EventBridgeClient, PutEventsCommand } from "@aws-sdk/client-eventbridge"; // ES Modules import
- * // const { EventBridgeClient, PutEventsCommand } = require("@aws-sdk/client-eventbridge"); // CommonJS import
- * const client = new EventBridgeClient(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 EventBridgeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class PutEventsCommand extends $Command<PutEventsCommandInput, PutEventsCommandOutput, EventBridgeClientResolvedConfig> {
     readonly input: PutEventsCommandInput;
     constructor(input: PutEventsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EventBridgeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutEventsCommandInput, PutEventsCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/PutPartnerEventsCommand.d.ts

@@ -6,30 +6,11 @@ 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 { EventBridgeClient, PutPartnerEventsCommand } from "@aws-sdk/client-eventbridge"; // ES Modules import
- * // const { EventBridgeClient, PutPartnerEventsCommand } = require("@aws-sdk/client-eventbridge"); // CommonJS import
- * const client = new EventBridgeClient(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 EventBridgeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class PutPartnerEventsCommand extends $Command<PutPartnerEventsCommandInput, PutPartnerEventsCommandOutput, EventBridgeClientResolvedConfig> {
     readonly input: PutPartnerEventsCommandInput;
     constructor(input: PutPartnerEventsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EventBridgeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutPartnerEventsCommandInput, PutPartnerEventsCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/PutPermissionCommand.d.ts

@@ -6,48 +6,11 @@ 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 { EventBridgeClient, PutPermissionCommand } from "@aws-sdk/client-eventbridge"; // ES Modules import
- * // const { EventBridgeClient, PutPermissionCommand } = require("@aws-sdk/client-eventbridge"); // CommonJS import
- * const client = new EventBridgeClient(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 EventBridgeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class PutPermissionCommand extends $Command<PutPermissionCommandInput, PutPermissionCommandOutput, EventBridgeClientResolvedConfig> {
     readonly input: PutPermissionCommandInput;
     constructor(input: PutPermissionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EventBridgeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutPermissionCommandInput, PutPermissionCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/PutRuleCommand.d.ts

@@ -6,75 +6,11 @@ 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 { EventBridgeClient, PutRuleCommand } from "@aws-sdk/client-eventbridge"; // ES Modules import
- * // const { EventBridgeClient, PutRuleCommand } = require("@aws-sdk/client-eventbridge"); // CommonJS import
- * const client = new EventBridgeClient(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 EventBridgeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class PutRuleCommand extends $Command<PutRuleCommandInput, PutRuleCommandOutput, EventBridgeClientResolvedConfig> {
     readonly input: PutRuleCommandInput;
     constructor(input: PutRuleCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EventBridgeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutRuleCommandInput, PutRuleCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/PutTargetsCommand.d.ts

@@ -6,194 +6,11 @@ export interface PutTargetsCommandInput extends PutTargetsRequest {
 }
 export interface PutTargetsCommandOutput extends PutTargetsResponse, __MetadataBearer {
 }
-/**
- * <p>Adds the specified targets to the specified rule, or updates the targets if they are
- *       already associated with the rule.</p>
- *          <p>Targets are the resources that are invoked when a rule is triggered.</p>
- *          <p>You can configure the following as targets for Events:</p>
- *
- *          <ul>
- *             <li>
- *                <p>
- *                   <a href="https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-api-destinations.html">API
- *           destination</a>
- *                </p>
- *             </li>
- *             <li>
- *                <p>Amazon API Gateway REST API endpoints</p>
- *             </li>
- *             <li>
- *                <p>API Gateway</p>
- *             </li>
- *             <li>
- *                <p>Batch job queue</p>
- *             </li>
- *             <li>
- *                <p>CloudWatch Logs group</p>
- *             </li>
- *             <li>
- *                <p>CodeBuild project</p>
- *             </li>
- *             <li>
- *                <p>CodePipeline</p>
- *             </li>
- *             <li>
- *                <p>Amazon EC2 <code>CreateSnapshot</code> API call</p>
- *             </li>
- *             <li>
- *                <p>Amazon EC2 <code>RebootInstances</code> API call</p>
- *             </li>
- *             <li>
- *                <p>Amazon EC2 <code>StopInstances</code> API call</p>
- *             </li>
- *             <li>
- *                <p>Amazon EC2 <code>TerminateInstances</code> API call</p>
- *             </li>
- *             <li>
- *                <p>Amazon ECS tasks</p>
- *             </li>
- *             <li>
- *                <p>Event bus in a different Amazon Web Services account or Region.</p>
- *                <p>You can use an event bus in the US East (N. Virginia) us-east-1, US West (Oregon)
- *           us-west-2, or Europe (Ireland) eu-west-1 Regions as a target for a rule.</p>
- *             </li>
- *             <li>
- *                <p>Firehose delivery stream (Kinesis Data Firehose)</p>
- *             </li>
- *             <li>
- *                <p>Inspector assessment template (Amazon Inspector)</p>
- *             </li>
- *             <li>
- *                <p>Kinesis stream (Kinesis Data Stream)</p>
- *             </li>
- *             <li>
- *                <p>Lambda function</p>
- *             </li>
- *             <li>
- *                <p>Redshift clusters (Data API statement execution)</p>
- *             </li>
- *             <li>
- *                <p>Amazon SNS topic</p>
- *             </li>
- *             <li>
- *                <p>Amazon SQS queues (includes FIFO queues</p>
- *             </li>
- *             <li>
- *                <p>SSM Automation</p>
- *             </li>
- *             <li>
- *                <p>SSM OpsItem</p>
- *             </li>
- *             <li>
- *                <p>SSM Run Command</p>
- *             </li>
- *             <li>
- *                <p>Step Functions state machines</p>
- *             </li>
- *          </ul>
- *
- *          <p>Creating rules with built-in targets is supported only in the Amazon Web Services Management Console. The
- *       built-in targets are <code>EC2 CreateSnapshot API call</code>, <code>EC2 RebootInstances API
- *         call</code>, <code>EC2 StopInstances API call</code>, and <code>EC2 TerminateInstances API
- *         call</code>. </p>
- *
- *          <p>For some target types, <code>PutTargets</code> provides target-specific parameters. If the
- *       target is a Kinesis data stream, you can optionally specify which shard the event goes to by
- *       using the <code>KinesisParameters</code> argument. To invoke a command on multiple EC2
- *       instances with one rule, you can use the <code>RunCommandParameters</code> field.</p>
- *
- *          <p>To be able to make API calls against the resources that you own, Amazon EventBridge
- *       needs the appropriate permissions. For Lambda and Amazon SNS
- *       resources, EventBridge relies on resource-based policies. For EC2 instances, Kinesis Data Streams,
- *       Step Functions state machines and API Gateway REST APIs, EventBridge relies on
- *       IAM roles that you specify in the <code>RoleARN</code> argument in <code>PutTargets</code>.
- *       For more information, see <a href="https://docs.aws.amazon.com/eventbridge/latest/userguide/auth-and-access-control-eventbridge.html">Authentication
- *         and Access Control</a> in the <i>Amazon EventBridge User Guide</i>.</p>
- *
- *          <p>If another Amazon Web Services account is in the same region and has granted you permission (using
- *         <code>PutPermission</code>), you can send events to that account. Set that account's event
- *       bus as a target of the rules in your account. To send the matched events to the other account,
- *       specify that account's event bus as the <code>Arn</code> value when you run
- *         <code>PutTargets</code>. If your account sends events to another account, your account is
- *       charged for each sent event. Each event sent to another account is charged as a custom event.
- *       The account receiving the event is not charged. For more information, see <a href="http://aws.amazon.com/eventbridge/pricing/">Amazon EventBridge
- *         Pricing</a>.</p>
- *
- *          <note>
- *             <p>
- *                <code>Input</code>, <code>InputPath</code>, and <code>InputTransformer</code> are not
- *         available with <code>PutTarget</code> if the target is an event bus of a different Amazon Web Services
- *         account.</p>
- *          </note>
- *
- *          <p>If you are setting the event bus of another account as the target, and that account
- *       granted permission to your account through an organization instead of directly by the account
- *       ID, then you must specify a <code>RoleArn</code> with proper permissions in the
- *         <code>Target</code> structure. 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>For more information about enabling cross-account events, see <a href="https://docs.aws.amazon.com/eventbridge/latest/APIReference/API_PutPermission.html">PutPermission</a>.</p>
- *
- *          <p>
- *             <b>Input</b>, <b>InputPath</b>, and
- *         <b>InputTransformer</b> are mutually exclusive and optional
- *       parameters of a target. When a rule is triggered due to a matched event:</p>
- *
- *          <ul>
- *             <li>
- *                <p>If none of the following arguments are specified for a target, then the entire event
- *           is passed to the target in JSON format (unless the target is Amazon EC2 Run Command or
- *           Amazon ECS task, in which case nothing from the event is passed to the target).</p>
- *             </li>
- *             <li>
- *                <p>If <b>Input</b> is specified in the form of valid JSON, then
- *           the matched event is overridden with this constant.</p>
- *             </li>
- *             <li>
- *                <p>If <b>InputPath</b> is specified in the form of JSONPath
- *           (for example, <code>$.detail</code>), then only the part of the event specified in the
- *           path is passed to the target (for example, only the detail part of the event is
- *           passed).</p>
- *             </li>
- *             <li>
- *                <p>If <b>InputTransformer</b> is specified, then one or more
- *           specified JSONPaths are extracted from the event and used as values in a template that you
- *           specify as the input to the target.</p>
- *             </li>
- *          </ul>
- *
- *          <p>When you specify <code>InputPath</code> or <code>InputTransformer</code>, you must use
- *       JSON dot notation, not bracket notation.</p>
- *
- *          <p>When you add targets to a rule and the associated rule triggers soon after, new or updated
- *       targets might not be immediately invoked. Allow a short period of time for changes to take
- *       effect.</p>
- *
- *          <p>This action can partially fail if too many requests are made at the same time. If that
- *       happens, <code>FailedEntryCount</code> is non-zero in the response and each entry in
- *         <code>FailedEntries</code> provides the ID of the failed target and the error code.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EventBridgeClient, PutTargetsCommand } from "@aws-sdk/client-eventbridge"; // ES Modules import
- * // const { EventBridgeClient, PutTargetsCommand } = require("@aws-sdk/client-eventbridge"); // CommonJS import
- * const client = new EventBridgeClient(config);
- * const command = new PutTargetsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link PutTargetsCommandInput} for command's `input` shape.
- * @see {@link PutTargetsCommandOutput} for command's `response` shape.
- * @see {@link EventBridgeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class PutTargetsCommand extends $Command<PutTargetsCommandInput, PutTargetsCommandOutput, EventBridgeClientResolvedConfig> {
     readonly input: PutTargetsCommandInput;
     constructor(input: PutTargetsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EventBridgeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutTargetsCommandInput, PutTargetsCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/RemovePermissionCommand.d.ts

@@ -6,32 +6,11 @@ export interface RemovePermissionCommandInput extends RemovePermissionRequest {
 }
 export interface RemovePermissionCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Revokes the permission of another Amazon Web Services account to be able to put events to the specified
- *       event bus. Specify the account to revoke by the <code>StatementId</code> value that you
- *       associated with the account when you granted it permission with <code>PutPermission</code>.
- *       You can find the <code>StatementId</code> by using <a href="https://docs.aws.amazon.com/eventbridge/latest/APIReference/API_DescribeEventBus.html">DescribeEventBus</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EventBridgeClient, RemovePermissionCommand } from "@aws-sdk/client-eventbridge"; // ES Modules import
- * // const { EventBridgeClient, RemovePermissionCommand } = require("@aws-sdk/client-eventbridge"); // CommonJS import
- * const client = new EventBridgeClient(config);
- * const command = new RemovePermissionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link RemovePermissionCommandInput} for command's `input` shape.
- * @see {@link RemovePermissionCommandOutput} for command's `response` shape.
- * @see {@link EventBridgeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class RemovePermissionCommand extends $Command<RemovePermissionCommandInput, RemovePermissionCommandOutput, EventBridgeClientResolvedConfig> {
     readonly input: RemovePermissionCommandInput;
     constructor(input: RemovePermissionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EventBridgeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<RemovePermissionCommandInput, RemovePermissionCommandOutput>;
     private serialize;
     private deserialize;