@aws-sdk/client-eventbridge 3.295.0 → 3.297.0

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { EventBridgeClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EventBridgeClient";
 import { DeletePartnerEventSourceRequest } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link DeletePartnerEventSourceCommand}.
  */
 export interface DeletePartnerEventSourceCommandInput extends DeletePartnerEventSourceRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link DeletePartnerEventSourceCommand}.
  */
 export interface DeletePartnerEventSourceCommandOutput extends __MetadataBearer {
 }
 /**
+ * @public
  * <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
@@ -29,6 +34,8 @@ export interface DeletePartnerEventSourceCommandOutput extends __MetadataBearer
  * const response = await client.send(command);
  * ```
  *
+ * @param DeletePartnerEventSourceCommandInput - {@link DeletePartnerEventSourceCommandInput}
+ * @returns {@link DeletePartnerEventSourceCommandOutput}
  * @see {@link DeletePartnerEventSourceCommandInput} for command's `input` shape.
  * @see {@link DeletePartnerEventSourceCommandOutput} for command's `response` shape.
  * @see {@link EventBridgeClientResolvedConfig | config} for EventBridgeClient's `config` shape.
@@ -47,11 +54,20 @@ export interface DeletePartnerEventSourceCommandOutput extends __MetadataBearer
 export declare class DeletePartnerEventSourceCommand extends $Command<DeletePartnerEventSourceCommandInput, DeletePartnerEventSourceCommandOutput, EventBridgeClientResolvedConfig> {
     readonly input: DeletePartnerEventSourceCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: DeletePartnerEventSourceCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EventBridgeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeletePartnerEventSourceCommandInput, DeletePartnerEventSourceCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { EventBridgeClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EventBridgeClient";
 import { DeleteRuleRequest } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link DeleteRuleCommand}.
  */
 export interface DeleteRuleCommandInput extends DeleteRuleRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link DeleteRuleCommand}.
  */
 export interface DeleteRuleCommandOutput extends __MetadataBearer {
 }
 /**
+ * @public
  * <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
@@ -35,6 +40,8 @@ export interface DeleteRuleCommandOutput extends __MetadataBearer {
  * const response = await client.send(command);
  * ```
  *
+ * @param DeleteRuleCommandInput - {@link DeleteRuleCommandInput}
+ * @returns {@link DeleteRuleCommandOutput}
  * @see {@link DeleteRuleCommandInput} for command's `input` shape.
  * @see {@link DeleteRuleCommandOutput} for command's `response` shape.
  * @see {@link EventBridgeClientResolvedConfig | config} for EventBridgeClient's `config` shape.
@@ -61,11 +68,20 @@ export interface DeleteRuleCommandOutput extends __MetadataBearer {
 export declare class DeleteRuleCommand extends $Command<DeleteRuleCommandInput, DeleteRuleCommandOutput, EventBridgeClientResolvedConfig> {
     readonly input: DeleteRuleCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: DeleteRuleCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EventBridgeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteRuleCommandInput, DeleteRuleCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { EventBridgeClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EventBridgeClient";
 import { DescribeApiDestinationRequest, DescribeApiDestinationResponse } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link DescribeApiDestinationCommand}.
  */
 export interface DescribeApiDestinationCommandInput extends DescribeApiDestinationRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link DescribeApiDestinationCommand}.
  */
 export interface DescribeApiDestinationCommandOutput extends DescribeApiDestinationResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Retrieves details about an API destination.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
@@ -25,6 +30,8 @@ export interface DescribeApiDestinationCommandOutput extends DescribeApiDestinat
  * const response = await client.send(command);
  * ```
  *
+ * @param DescribeApiDestinationCommandInput - {@link DescribeApiDestinationCommandInput}
+ * @returns {@link DescribeApiDestinationCommandOutput}
  * @see {@link DescribeApiDestinationCommandInput} for command's `input` shape.
  * @see {@link DescribeApiDestinationCommandOutput} for command's `response` shape.
  * @see {@link EventBridgeClientResolvedConfig | config} for EventBridgeClient's `config` shape.
@@ -40,11 +47,20 @@ export interface DescribeApiDestinationCommandOutput extends DescribeApiDestinat
 export declare class DescribeApiDestinationCommand extends $Command<DescribeApiDestinationCommandInput, DescribeApiDestinationCommandOutput, EventBridgeClientResolvedConfig> {
     readonly input: DescribeApiDestinationCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: DescribeApiDestinationCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EventBridgeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeApiDestinationCommandInput, DescribeApiDestinationCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { EventBridgeClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EventBridgeClient";
 import { DescribeArchiveRequest, DescribeArchiveResponse } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link DescribeArchiveCommand}.
  */
 export interface DescribeArchiveCommandInput extends DescribeArchiveRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link DescribeArchiveCommand}.
  */
 export interface DescribeArchiveCommandOutput extends DescribeArchiveResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Retrieves details about an archive.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
@@ -25,6 +30,8 @@ export interface DescribeArchiveCommandOutput extends DescribeArchiveResponse, _
  * const response = await client.send(command);
  * ```
  *
+ * @param DescribeArchiveCommandInput - {@link DescribeArchiveCommandInput}
+ * @returns {@link DescribeArchiveCommandOutput}
  * @see {@link DescribeArchiveCommandInput} for command's `input` shape.
  * @see {@link DescribeArchiveCommandOutput} for command's `response` shape.
  * @see {@link EventBridgeClientResolvedConfig | config} for EventBridgeClient's `config` shape.
@@ -43,11 +50,20 @@ export interface DescribeArchiveCommandOutput extends DescribeArchiveResponse, _
 export declare class DescribeArchiveCommand extends $Command<DescribeArchiveCommandInput, DescribeArchiveCommandOutput, EventBridgeClientResolvedConfig> {
     readonly input: DescribeArchiveCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: DescribeArchiveCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EventBridgeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeArchiveCommandInput, DescribeArchiveCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { EventBridgeClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EventBridgeClient";
 import { DescribeConnectionRequest, DescribeConnectionResponse } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link DescribeConnectionCommand}.
  */
 export interface DescribeConnectionCommandInput extends DescribeConnectionRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link DescribeConnectionCommand}.
  */
 export interface DescribeConnectionCommandOutput extends DescribeConnectionResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Retrieves details about a connection.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
@@ -25,6 +30,8 @@ export interface DescribeConnectionCommandOutput extends DescribeConnectionRespo
  * const response = await client.send(command);
  * ```
  *
+ * @param DescribeConnectionCommandInput - {@link DescribeConnectionCommandInput}
+ * @returns {@link DescribeConnectionCommandOutput}
  * @see {@link DescribeConnectionCommandInput} for command's `input` shape.
  * @see {@link DescribeConnectionCommandOutput} for command's `response` shape.
  * @see {@link EventBridgeClientResolvedConfig | config} for EventBridgeClient's `config` shape.
@@ -40,11 +47,20 @@ export interface DescribeConnectionCommandOutput extends DescribeConnectionRespo
 export declare class DescribeConnectionCommand extends $Command<DescribeConnectionCommandInput, DescribeConnectionCommandOutput, EventBridgeClientResolvedConfig> {
     readonly input: DescribeConnectionCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: DescribeConnectionCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EventBridgeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeConnectionCommandInput, DescribeConnectionCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { EventBridgeClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EventBridgeClient";
 import { DescribeEndpointRequest, DescribeEndpointResponse } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link DescribeEndpointCommand}.
  */
 export interface DescribeEndpointCommandInput extends DescribeEndpointRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link DescribeEndpointCommand}.
  */
 export interface DescribeEndpointCommandOutput extends DescribeEndpointResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Get the information about an existing global endpoint. For more information about global endpoints, see <a href="https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-global-endpoints.html">Making applications Regional-fault tolerant with global endpoints and event replication</a> in the Amazon EventBridge User Guide..</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
@@ -25,6 +30,8 @@ export interface DescribeEndpointCommandOutput extends DescribeEndpointResponse,
  * const response = await client.send(command);
  * ```
  *
+ * @param DescribeEndpointCommandInput - {@link DescribeEndpointCommandInput}
+ * @returns {@link DescribeEndpointCommandOutput}
  * @see {@link DescribeEndpointCommandInput} for command's `input` shape.
  * @see {@link DescribeEndpointCommandOutput} for command's `response` shape.
  * @see {@link EventBridgeClientResolvedConfig | config} for EventBridgeClient's `config` shape.
@@ -40,11 +47,20 @@ export interface DescribeEndpointCommandOutput extends DescribeEndpointResponse,
 export declare class DescribeEndpointCommand extends $Command<DescribeEndpointCommandInput, DescribeEndpointCommandOutput, EventBridgeClientResolvedConfig> {
     readonly input: DescribeEndpointCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: DescribeEndpointCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EventBridgeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeEndpointCommandInput, DescribeEndpointCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { EventBridgeClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EventBridgeClient";
 import { DescribeEventBusRequest, DescribeEventBusResponse } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link DescribeEventBusCommand}.
  */
 export interface DescribeEventBusCommandInput extends DescribeEventBusRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link DescribeEventBusCommand}.
  */
 export interface DescribeEventBusCommandOutput extends DescribeEventBusResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <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,
@@ -31,6 +36,8 @@ export interface DescribeEventBusCommandOutput extends DescribeEventBusResponse,
  * const response = await client.send(command);
  * ```
  *
+ * @param DescribeEventBusCommandInput - {@link DescribeEventBusCommandInput}
+ * @returns {@link DescribeEventBusCommandOutput}
  * @see {@link DescribeEventBusCommandInput} for command's `input` shape.
  * @see {@link DescribeEventBusCommandOutput} for command's `response` shape.
  * @see {@link EventBridgeClientResolvedConfig | config} for EventBridgeClient's `config` shape.
@@ -46,11 +53,20 @@ export interface DescribeEventBusCommandOutput extends DescribeEventBusResponse,
 export declare class DescribeEventBusCommand extends $Command<DescribeEventBusCommandInput, DescribeEventBusCommandOutput, EventBridgeClientResolvedConfig> {
     readonly input: DescribeEventBusCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: DescribeEventBusCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EventBridgeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeEventBusCommandInput, DescribeEventBusCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { EventBridgeClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EventBridgeClient";
 import { DescribeEventSourceRequest, DescribeEventSourceResponse } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link DescribeEventSourceCommand}.
  */
 export interface DescribeEventSourceCommandInput extends DescribeEventSourceRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link DescribeEventSourceCommand}.
  */
 export interface DescribeEventSourceCommandOutput extends DescribeEventSourceResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <p>This operation lists details about a partner event source that is shared with your
  *       account.</p>
  * @example
@@ -26,6 +31,8 @@ export interface DescribeEventSourceCommandOutput extends DescribeEventSourceRes
  * const response = await client.send(command);
  * ```
  *
+ * @param DescribeEventSourceCommandInput - {@link DescribeEventSourceCommandInput}
+ * @returns {@link DescribeEventSourceCommandOutput}
  * @see {@link DescribeEventSourceCommandInput} for command's `input` shape.
  * @see {@link DescribeEventSourceCommandOutput} for command's `response` shape.
  * @see {@link EventBridgeClientResolvedConfig | config} for EventBridgeClient's `config` shape.
@@ -44,11 +51,20 @@ export interface DescribeEventSourceCommandOutput extends DescribeEventSourceRes
 export declare class DescribeEventSourceCommand extends $Command<DescribeEventSourceCommandInput, DescribeEventSourceCommandOutput, EventBridgeClientResolvedConfig> {
     readonly input: DescribeEventSourceCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: DescribeEventSourceCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EventBridgeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeEventSourceCommandInput, DescribeEventSourceCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { EventBridgeClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EventBridgeClient";
 import { DescribePartnerEventSourceRequest, DescribePartnerEventSourceResponse } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link DescribePartnerEventSourceCommand}.
  */
 export interface DescribePartnerEventSourceCommandInput extends DescribePartnerEventSourceRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link DescribePartnerEventSourceCommand}.
  */
 export interface DescribePartnerEventSourceCommandOutput extends DescribePartnerEventSourceResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <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
@@ -28,6 +33,8 @@ export interface DescribePartnerEventSourceCommandOutput extends DescribePartner
  * const response = await client.send(command);
  * ```
  *
+ * @param DescribePartnerEventSourceCommandInput - {@link DescribePartnerEventSourceCommandInput}
+ * @returns {@link DescribePartnerEventSourceCommandOutput}
  * @see {@link DescribePartnerEventSourceCommandInput} for command's `input` shape.
  * @see {@link DescribePartnerEventSourceCommandOutput} for command's `response` shape.
  * @see {@link EventBridgeClientResolvedConfig | config} for EventBridgeClient's `config` shape.
@@ -46,11 +53,20 @@ export interface DescribePartnerEventSourceCommandOutput extends DescribePartner
 export declare class DescribePartnerEventSourceCommand extends $Command<DescribePartnerEventSourceCommandInput, DescribePartnerEventSourceCommandOutput, EventBridgeClientResolvedConfig> {
     readonly input: DescribePartnerEventSourceCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: DescribePartnerEventSourceCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EventBridgeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribePartnerEventSourceCommandInput, DescribePartnerEventSourceCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { EventBridgeClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EventBridgeClient";
 import { DescribeReplayRequest, DescribeReplayResponse } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link DescribeReplayCommand}.
  */
 export interface DescribeReplayCommandInput extends DescribeReplayRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link DescribeReplayCommand}.
  */
 export interface DescribeReplayCommandOutput extends DescribeReplayResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <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
@@ -33,6 +38,8 @@ export interface DescribeReplayCommandOutput extends DescribeReplayResponse, __M
  * const response = await client.send(command);
  * ```
  *
+ * @param DescribeReplayCommandInput - {@link DescribeReplayCommandInput}
+ * @returns {@link DescribeReplayCommandOutput}
  * @see {@link DescribeReplayCommandInput} for command's `input` shape.
  * @see {@link DescribeReplayCommandOutput} for command's `response` shape.
  * @see {@link EventBridgeClientResolvedConfig | config} for EventBridgeClient's `config` shape.
@@ -48,11 +55,20 @@ export interface DescribeReplayCommandOutput extends DescribeReplayResponse, __M
 export declare class DescribeReplayCommand extends $Command<DescribeReplayCommandInput, DescribeReplayCommandOutput, EventBridgeClientResolvedConfig> {
     readonly input: DescribeReplayCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: DescribeReplayCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EventBridgeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeReplayCommandInput, DescribeReplayCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { EventBridgeClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EventBridgeClient";
 import { DescribeRuleRequest, DescribeRuleResponse } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link DescribeRuleCommand}.
  */
 export interface DescribeRuleCommandInput extends DescribeRuleRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link DescribeRuleCommand}.
  */
 export interface DescribeRuleCommandOutput extends DescribeRuleResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <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>
@@ -27,6 +32,8 @@ export interface DescribeRuleCommandOutput extends DescribeRuleResponse, __Metad
  * const response = await client.send(command);
  * ```
  *
+ * @param DescribeRuleCommandInput - {@link DescribeRuleCommandInput}
+ * @returns {@link DescribeRuleCommandOutput}
  * @see {@link DescribeRuleCommandInput} for command's `input` shape.
  * @see {@link DescribeRuleCommandOutput} for command's `response` shape.
  * @see {@link EventBridgeClientResolvedConfig | config} for EventBridgeClient's `config` shape.
@@ -42,11 +49,20 @@ export interface DescribeRuleCommandOutput extends DescribeRuleResponse, __Metad
 export declare class DescribeRuleCommand extends $Command<DescribeRuleCommandInput, DescribeRuleCommandOutput, EventBridgeClientResolvedConfig> {
     readonly input: DescribeRuleCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: DescribeRuleCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EventBridgeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeRuleCommandInput, DescribeRuleCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { EventBridgeClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EventBridgeClient";
 import { DisableRuleRequest } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link DisableRuleCommand}.
  */
 export interface DisableRuleCommandInput extends DisableRuleRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link DisableRuleCommand}.
  */
 export interface DisableRuleCommandOutput extends __MetadataBearer {
 }
 /**
+ * @public
  * <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.
@@ -28,6 +33,8 @@ export interface DisableRuleCommandOutput extends __MetadataBearer {
  * const response = await client.send(command);
  * ```
  *
+ * @param DisableRuleCommandInput - {@link DisableRuleCommandInput}
+ * @returns {@link DisableRuleCommandOutput}
  * @see {@link DisableRuleCommandInput} for command's `input` shape.
  * @see {@link DisableRuleCommandOutput} for command's `response` shape.
  * @see {@link EventBridgeClientResolvedConfig | config} for EventBridgeClient's `config` shape.
@@ -54,11 +61,20 @@ export interface DisableRuleCommandOutput extends __MetadataBearer {
 export declare class DisableRuleCommand extends $Command<DisableRuleCommandInput, DisableRuleCommandOutput, EventBridgeClientResolvedConfig> {
     readonly input: DisableRuleCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: DisableRuleCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EventBridgeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DisableRuleCommandInput, DisableRuleCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { EventBridgeClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EventBridgeClient";
 import { EnableRuleRequest } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link EnableRuleCommand}.
  */
 export interface EnableRuleCommandInput extends EnableRuleRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link EnableRuleCommand}.
  */
 export interface EnableRuleCommandOutput extends __MetadataBearer {
 }
 /**
+ * @public
  * <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>
@@ -27,6 +32,8 @@ export interface EnableRuleCommandOutput extends __MetadataBearer {
  * const response = await client.send(command);
  * ```
  *
+ * @param EnableRuleCommandInput - {@link EnableRuleCommandInput}
+ * @returns {@link EnableRuleCommandOutput}
  * @see {@link EnableRuleCommandInput} for command's `input` shape.
  * @see {@link EnableRuleCommandOutput} for command's `response` shape.
  * @see {@link EventBridgeClientResolvedConfig | config} for EventBridgeClient's `config` shape.
@@ -53,11 +60,20 @@ export interface EnableRuleCommandOutput extends __MetadataBearer {
 export declare class EnableRuleCommand extends $Command<EnableRuleCommandInput, EnableRuleCommandOutput, EventBridgeClientResolvedConfig> {
     readonly input: EnableRuleCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: EnableRuleCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EventBridgeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<EnableRuleCommandInput, EnableRuleCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }