@aws-sdk/client-eventbridge 3.36.0 → 3.39.0

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

@@ -6,37 +6,11 @@ export interface RemoveTargetsCommandInput extends RemoveTargetsRequest {
 }
 export interface RemoveTargetsCommandOutput extends RemoveTargetsResponse, __MetadataBearer {
 }
-/**
- * <p>Removes the specified targets from the specified rule. When the rule is triggered, those
- *       targets are no longer be invoked.</p>
- *
- *          <p>When you remove a target, when the associated rule triggers, removed targets might
- *       continue to be 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, RemoveTargetsCommand } from "@aws-sdk/client-eventbridge"; // ES Modules import
- * // const { EventBridgeClient, RemoveTargetsCommand } = require("@aws-sdk/client-eventbridge"); // CommonJS import
- * const client = new EventBridgeClient(config);
- * const command = new RemoveTargetsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link RemoveTargetsCommandInput} for command's `input` shape.
- * @see {@link RemoveTargetsCommandOutput} for command's `response` shape.
- * @see {@link EventBridgeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class RemoveTargetsCommand extends $Command<RemoveTargetsCommandInput, RemoveTargetsCommandOutput, EventBridgeClientResolvedConfig> {
     readonly input: RemoveTargetsCommandInput;
     constructor(input: RemoveTargetsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EventBridgeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<RemoveTargetsCommandInput, RemoveTargetsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,37 +6,11 @@ export interface StartReplayCommandInput extends StartReplayRequest {
 }
 export interface StartReplayCommandOutput extends StartReplayResponse, __MetadataBearer {
 }
-/**
- * <p>Starts the specified replay. Events are not necessarily replayed in the exact same order
- *       that they were added to the archive. A replay processes events to replay based on the time in
- *       the event, and replays them using 1 minute intervals. If you specify an
- *         <code>EventStartTime</code> and an <code>EventEndTime</code> that covers a 20 minute time
- *       range, the events are replayed from the first minute of that 20 minute range first. Then the
- *       events from the second minute are replayed. You can use <code>DescribeReplay</code> to
- *       determine the progress of a replay. The value returned for <code>EventLastReplayedTime</code>
- *       indicates the time within the specified time range associated with the last event
- *       replayed.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EventBridgeClient, StartReplayCommand } from "@aws-sdk/client-eventbridge"; // ES Modules import
- * // const { EventBridgeClient, StartReplayCommand } = require("@aws-sdk/client-eventbridge"); // CommonJS import
- * const client = new EventBridgeClient(config);
- * const command = new StartReplayCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link StartReplayCommandInput} for command's `input` shape.
- * @see {@link StartReplayCommandOutput} for command's `response` shape.
- * @see {@link EventBridgeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class StartReplayCommand extends $Command<StartReplayCommandInput, StartReplayCommandOutput, EventBridgeClientResolvedConfig> {
     readonly input: StartReplayCommandInput;
     constructor(input: StartReplayCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EventBridgeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StartReplayCommandInput, StartReplayCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,39 +6,11 @@ export interface TagResourceCommandInput extends TagResourceRequest {
 }
 export interface TagResourceCommandOutput extends TagResourceResponse, __MetadataBearer {
 }
-/**
- * <p>Assigns one or more tags (key-value pairs) to the specified EventBridge resource. 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 resources with certain tag
- *       values. In EventBridge, rules and event buses can be tagged.</p>
- *          <p>Tags don't have any semantic meaning to Amazon Web Services and are interpreted strictly as strings of
- *       characters.</p>
- *          <p>You can use the <code>TagResource</code> action with a resource that already has tags. If
- *       you specify a new tag key, this tag is appended to the list of tags associated with the
- *       resource. If you specify a tag key that is already associated with the resource, the new tag
- *       value that you specify replaces the previous value for that tag.</p>
- *          <p>You can associate as many as 50 tags with a resource.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EventBridgeClient, TagResourceCommand } from "@aws-sdk/client-eventbridge"; // ES Modules import
- * // const { EventBridgeClient, TagResourceCommand } = require("@aws-sdk/client-eventbridge"); // CommonJS import
- * const client = new EventBridgeClient(config);
- * const command = new TagResourceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link TagResourceCommandInput} for command's `input` shape.
- * @see {@link TagResourceCommandOutput} for command's `response` shape.
- * @see {@link EventBridgeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class TagResourceCommand extends $Command<TagResourceCommandInput, TagResourceCommandOutput, EventBridgeClientResolvedConfig> {
     readonly input: TagResourceCommandInput;
     constructor(input: TagResourceCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EventBridgeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<TagResourceCommandInput, TagResourceCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,33 +6,11 @@ export interface TestEventPatternCommandInput extends TestEventPatternRequest {
 }
 export interface TestEventPatternCommandOutput extends TestEventPatternResponse, __MetadataBearer {
 }
-/**
- * <p>Tests whether the specified event pattern matches the provided event.</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>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EventBridgeClient, TestEventPatternCommand } from "@aws-sdk/client-eventbridge"; // ES Modules import
- * // const { EventBridgeClient, TestEventPatternCommand } = require("@aws-sdk/client-eventbridge"); // CommonJS import
- * const client = new EventBridgeClient(config);
- * const command = new TestEventPatternCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link TestEventPatternCommandInput} for command's `input` shape.
- * @see {@link TestEventPatternCommandOutput} for command's `response` shape.
- * @see {@link EventBridgeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class TestEventPatternCommand extends $Command<TestEventPatternCommandInput, TestEventPatternCommandOutput, EventBridgeClientResolvedConfig> {
     readonly input: TestEventPatternCommandInput;
     constructor(input: TestEventPatternCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EventBridgeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<TestEventPatternCommandInput, TestEventPatternCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface UntagResourceCommandInput extends UntagResourceRequest {
 }
 export interface UntagResourceCommandOutput extends UntagResourceResponse, __MetadataBearer {
 }
-/**
- * <p>Removes one or more tags from the specified EventBridge resource. In Amazon EventBridge
- *       (CloudWatch Events), 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, UntagResourceCommand } from "@aws-sdk/client-eventbridge"; // ES Modules import
- * // const { EventBridgeClient, UntagResourceCommand } = require("@aws-sdk/client-eventbridge"); // CommonJS import
- * const client = new EventBridgeClient(config);
- * const command = new UntagResourceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UntagResourceCommandInput} for command's `input` shape.
- * @see {@link UntagResourceCommandOutput} for command's `response` shape.
- * @see {@link EventBridgeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UntagResourceCommand extends $Command<UntagResourceCommandInput, UntagResourceCommandOutput, EventBridgeClientResolvedConfig> {
     readonly input: UntagResourceCommandInput;
     constructor(input: UntagResourceCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EventBridgeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UntagResourceCommandInput, UntagResourceCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface UpdateApiDestinationCommandInput extends UpdateApiDestinationRe
 }
 export interface UpdateApiDestinationCommandOutput extends UpdateApiDestinationResponse, __MetadataBearer {
 }
-/**
- * <p>Updates an API destination.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EventBridgeClient, UpdateApiDestinationCommand } from "@aws-sdk/client-eventbridge"; // ES Modules import
- * // const { EventBridgeClient, UpdateApiDestinationCommand } = require("@aws-sdk/client-eventbridge"); // CommonJS import
- * const client = new EventBridgeClient(config);
- * const command = new UpdateApiDestinationCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateApiDestinationCommandInput} for command's `input` shape.
- * @see {@link UpdateApiDestinationCommandOutput} for command's `response` shape.
- * @see {@link EventBridgeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UpdateApiDestinationCommand extends $Command<UpdateApiDestinationCommandInput, UpdateApiDestinationCommandOutput, EventBridgeClientResolvedConfig> {
     readonly input: UpdateApiDestinationCommandInput;
     constructor(input: UpdateApiDestinationCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EventBridgeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateApiDestinationCommandInput, UpdateApiDestinationCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface UpdateArchiveCommandInput extends UpdateArchiveRequest {
 }
 export interface UpdateArchiveCommandOutput extends UpdateArchiveResponse, __MetadataBearer {
 }
-/**
- * <p>Updates the specified archive.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EventBridgeClient, UpdateArchiveCommand } from "@aws-sdk/client-eventbridge"; // ES Modules import
- * // const { EventBridgeClient, UpdateArchiveCommand } = require("@aws-sdk/client-eventbridge"); // CommonJS import
- * const client = new EventBridgeClient(config);
- * const command = new UpdateArchiveCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateArchiveCommandInput} for command's `input` shape.
- * @see {@link UpdateArchiveCommandOutput} for command's `response` shape.
- * @see {@link EventBridgeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UpdateArchiveCommand extends $Command<UpdateArchiveCommandInput, UpdateArchiveCommandOutput, EventBridgeClientResolvedConfig> {
     readonly input: UpdateArchiveCommandInput;
     constructor(input: UpdateArchiveCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EventBridgeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateArchiveCommandInput, UpdateArchiveCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface UpdateConnectionCommandInput extends UpdateConnectionRequest {
 }
 export interface UpdateConnectionCommandOutput extends UpdateConnectionResponse, __MetadataBearer {
 }
-/**
- * <p>Updates settings for a connection.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EventBridgeClient, UpdateConnectionCommand } from "@aws-sdk/client-eventbridge"; // ES Modules import
- * // const { EventBridgeClient, UpdateConnectionCommand } = require("@aws-sdk/client-eventbridge"); // CommonJS import
- * const client = new EventBridgeClient(config);
- * const command = new UpdateConnectionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateConnectionCommandInput} for command's `input` shape.
- * @see {@link UpdateConnectionCommandOutput} for command's `response` shape.
- * @see {@link EventBridgeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UpdateConnectionCommand extends $Command<UpdateConnectionCommandInput, UpdateConnectionCommandOutput, EventBridgeClientResolvedConfig> {
     readonly input: UpdateConnectionCommandInput;
     constructor(input: UpdateConnectionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EventBridgeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateConnectionCommandInput, UpdateConnectionCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -0,0 +1,51 @@
+export * from "./ActivateEventSourceCommand";
+export * from "./CancelReplayCommand";
+export * from "./CreateApiDestinationCommand";
+export * from "./CreateArchiveCommand";
+export * from "./CreateConnectionCommand";
+export * from "./CreateEventBusCommand";
+export * from "./CreatePartnerEventSourceCommand";
+export * from "./DeactivateEventSourceCommand";
+export * from "./DeauthorizeConnectionCommand";
+export * from "./DeleteApiDestinationCommand";
+export * from "./DeleteArchiveCommand";
+export * from "./DeleteConnectionCommand";
+export * from "./DeleteEventBusCommand";
+export * from "./DeletePartnerEventSourceCommand";
+export * from "./DeleteRuleCommand";
+export * from "./DescribeApiDestinationCommand";
+export * from "./DescribeArchiveCommand";
+export * from "./DescribeConnectionCommand";
+export * from "./DescribeEventBusCommand";
+export * from "./DescribeEventSourceCommand";
+export * from "./DescribePartnerEventSourceCommand";
+export * from "./DescribeReplayCommand";
+export * from "./DescribeRuleCommand";
+export * from "./DisableRuleCommand";
+export * from "./EnableRuleCommand";
+export * from "./ListApiDestinationsCommand";
+export * from "./ListArchivesCommand";
+export * from "./ListConnectionsCommand";
+export * from "./ListEventBusesCommand";
+export * from "./ListEventSourcesCommand";
+export * from "./ListPartnerEventSourceAccountsCommand";
+export * from "./ListPartnerEventSourcesCommand";
+export * from "./ListReplaysCommand";
+export * from "./ListRuleNamesByTargetCommand";
+export * from "./ListRulesCommand";
+export * from "./ListTagsForResourceCommand";
+export * from "./ListTargetsByRuleCommand";
+export * from "./PutEventsCommand";
+export * from "./PutPartnerEventsCommand";
+export * from "./PutPermissionCommand";
+export * from "./PutRuleCommand";
+export * from "./PutTargetsCommand";
+export * from "./RemovePermissionCommand";
+export * from "./RemoveTargetsCommand";
+export * from "./StartReplayCommand";
+export * from "./TagResourceCommand";
+export * from "./TestEventPatternCommand";
+export * from "./UntagResourceCommand";
+export * from "./UpdateApiDestinationCommand";
+export * from "./UpdateArchiveCommand";
+export * from "./UpdateConnectionCommand";

package/dist-types/ts3.4/index.d.ts

@@ -1,54 +1,4 @@
-export * from "./EventBridgeClient";
 export * from "./EventBridge";
-export * from "./commands/ActivateEventSourceCommand";
-export * from "./commands/CancelReplayCommand";
-export * from "./commands/CreateApiDestinationCommand";
-export * from "./commands/CreateArchiveCommand";
-export * from "./commands/CreateConnectionCommand";
-export * from "./commands/CreateEventBusCommand";
-export * from "./commands/CreatePartnerEventSourceCommand";
-export * from "./commands/DeactivateEventSourceCommand";
-export * from "./commands/DeauthorizeConnectionCommand";
-export * from "./commands/DeleteApiDestinationCommand";
-export * from "./commands/DeleteArchiveCommand";
-export * from "./commands/DeleteConnectionCommand";
-export * from "./commands/DeleteEventBusCommand";
-export * from "./commands/DeletePartnerEventSourceCommand";
-export * from "./commands/DeleteRuleCommand";
-export * from "./commands/DescribeApiDestinationCommand";
-export * from "./commands/DescribeArchiveCommand";
-export * from "./commands/DescribeConnectionCommand";
-export * from "./commands/DescribeEventBusCommand";
-export * from "./commands/DescribeEventSourceCommand";
-export * from "./commands/DescribePartnerEventSourceCommand";
-export * from "./commands/DescribeReplayCommand";
-export * from "./commands/DescribeRuleCommand";
-export * from "./commands/DisableRuleCommand";
-export * from "./commands/EnableRuleCommand";
-export * from "./commands/ListApiDestinationsCommand";
-export * from "./commands/ListArchivesCommand";
-export * from "./commands/ListConnectionsCommand";
-export * from "./commands/ListEventBusesCommand";
-export * from "./commands/ListEventSourcesCommand";
-export * from "./commands/ListPartnerEventSourceAccountsCommand";
-export * from "./commands/ListPartnerEventSourcesCommand";
-export * from "./commands/ListReplaysCommand";
-export * from "./commands/ListRuleNamesByTargetCommand";
-export * from "./commands/ListRulesCommand";
-export * from "./commands/ListTagsForResourceCommand";
-export * from "./commands/ListTargetsByRuleCommand";
-export * from "./commands/PutEventsCommand";
-export * from "./commands/PutPartnerEventsCommand";
-export * from "./commands/PutPermissionCommand";
-export * from "./commands/PutRuleCommand";
-export * from "./commands/PutTargetsCommand";
-export * from "./commands/RemovePermissionCommand";
-export * from "./commands/RemoveTargetsCommand";
-export * from "./commands/StartReplayCommand";
-export * from "./commands/TagResourceCommand";
-export * from "./commands/TestEventPatternCommand";
-export * from "./commands/UntagResourceCommand";
-export * from "./commands/UpdateApiDestinationCommand";
-export * from "./commands/UpdateArchiveCommand";
-export * from "./commands/UpdateConnectionCommand";
-export * from "./models/index";
+export * from "./EventBridgeClient";
+export * from "./commands";
+export * from "./models";