@aws-sdk/client-eventbridge 3.296.0 → 3.297.0

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { EventBridgeClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EventBridgeClient";
 import { CreateApiDestinationRequest, CreateApiDestinationResponse } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link CreateApiDestinationCommand}.
  */
 export interface CreateApiDestinationCommandInput extends CreateApiDestinationRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateApiDestinationCommand}.
  */
 export interface CreateApiDestinationCommandOutput extends CreateApiDestinationResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Creates an API destination, which is an HTTP invocation endpoint configured as a target
  *       for events.</p>
  * @example
@@ -26,6 +31,8 @@ export interface CreateApiDestinationCommandOutput extends CreateApiDestinationR
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateApiDestinationCommandInput - {@link CreateApiDestinationCommandInput}
+ * @returns {@link CreateApiDestinationCommandOutput}
  * @see {@link CreateApiDestinationCommandInput} for command's `input` shape.
  * @see {@link CreateApiDestinationCommandOutput} for command's `response` shape.
  * @see {@link EventBridgeClientResolvedConfig | config} for EventBridgeClient's `config` shape.
@@ -48,11 +55,20 @@ export interface CreateApiDestinationCommandOutput extends CreateApiDestinationR
 export declare class CreateApiDestinationCommand extends $Command<CreateApiDestinationCommandInput, CreateApiDestinationCommandOutput, EventBridgeClientResolvedConfig> {
     readonly input: CreateApiDestinationCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateApiDestinationCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EventBridgeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateApiDestinationCommandInput, CreateApiDestinationCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { EventBridgeClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EventBridgeClient";
 import { CreateArchiveRequest, CreateArchiveResponse } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link CreateArchiveCommand}.
  */
 export interface CreateArchiveCommandInput extends CreateArchiveRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateArchiveCommand}.
  */
 export interface CreateArchiveCommandOutput extends CreateArchiveResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Creates an archive of events with the specified settings. When you create an archive,
  *       incoming events might not immediately start being sent to the archive. Allow a short period of
  *       time for changes to take effect. If you do not specify a pattern to filter events sent to the
@@ -29,6 +34,8 @@ export interface CreateArchiveCommandOutput extends CreateArchiveResponse, __Met
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateArchiveCommandInput - {@link CreateArchiveCommandInput}
+ * @returns {@link CreateArchiveCommandOutput}
  * @see {@link CreateArchiveCommandInput} for command's `input` shape.
  * @see {@link CreateArchiveCommandOutput} for command's `response` shape.
  * @see {@link EventBridgeClientResolvedConfig | config} for EventBridgeClient's `config` shape.
@@ -57,11 +64,20 @@ export interface CreateArchiveCommandOutput extends CreateArchiveResponse, __Met
 export declare class CreateArchiveCommand extends $Command<CreateArchiveCommandInput, CreateArchiveCommandOutput, EventBridgeClientResolvedConfig> {
     readonly input: CreateArchiveCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateArchiveCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EventBridgeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateArchiveCommandInput, CreateArchiveCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { EventBridgeClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EventBridgeClient";
 import { CreateConnectionRequest, CreateConnectionResponse } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link CreateConnectionCommand}.
  */
 export interface CreateConnectionCommandInput extends CreateConnectionRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateConnectionCommand}.
  */
 export interface CreateConnectionCommandOutput extends CreateConnectionResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Creates a connection. A connection defines the authorization type and credentials to use
  *       for authorization with an API destination HTTP endpoint.</p>
  * @example
@@ -26,6 +31,8 @@ export interface CreateConnectionCommandOutput extends CreateConnectionResponse,
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateConnectionCommandInput - {@link CreateConnectionCommandInput}
+ * @returns {@link CreateConnectionCommandOutput}
  * @see {@link CreateConnectionCommandInput} for command's `input` shape.
  * @see {@link CreateConnectionCommandOutput} for command's `response` shape.
  * @see {@link EventBridgeClientResolvedConfig | config} for EventBridgeClient's `config` shape.
@@ -45,11 +52,20 @@ export interface CreateConnectionCommandOutput extends CreateConnectionResponse,
 export declare class CreateConnectionCommand extends $Command<CreateConnectionCommandInput, CreateConnectionCommandOutput, EventBridgeClientResolvedConfig> {
     readonly input: CreateConnectionCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateConnectionCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EventBridgeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateConnectionCommandInput, CreateConnectionCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { EventBridgeClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EventBridgeClient";
 import { CreateEndpointRequest, CreateEndpointResponse } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link CreateEndpointCommand}.
  */
 export interface CreateEndpointCommandInput extends CreateEndpointRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateEndpointCommand}.
  */
 export interface CreateEndpointCommandOutput extends CreateEndpointResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Creates a global endpoint. Global endpoints improve your application's availability by making it regional-fault tolerant. To do this, you define a primary and secondary Region
  *       with event buses in each Region. You also create a Amazon Route 53 health check that will tell EventBridge to route events to the secondary Region when an "unhealthy" state
  *       is encountered and events will be routed back to the primary Region when the health check reports a "healthy" state.</p>
@@ -27,6 +32,8 @@ export interface CreateEndpointCommandOutput extends CreateEndpointResponse, __M
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateEndpointCommandInput - {@link CreateEndpointCommandInput}
+ * @returns {@link CreateEndpointCommandOutput}
  * @see {@link CreateEndpointCommandInput} for command's `input` shape.
  * @see {@link CreateEndpointCommandOutput} for command's `response` shape.
  * @see {@link EventBridgeClientResolvedConfig | config} for EventBridgeClient's `config` shape.
@@ -46,11 +53,20 @@ export interface CreateEndpointCommandOutput extends CreateEndpointResponse, __M
 export declare class CreateEndpointCommand extends $Command<CreateEndpointCommandInput, CreateEndpointCommandOutput, EventBridgeClientResolvedConfig> {
     readonly input: CreateEndpointCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateEndpointCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EventBridgeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateEndpointCommandInput, CreateEndpointCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { EventBridgeClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EventBridgeClient";
 import { CreateEventBusRequest, CreateEventBusResponse } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link CreateEventBusCommand}.
  */
 export interface CreateEventBusCommandInput extends CreateEventBusRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateEventBusCommand}.
  */
 export interface CreateEventBusCommandOutput extends CreateEventBusResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Creates a new event bus within your account. This can be a custom event bus which you can
  *       use to receive events from your custom applications and services, or it can be a partner event
  *       bus which can be matched to a partner event source.</p>
@@ -27,6 +32,8 @@ export interface CreateEventBusCommandOutput extends CreateEventBusResponse, __M
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateEventBusCommandInput - {@link CreateEventBusCommandInput}
+ * @returns {@link CreateEventBusCommandOutput}
  * @see {@link CreateEventBusCommandInput} for command's `input` shape.
  * @see {@link CreateEventBusCommandOutput} for command's `response` shape.
  * @see {@link EventBridgeClientResolvedConfig | config} for EventBridgeClient's `config` shape.
@@ -58,11 +65,20 @@ export interface CreateEventBusCommandOutput extends CreateEventBusResponse, __M
 export declare class CreateEventBusCommand extends $Command<CreateEventBusCommandInput, CreateEventBusCommandOutput, EventBridgeClientResolvedConfig> {
     readonly input: CreateEventBusCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateEventBusCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EventBridgeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateEventBusCommandInput, CreateEventBusCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { EventBridgeClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EventBridgeClient";
 import { CreatePartnerEventSourceRequest, CreatePartnerEventSourceResponse } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link CreatePartnerEventSourceCommand}.
  */
 export interface CreatePartnerEventSourceCommandInput extends CreatePartnerEventSourceRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreatePartnerEventSourceCommand}.
  */
 export interface CreatePartnerEventSourceCommandOutput extends CreatePartnerEventSourceResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Called by an SaaS partner to create a partner event source. This operation is not used by
  *       Amazon Web Services customers.</p>
  *          <p>Each partner event source can be used by one Amazon Web Services account to create a matching partner
@@ -48,6 +53,8 @@ export interface CreatePartnerEventSourceCommandOutput extends CreatePartnerEven
  * const response = await client.send(command);
  * ```
  *
+ * @param CreatePartnerEventSourceCommandInput - {@link CreatePartnerEventSourceCommandInput}
+ * @returns {@link CreatePartnerEventSourceCommandOutput}
  * @see {@link CreatePartnerEventSourceCommandInput} for command's `input` shape.
  * @see {@link CreatePartnerEventSourceCommandOutput} for command's `response` shape.
  * @see {@link EventBridgeClientResolvedConfig | config} for EventBridgeClient's `config` shape.
@@ -73,11 +80,20 @@ export interface CreatePartnerEventSourceCommandOutput extends CreatePartnerEven
 export declare class CreatePartnerEventSourceCommand extends $Command<CreatePartnerEventSourceCommandInput, CreatePartnerEventSourceCommandOutput, EventBridgeClientResolvedConfig> {
     readonly input: CreatePartnerEventSourceCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreatePartnerEventSourceCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EventBridgeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreatePartnerEventSourceCommandInput, CreatePartnerEventSourceCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { EventBridgeClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EventBridgeClient";
 import { DeactivateEventSourceRequest } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link DeactivateEventSourceCommand}.
  */
 export interface DeactivateEventSourceCommandInput extends DeactivateEventSourceRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link DeactivateEventSourceCommand}.
  */
 export interface DeactivateEventSourceCommandOutput extends __MetadataBearer {
 }
 /**
+ * @public
  * <p>You can use this operation to temporarily stop receiving events from the specified partner
  *       event source. The matching event bus is not deleted. </p>
  *          <p>When you deactivate a partner event source, the source goes into PENDING state. If it
@@ -29,6 +34,8 @@ export interface DeactivateEventSourceCommandOutput extends __MetadataBearer {
  * const response = await client.send(command);
  * ```
  *
+ * @param DeactivateEventSourceCommandInput - {@link DeactivateEventSourceCommandInput}
+ * @returns {@link DeactivateEventSourceCommandOutput}
  * @see {@link DeactivateEventSourceCommandInput} for command's `input` shape.
  * @see {@link DeactivateEventSourceCommandOutput} for command's `response` shape.
  * @see {@link EventBridgeClientResolvedConfig | config} for EventBridgeClient's `config` shape.
@@ -53,11 +60,20 @@ export interface DeactivateEventSourceCommandOutput extends __MetadataBearer {
 export declare class DeactivateEventSourceCommand extends $Command<DeactivateEventSourceCommandInput, DeactivateEventSourceCommandOutput, EventBridgeClientResolvedConfig> {
     readonly input: DeactivateEventSourceCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: DeactivateEventSourceCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EventBridgeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeactivateEventSourceCommandInput, DeactivateEventSourceCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { EventBridgeClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EventBridgeClient";
 import { DeauthorizeConnectionRequest, DeauthorizeConnectionResponse } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link DeauthorizeConnectionCommand}.
  */
 export interface DeauthorizeConnectionCommandInput extends DeauthorizeConnectionRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link DeauthorizeConnectionCommand}.
  */
 export interface DeauthorizeConnectionCommandOutput extends DeauthorizeConnectionResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Removes all authorization parameters from the connection. This lets you remove the secret
  *       from the connection so you can reuse it without having to create a new connection.</p>
  * @example
@@ -26,6 +31,8 @@ export interface DeauthorizeConnectionCommandOutput extends DeauthorizeConnectio
  * const response = await client.send(command);
  * ```
  *
+ * @param DeauthorizeConnectionCommandInput - {@link DeauthorizeConnectionCommandInput}
+ * @returns {@link DeauthorizeConnectionCommandOutput}
  * @see {@link DeauthorizeConnectionCommandInput} for command's `input` shape.
  * @see {@link DeauthorizeConnectionCommandOutput} for command's `response` shape.
  * @see {@link EventBridgeClientResolvedConfig | config} for EventBridgeClient's `config` shape.
@@ -44,11 +51,20 @@ export interface DeauthorizeConnectionCommandOutput extends DeauthorizeConnectio
 export declare class DeauthorizeConnectionCommand extends $Command<DeauthorizeConnectionCommandInput, DeauthorizeConnectionCommandOutput, EventBridgeClientResolvedConfig> {
     readonly input: DeauthorizeConnectionCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: DeauthorizeConnectionCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EventBridgeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeauthorizeConnectionCommandInput, DeauthorizeConnectionCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { EventBridgeClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EventBridgeClient";
 import { DeleteApiDestinationRequest, DeleteApiDestinationResponse } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link DeleteApiDestinationCommand}.
  */
 export interface DeleteApiDestinationCommandInput extends DeleteApiDestinationRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link DeleteApiDestinationCommand}.
  */
 export interface DeleteApiDestinationCommandOutput extends DeleteApiDestinationResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Deletes the specified 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 DeleteApiDestinationCommandOutput extends DeleteApiDestinationR
  * const response = await client.send(command);
  * ```
  *
+ * @param DeleteApiDestinationCommandInput - {@link DeleteApiDestinationCommandInput}
+ * @returns {@link DeleteApiDestinationCommandOutput}
  * @see {@link DeleteApiDestinationCommandInput} for command's `input` shape.
  * @see {@link DeleteApiDestinationCommandOutput} for command's `response` shape.
  * @see {@link EventBridgeClientResolvedConfig | config} for EventBridgeClient's `config` shape.
@@ -43,11 +50,20 @@ export interface DeleteApiDestinationCommandOutput extends DeleteApiDestinationR
 export declare class DeleteApiDestinationCommand extends $Command<DeleteApiDestinationCommandInput, DeleteApiDestinationCommandOutput, EventBridgeClientResolvedConfig> {
     readonly input: DeleteApiDestinationCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: DeleteApiDestinationCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EventBridgeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteApiDestinationCommandInput, DeleteApiDestinationCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

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

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

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

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

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

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { EventBridgeClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EventBridgeClient";
 import { DeleteEventBusRequest } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link DeleteEventBusCommand}.
  */
 export interface DeleteEventBusCommandInput extends DeleteEventBusRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link DeleteEventBusCommand}.
  */
 export interface DeleteEventBusCommandOutput extends __MetadataBearer {
 }
 /**
+ * @public
  * <p>Deletes the specified custom event bus or partner event bus. All rules associated with
  *       this event bus need to be deleted. You can't delete your account's default event bus.</p>
  * @example
@@ -26,6 +31,8 @@ export interface DeleteEventBusCommandOutput extends __MetadataBearer {
  * const response = await client.send(command);
  * ```
  *
+ * @param DeleteEventBusCommandInput - {@link DeleteEventBusCommandInput}
+ * @returns {@link DeleteEventBusCommandOutput}
  * @see {@link DeleteEventBusCommandInput} for command's `input` shape.
  * @see {@link DeleteEventBusCommandOutput} for command's `response` shape.
  * @see {@link EventBridgeClientResolvedConfig | config} for EventBridgeClient's `config` shape.
@@ -41,11 +48,20 @@ export interface DeleteEventBusCommandOutput extends __MetadataBearer {
 export declare class DeleteEventBusCommand extends $Command<DeleteEventBusCommandInput, DeleteEventBusCommandOutput, EventBridgeClientResolvedConfig> {
     readonly input: DeleteEventBusCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: DeleteEventBusCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EventBridgeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteEventBusCommandInput, DeleteEventBusCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }