@aws-sdk/client-eventbridge 3.36.0 → 3.39.0

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

@@ -6,33 +6,11 @@ export interface DeletePartnerEventSourceCommandInput extends DeletePartnerEvent
 }
 export interface DeletePartnerEventSourceCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>This operation is used by SaaS partners to delete a partner event source. This operation
- *       is not used by Amazon Web Services customers.</p>
- *          <p>When you delete an event source, the status of the corresponding partner event bus in the
- *       Amazon Web Services customer account becomes DELETED.</p>
- *          <p></p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EventBridgeClient, DeletePartnerEventSourceCommand } from "@aws-sdk/client-eventbridge"; // ES Modules import
- * // const { EventBridgeClient, DeletePartnerEventSourceCommand } = require("@aws-sdk/client-eventbridge"); // CommonJS import
- * const client = new EventBridgeClient(config);
- * const command = new DeletePartnerEventSourceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeletePartnerEventSourceCommandInput} for command's `input` shape.
- * @see {@link DeletePartnerEventSourceCommandOutput} for command's `response` shape.
- * @see {@link EventBridgeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeletePartnerEventSourceCommand extends $Command<DeletePartnerEventSourceCommandInput, DeletePartnerEventSourceCommandOutput, EventBridgeClientResolvedConfig> {
     readonly input: DeletePartnerEventSourceCommandInput;
     constructor(input: DeletePartnerEventSourceCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EventBridgeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeletePartnerEventSourceCommandInput, DeletePartnerEventSourceCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,42 +6,11 @@ export interface DeleteRuleCommandInput extends DeleteRuleRequest {
 }
 export interface DeleteRuleCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Deletes the specified rule.</p>
- *          <p>Before you can delete the rule, you must remove all targets, using <a href="https://docs.aws.amazon.com/eventbridge/latest/APIReference/API_RemoveTargets.html">RemoveTargets</a>.</p>
- *
- *          <p>When you delete a rule, incoming events might continue to match to the deleted rule. Allow
- *       a short period of time for changes to take effect.</p>
- *
- *          <p>If you call delete rule multiple times for the same rule, all calls will succeed. When you
- *       call delete rule for a non-existent custom eventbus, <code>ResourceNotFoundException</code> is
- *       returned.</p>
- *
- *          <p>Managed rules are rules created and managed by another Amazon Web Services service on your behalf. These
- *       rules are created by those other Amazon Web Services services to support functionality in those services. You
- *       can delete these rules using the <code>Force</code> option, but you should do so only if you
- *       are sure the other service is not still using that rule.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EventBridgeClient, DeleteRuleCommand } from "@aws-sdk/client-eventbridge"; // ES Modules import
- * // const { EventBridgeClient, DeleteRuleCommand } = require("@aws-sdk/client-eventbridge"); // CommonJS import
- * const client = new EventBridgeClient(config);
- * const command = new DeleteRuleCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteRuleCommandInput} for command's `input` shape.
- * @see {@link DeleteRuleCommandOutput} for command's `response` shape.
- * @see {@link EventBridgeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteRuleCommand extends $Command<DeleteRuleCommandInput, DeleteRuleCommandOutput, EventBridgeClientResolvedConfig> {
     readonly input: DeleteRuleCommandInput;
     constructor(input: DeleteRuleCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EventBridgeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteRuleCommandInput, DeleteRuleCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

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

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

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

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

@@ -6,35 +6,11 @@ export interface DescribeEventBusCommandInput extends DescribeEventBusRequest {
 }
 export interface DescribeEventBusCommandOutput extends DescribeEventBusResponse, __MetadataBearer {
 }
-/**
- * <p>Displays details about an event bus in your account. This can include the external Amazon Web Services
- *       accounts that are permitted to write events to your default event bus, and the associated
- *       policy. For custom event buses and partner event buses, it displays the name, ARN, policy,
- *       state, and creation time.</p>
- *          <p> To enable your account to receive events from other accounts on its default event bus,
- *       use <a href="https://docs.aws.amazon.com/eventbridge/latest/APIReference/API_PutPermission.html">PutPermission</a>.</p>
- *          <p>For more information about partner event buses, see <a href="https://docs.aws.amazon.com/eventbridge/latest/APIReference/API_CreateEventBus.html">CreateEventBus</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EventBridgeClient, DescribeEventBusCommand } from "@aws-sdk/client-eventbridge"; // ES Modules import
- * // const { EventBridgeClient, DescribeEventBusCommand } = require("@aws-sdk/client-eventbridge"); // CommonJS import
- * const client = new EventBridgeClient(config);
- * const command = new DescribeEventBusCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeEventBusCommandInput} for command's `input` shape.
- * @see {@link DescribeEventBusCommandOutput} for command's `response` shape.
- * @see {@link EventBridgeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeEventBusCommand extends $Command<DescribeEventBusCommandInput, DescribeEventBusCommandOutput, EventBridgeClientResolvedConfig> {
     readonly input: DescribeEventBusCommandInput;
     constructor(input: DescribeEventBusCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EventBridgeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeEventBusCommandInput, DescribeEventBusCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface DescribeEventSourceCommandInput extends DescribeEventSourceRequ
 }
 export interface DescribeEventSourceCommandOutput extends DescribeEventSourceResponse, __MetadataBearer {
 }
-/**
- * <p>This operation lists details about a partner event source that is shared with your
- *       account.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EventBridgeClient, DescribeEventSourceCommand } from "@aws-sdk/client-eventbridge"; // ES Modules import
- * // const { EventBridgeClient, DescribeEventSourceCommand } = require("@aws-sdk/client-eventbridge"); // CommonJS import
- * const client = new EventBridgeClient(config);
- * const command = new DescribeEventSourceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeEventSourceCommandInput} for command's `input` shape.
- * @see {@link DescribeEventSourceCommandOutput} for command's `response` shape.
- * @see {@link EventBridgeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeEventSourceCommand extends $Command<DescribeEventSourceCommandInput, DescribeEventSourceCommandOutput, EventBridgeClientResolvedConfig> {
     readonly input: DescribeEventSourceCommandInput;
     constructor(input: DescribeEventSourceCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EventBridgeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeEventSourceCommandInput, DescribeEventSourceCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,32 +6,11 @@ export interface DescribePartnerEventSourceCommandInput extends DescribePartnerE
 }
 export interface DescribePartnerEventSourceCommandOutput extends DescribePartnerEventSourceResponse, __MetadataBearer {
 }
-/**
- * <p>An SaaS partner can use this operation to list details about a partner event source that
- *       they have created. Amazon Web Services customers do not use this operation. Instead, Amazon Web Services customers can use <a href="https://docs.aws.amazon.com/eventbridge/latest/APIReference/API_DescribeEventSource.html">DescribeEventSource</a>
- *       to see details about a partner event source that is
- *       shared with them.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EventBridgeClient, DescribePartnerEventSourceCommand } from "@aws-sdk/client-eventbridge"; // ES Modules import
- * // const { EventBridgeClient, DescribePartnerEventSourceCommand } = require("@aws-sdk/client-eventbridge"); // CommonJS import
- * const client = new EventBridgeClient(config);
- * const command = new DescribePartnerEventSourceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribePartnerEventSourceCommandInput} for command's `input` shape.
- * @see {@link DescribePartnerEventSourceCommandOutput} for command's `response` shape.
- * @see {@link EventBridgeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribePartnerEventSourceCommand extends $Command<DescribePartnerEventSourceCommandInput, DescribePartnerEventSourceCommandOutput, EventBridgeClientResolvedConfig> {
     readonly input: DescribePartnerEventSourceCommandInput;
     constructor(input: DescribePartnerEventSourceCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EventBridgeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribePartnerEventSourceCommandInput, DescribePartnerEventSourceCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,37 +6,11 @@ export interface DescribeReplayCommandInput extends DescribeReplayRequest {
 }
 export interface DescribeReplayCommandOutput extends DescribeReplayResponse, __MetadataBearer {
 }
-/**
- * <p>Retrieves details about a replay. Use <code>DescribeReplay</code> to determine the
- *       progress of a running replay. A replay processes events to replay based on the time in the
- *       event, and replays them using 1 minute intervals. If you use <code>StartReplay</code> and
- *       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, DescribeReplayCommand } from "@aws-sdk/client-eventbridge"; // ES Modules import
- * // const { EventBridgeClient, DescribeReplayCommand } = require("@aws-sdk/client-eventbridge"); // CommonJS import
- * const client = new EventBridgeClient(config);
- * const command = new DescribeReplayCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeReplayCommandInput} for command's `input` shape.
- * @see {@link DescribeReplayCommandOutput} for command's `response` shape.
- * @see {@link EventBridgeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeReplayCommand extends $Command<DescribeReplayCommandInput, DescribeReplayCommandOutput, EventBridgeClientResolvedConfig> {
     readonly input: DescribeReplayCommandInput;
     constructor(input: DescribeReplayCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EventBridgeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeReplayCommandInput, DescribeReplayCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,31 +6,11 @@ export interface DescribeRuleCommandInput extends DescribeRuleRequest {
 }
 export interface DescribeRuleCommandOutput extends DescribeRuleResponse, __MetadataBearer {
 }
-/**
- * <p>Describes the specified rule.</p>
- *          <p>DescribeRule 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, DescribeRuleCommand } from "@aws-sdk/client-eventbridge"; // ES Modules import
- * // const { EventBridgeClient, DescribeRuleCommand } = require("@aws-sdk/client-eventbridge"); // CommonJS import
- * const client = new EventBridgeClient(config);
- * const command = new DescribeRuleCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeRuleCommandInput} for command's `input` shape.
- * @see {@link DescribeRuleCommandOutput} for command's `response` shape.
- * @see {@link EventBridgeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeRuleCommand extends $Command<DescribeRuleCommandInput, DescribeRuleCommandOutput, EventBridgeClientResolvedConfig> {
     readonly input: DescribeRuleCommandInput;
     constructor(input: DescribeRuleCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EventBridgeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeRuleCommandInput, DescribeRuleCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,33 +6,11 @@ export interface DisableRuleCommandInput extends DisableRuleRequest {
 }
 export interface DisableRuleCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Disables the specified rule. A disabled rule won't match any events, and won't
- *       self-trigger if it has a schedule expression.</p>
- *
- *          <p>When you disable a rule, incoming events might continue to match to the disabled rule.
- *       Allow a short period of time for changes to take effect.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EventBridgeClient, DisableRuleCommand } from "@aws-sdk/client-eventbridge"; // ES Modules import
- * // const { EventBridgeClient, DisableRuleCommand } = require("@aws-sdk/client-eventbridge"); // CommonJS import
- * const client = new EventBridgeClient(config);
- * const command = new DisableRuleCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DisableRuleCommandInput} for command's `input` shape.
- * @see {@link DisableRuleCommandOutput} for command's `response` shape.
- * @see {@link EventBridgeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DisableRuleCommand extends $Command<DisableRuleCommandInput, DisableRuleCommandOutput, EventBridgeClientResolvedConfig> {
     readonly input: DisableRuleCommandInput;
     constructor(input: DisableRuleCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EventBridgeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DisableRuleCommandInput, DisableRuleCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,32 +6,11 @@ export interface EnableRuleCommandInput extends EnableRuleRequest {
 }
 export interface EnableRuleCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Enables the specified rule. If the rule does not exist, the operation fails.</p>
- *
- *          <p>When you enable a rule, incoming events might not immediately start matching to a newly
- *       enabled rule. Allow a short period of time for changes to take effect.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EventBridgeClient, EnableRuleCommand } from "@aws-sdk/client-eventbridge"; // ES Modules import
- * // const { EventBridgeClient, EnableRuleCommand } = require("@aws-sdk/client-eventbridge"); // CommonJS import
- * const client = new EventBridgeClient(config);
- * const command = new EnableRuleCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link EnableRuleCommandInput} for command's `input` shape.
- * @see {@link EnableRuleCommandOutput} for command's `response` shape.
- * @see {@link EventBridgeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class EnableRuleCommand extends $Command<EnableRuleCommandInput, EnableRuleCommandOutput, EventBridgeClientResolvedConfig> {
     readonly input: EnableRuleCommandInput;
     constructor(input: EnableRuleCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EventBridgeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<EnableRuleCommandInput, EnableRuleCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

@@ -6,30 +6,11 @@ export interface ListArchivesCommandInput extends ListArchivesRequest {
 }
 export interface ListArchivesCommandOutput extends ListArchivesResponse, __MetadataBearer {
 }
-/**
- * <p>Lists your archives. You can either list all the archives or you can provide a prefix to
- *       match to the archive 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, ListArchivesCommand } from "@aws-sdk/client-eventbridge"; // ES Modules import
- * // const { EventBridgeClient, ListArchivesCommand } = require("@aws-sdk/client-eventbridge"); // CommonJS import
- * const client = new EventBridgeClient(config);
- * const command = new ListArchivesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListArchivesCommandInput} for command's `input` shape.
- * @see {@link ListArchivesCommandOutput} for command's `response` shape.
- * @see {@link EventBridgeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListArchivesCommand extends $Command<ListArchivesCommandInput, ListArchivesCommandOutput, EventBridgeClientResolvedConfig> {
     readonly input: ListArchivesCommandInput;
     constructor(input: ListArchivesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EventBridgeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListArchivesCommandInput, ListArchivesCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

@@ -6,30 +6,11 @@ export interface ListEventBusesCommandInput extends ListEventBusesRequest {
 }
 export interface ListEventBusesCommandOutput extends ListEventBusesResponse, __MetadataBearer {
 }
-/**
- * <p>Lists all the event buses in your account, including the default event bus, custom event
- *       buses, and partner event buses.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EventBridgeClient, ListEventBusesCommand } from "@aws-sdk/client-eventbridge"; // ES Modules import
- * // const { EventBridgeClient, ListEventBusesCommand } = require("@aws-sdk/client-eventbridge"); // CommonJS import
- * const client = new EventBridgeClient(config);
- * const command = new ListEventBusesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListEventBusesCommandInput} for command's `input` shape.
- * @see {@link ListEventBusesCommandOutput} for command's `response` shape.
- * @see {@link EventBridgeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListEventBusesCommand extends $Command<ListEventBusesCommandInput, ListEventBusesCommandOutput, EventBridgeClientResolvedConfig> {
     readonly input: ListEventBusesCommandInput;
     constructor(input: ListEventBusesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EventBridgeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListEventBusesCommandInput, ListEventBusesCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface ListEventSourcesCommandInput extends ListEventSourcesRequest {
 }
 export interface ListEventSourcesCommandOutput extends ListEventSourcesResponse, __MetadataBearer {
 }
-/**
- * <p>You can use this to see all the partner event sources that have been shared with your Amazon Web Services
- *       account. For more information about partner event sources, see <a href="https://docs.aws.amazon.com/eventbridge/latest/APIReference/API_CreateEventBus.html">CreateEventBus</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EventBridgeClient, ListEventSourcesCommand } from "@aws-sdk/client-eventbridge"; // ES Modules import
- * // const { EventBridgeClient, ListEventSourcesCommand } = require("@aws-sdk/client-eventbridge"); // CommonJS import
- * const client = new EventBridgeClient(config);
- * const command = new ListEventSourcesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListEventSourcesCommandInput} for command's `input` shape.
- * @see {@link ListEventSourcesCommandOutput} for command's `response` shape.
- * @see {@link EventBridgeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListEventSourcesCommand extends $Command<ListEventSourcesCommandInput, ListEventSourcesCommandOutput, EventBridgeClientResolvedConfig> {
     readonly input: ListEventSourcesCommandInput;
     constructor(input: ListEventSourcesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EventBridgeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListEventSourcesCommandInput, ListEventSourcesCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,31 +6,11 @@ export interface ListPartnerEventSourceAccountsCommandInput extends ListPartnerE
 }
 export interface ListPartnerEventSourceAccountsCommandOutput extends ListPartnerEventSourceAccountsResponse, __MetadataBearer {
 }
-/**
- * <p>An SaaS partner can use this operation to display the Amazon Web Services account ID that a particular
- *       partner event source name is associated with. 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, ListPartnerEventSourceAccountsCommand } from "@aws-sdk/client-eventbridge"; // ES Modules import
- * // const { EventBridgeClient, ListPartnerEventSourceAccountsCommand } = require("@aws-sdk/client-eventbridge"); // CommonJS import
- * const client = new EventBridgeClient(config);
- * const command = new ListPartnerEventSourceAccountsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListPartnerEventSourceAccountsCommandInput} for command's `input` shape.
- * @see {@link ListPartnerEventSourceAccountsCommandOutput} for command's `response` shape.
- * @see {@link EventBridgeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListPartnerEventSourceAccountsCommand extends $Command<ListPartnerEventSourceAccountsCommandInput, ListPartnerEventSourceAccountsCommandOutput, EventBridgeClientResolvedConfig> {
     readonly input: ListPartnerEventSourceAccountsCommandInput;
     constructor(input: ListPartnerEventSourceAccountsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EventBridgeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListPartnerEventSourceAccountsCommandInput, ListPartnerEventSourceAccountsCommandOutput>;
     private serialize;
     private deserialize;