@aws-sdk/client-eventbridge 3.296.0 → 3.298.0

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { EventBridgeClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EventBridgeClient";
 import { PutEventsRequest, PutEventsResponse } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link PutEventsCommand}.
  */
 export interface PutEventsCommandInput extends PutEventsRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link PutEventsCommand}.
  */
 export interface PutEventsCommandOutput extends PutEventsResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Sends custom events to Amazon EventBridge so that they can be matched to rules.</p>
  *          <note>
  *             <p>PutEvents will only process nested JSON up to 1100 levels deep.</p>
@@ -28,6 +33,8 @@ export interface PutEventsCommandOutput extends PutEventsResponse, __MetadataBea
  * const response = await client.send(command);
  * ```
  *
+ * @param PutEventsCommandInput - {@link PutEventsCommandInput}
+ * @returns {@link PutEventsCommandOutput}
  * @see {@link PutEventsCommandInput} for command's `input` shape.
  * @see {@link PutEventsCommandOutput} for command's `response` shape.
  * @see {@link EventBridgeClientResolvedConfig | config} for EventBridgeClient's `config` shape.
@@ -40,11 +47,20 @@ export interface PutEventsCommandOutput extends PutEventsResponse, __MetadataBea
 export declare class PutEventsCommand extends $Command<PutEventsCommandInput, PutEventsCommandOutput, EventBridgeClientResolvedConfig> {
     readonly input: PutEventsCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: PutEventsCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EventBridgeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutEventsCommandInput, PutEventsCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { EventBridgeClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EventBridgeClient";
 import { PutPartnerEventsRequest, PutPartnerEventsResponse } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link PutPartnerEventsCommand}.
  */
 export interface PutPartnerEventsCommandInput extends PutPartnerEventsRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link PutPartnerEventsCommand}.
  */
 export interface PutPartnerEventsCommandOutput extends PutPartnerEventsResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <p>This is used by SaaS partners to write events to a customer's partner event bus. Amazon Web Services
  *       customers do not use this operation.</p>
  * @example
@@ -26,6 +31,8 @@ export interface PutPartnerEventsCommandOutput extends PutPartnerEventsResponse,
  * const response = await client.send(command);
  * ```
  *
+ * @param PutPartnerEventsCommandInput - {@link PutPartnerEventsCommandInput}
+ * @returns {@link PutPartnerEventsCommandOutput}
  * @see {@link PutPartnerEventsCommandInput} for command's `input` shape.
  * @see {@link PutPartnerEventsCommandOutput} for command's `response` shape.
  * @see {@link EventBridgeClientResolvedConfig | config} for EventBridgeClient's `config` shape.
@@ -41,11 +48,20 @@ export interface PutPartnerEventsCommandOutput extends PutPartnerEventsResponse,
 export declare class PutPartnerEventsCommand extends $Command<PutPartnerEventsCommandInput, PutPartnerEventsCommandOutput, EventBridgeClientResolvedConfig> {
     readonly input: PutPartnerEventsCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: PutPartnerEventsCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EventBridgeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutPartnerEventsCommandInput, PutPartnerEventsCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { EventBridgeClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EventBridgeClient";
 import { PutPermissionRequest } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link PutPermissionCommand}.
  */
 export interface PutPermissionCommandInput extends PutPermissionRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link PutPermissionCommand}.
  */
 export interface PutPermissionCommandOutput extends __MetadataBearer {
 }
 /**
+ * @public
  * <p>Running <code>PutPermission</code> permits the specified Amazon Web Services account or Amazon Web Services organization
  *       to put events to the specified <i>event bus</i>. Amazon EventBridge (CloudWatch
  *       Events) rules in your account are triggered by these events arriving to an event bus in your
@@ -41,6 +46,8 @@ export interface PutPermissionCommandOutput extends __MetadataBearer {
  * const response = await client.send(command);
  * ```
  *
+ * @param PutPermissionCommandInput - {@link PutPermissionCommandInput}
+ * @returns {@link PutPermissionCommandOutput}
  * @see {@link PutPermissionCommandInput} for command's `input` shape.
  * @see {@link PutPermissionCommandOutput} for command's `response` shape.
  * @see {@link EventBridgeClientResolvedConfig | config} for EventBridgeClient's `config` shape.
@@ -65,11 +72,20 @@ export interface PutPermissionCommandOutput extends __MetadataBearer {
 export declare class PutPermissionCommand extends $Command<PutPermissionCommandInput, PutPermissionCommandOutput, EventBridgeClientResolvedConfig> {
     readonly input: PutPermissionCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: PutPermissionCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EventBridgeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutPermissionCommandInput, PutPermissionCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { EventBridgeClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EventBridgeClient";
 import { PutRuleRequest, PutRuleResponse } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link PutRuleCommand}.
  */
 export interface PutRuleCommandInput extends PutRuleRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link PutRuleCommand}.
  */
 export interface PutRuleCommandOutput extends PutRuleResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Creates or updates the specified rule. Rules are enabled by default, or based on value of
  *       the state. You can disable a rule using <a href="https://docs.aws.amazon.com/eventbridge/latest/APIReference/API_DisableRule.html">DisableRule</a>.</p>
  *          <p>A single rule watches for events from a single event bus. Events generated by Amazon Web Services services
@@ -64,6 +69,8 @@ export interface PutRuleCommandOutput extends PutRuleResponse, __MetadataBearer
  * const response = await client.send(command);
  * ```
  *
+ * @param PutRuleCommandInput - {@link PutRuleCommandInput}
+ * @returns {@link PutRuleCommandOutput}
  * @see {@link PutRuleCommandInput} for command's `input` shape.
  * @see {@link PutRuleCommandOutput} for command's `response` shape.
  * @see {@link EventBridgeClientResolvedConfig | config} for EventBridgeClient's `config` shape.
@@ -97,11 +104,20 @@ export interface PutRuleCommandOutput extends PutRuleResponse, __MetadataBearer
 export declare class PutRuleCommand extends $Command<PutRuleCommandInput, PutRuleCommandOutput, EventBridgeClientResolvedConfig> {
     readonly input: PutRuleCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: PutRuleCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EventBridgeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutRuleCommandInput, PutRuleCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { EventBridgeClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EventBridgeClient";
 import { PutTargetsRequest, PutTargetsResponse } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link PutTargetsCommand}.
  */
 export interface PutTargetsCommandInput extends PutTargetsRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link PutTargetsCommand}.
  */
 export interface PutTargetsCommandOutput extends PutTargetsResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Adds the specified targets to the specified rule, or updates the targets if they are
  *       already associated with the rule.</p>
  *          <p>Targets are the resources that are invoked when a rule is triggered.</p>
@@ -202,6 +207,8 @@ export interface PutTargetsCommandOutput extends PutTargetsResponse, __MetadataB
  * const response = await client.send(command);
  * ```
  *
+ * @param PutTargetsCommandInput - {@link PutTargetsCommandInput}
+ * @returns {@link PutTargetsCommandOutput}
  * @see {@link PutTargetsCommandInput} for command's `input` shape.
  * @see {@link PutTargetsCommandOutput} for command's `response` shape.
  * @see {@link EventBridgeClientResolvedConfig | config} for EventBridgeClient's `config` shape.
@@ -232,11 +239,20 @@ export interface PutTargetsCommandOutput extends PutTargetsResponse, __MetadataB
 export declare class PutTargetsCommand extends $Command<PutTargetsCommandInput, PutTargetsCommandOutput, EventBridgeClientResolvedConfig> {
     readonly input: PutTargetsCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: PutTargetsCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EventBridgeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutTargetsCommandInput, PutTargetsCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { EventBridgeClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EventBridgeClient";
 import { RemovePermissionRequest } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link RemovePermissionCommand}.
  */
 export interface RemovePermissionCommandInput extends RemovePermissionRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link RemovePermissionCommand}.
  */
 export interface RemovePermissionCommandOutput extends __MetadataBearer {
 }
 /**
+ * @public
  * <p>Revokes the permission of another Amazon Web Services account to be able to put events to the specified
  *       event bus. Specify the account to revoke by the <code>StatementId</code> value that you
  *       associated with the account when you granted it permission with <code>PutPermission</code>.
@@ -28,6 +33,8 @@ export interface RemovePermissionCommandOutput extends __MetadataBearer {
  * const response = await client.send(command);
  * ```
  *
+ * @param RemovePermissionCommandInput - {@link RemovePermissionCommandInput}
+ * @returns {@link RemovePermissionCommandOutput}
  * @see {@link RemovePermissionCommandInput} for command's `input` shape.
  * @see {@link RemovePermissionCommandOutput} for command's `response` shape.
  * @see {@link EventBridgeClientResolvedConfig | config} for EventBridgeClient's `config` shape.
@@ -49,11 +56,20 @@ export interface RemovePermissionCommandOutput extends __MetadataBearer {
 export declare class RemovePermissionCommand extends $Command<RemovePermissionCommandInput, RemovePermissionCommandOutput, EventBridgeClientResolvedConfig> {
     readonly input: RemovePermissionCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: RemovePermissionCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EventBridgeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<RemovePermissionCommandInput, RemovePermissionCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { EventBridgeClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EventBridgeClient";
 import { RemoveTargetsRequest, RemoveTargetsResponse } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link RemoveTargetsCommand}.
  */
 export interface RemoveTargetsCommandInput extends RemoveTargetsRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link RemoveTargetsCommand}.
  */
 export interface RemoveTargetsCommandOutput extends RemoveTargetsResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Removes the specified targets from the specified rule. When the rule is triggered, those
  *       targets are no longer be invoked.</p>
  *          <note>
@@ -34,6 +39,8 @@ export interface RemoveTargetsCommandOutput extends RemoveTargetsResponse, __Met
  * const response = await client.send(command);
  * ```
  *
+ * @param RemoveTargetsCommandInput - {@link RemoveTargetsCommandInput}
+ * @returns {@link RemoveTargetsCommandOutput}
  * @see {@link RemoveTargetsCommandInput} for command's `input` shape.
  * @see {@link RemoveTargetsCommandOutput} for command's `response` shape.
  * @see {@link EventBridgeClientResolvedConfig | config} for EventBridgeClient's `config` shape.
@@ -60,11 +67,20 @@ export interface RemoveTargetsCommandOutput extends RemoveTargetsResponse, __Met
 export declare class RemoveTargetsCommand extends $Command<RemoveTargetsCommandInput, RemoveTargetsCommandOutput, EventBridgeClientResolvedConfig> {
     readonly input: RemoveTargetsCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: RemoveTargetsCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EventBridgeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<RemoveTargetsCommandInput, RemoveTargetsCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { EventBridgeClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EventBridgeClient";
 import { StartReplayRequest, StartReplayResponse } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link StartReplayCommand}.
  */
 export interface StartReplayCommandInput extends StartReplayRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link StartReplayCommand}.
  */
 export interface StartReplayCommandOutput extends StartReplayResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Starts the specified replay. Events are not necessarily replayed in the exact same order
  *       that they were added to the archive. A replay processes events to replay based on the time in
  *       the event, and replays them using 1 minute intervals. If you specify an
@@ -33,6 +38,8 @@ export interface StartReplayCommandOutput extends StartReplayResponse, __Metadat
  * const response = await client.send(command);
  * ```
  *
+ * @param StartReplayCommandInput - {@link StartReplayCommandInput}
+ * @returns {@link StartReplayCommandOutput}
  * @see {@link StartReplayCommandInput} for command's `input` shape.
  * @see {@link StartReplayCommandOutput} for command's `response` shape.
  * @see {@link EventBridgeClientResolvedConfig | config} for EventBridgeClient's `config` shape.
@@ -58,11 +65,20 @@ export interface StartReplayCommandOutput extends StartReplayResponse, __Metadat
 export declare class StartReplayCommand extends $Command<StartReplayCommandInput, StartReplayCommandOutput, EventBridgeClientResolvedConfig> {
     readonly input: StartReplayCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: StartReplayCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EventBridgeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StartReplayCommandInput, StartReplayCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { EventBridgeClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EventBridgeClient";
 import { TagResourceRequest, TagResourceResponse } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link TagResourceCommand}.
  */
 export interface TagResourceCommandInput extends TagResourceRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link TagResourceCommand}.
  */
 export interface TagResourceCommandOutput extends TagResourceResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Assigns one or more tags (key-value pairs) to the specified EventBridge resource. Tags can
  *       help you organize and categorize your resources. You can also use them to scope user
  *       permissions by granting a user permission to access or change only resources with certain tag
@@ -35,6 +40,8 @@ export interface TagResourceCommandOutput extends TagResourceResponse, __Metadat
  * const response = await client.send(command);
  * ```
  *
+ * @param TagResourceCommandInput - {@link TagResourceCommandInput}
+ * @returns {@link TagResourceCommandOutput}
  * @see {@link TagResourceCommandInput} for command's `input` shape.
  * @see {@link TagResourceCommandOutput} for command's `response` shape.
  * @see {@link EventBridgeClientResolvedConfig | config} for EventBridgeClient's `config` shape.
@@ -61,11 +68,20 @@ export interface TagResourceCommandOutput extends TagResourceResponse, __Metadat
 export declare class TagResourceCommand extends $Command<TagResourceCommandInput, TagResourceCommandOutput, EventBridgeClientResolvedConfig> {
     readonly input: TagResourceCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: TagResourceCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EventBridgeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<TagResourceCommandInput, TagResourceCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { EventBridgeClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EventBridgeClient";
 import { TestEventPatternRequest, TestEventPatternResponse } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link TestEventPatternCommand}.
  */
 export interface TestEventPatternCommandInput extends TestEventPatternRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link TestEventPatternCommand}.
  */
 export interface TestEventPatternCommandOutput extends TestEventPatternResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Tests whether the specified event pattern matches the provided event.</p>
  *          <p>Most services in Amazon Web Services treat : or / as the same character in Amazon Resource Names (ARNs).
  *       However, EventBridge uses an exact match in event patterns and rules. Be sure to use the
@@ -29,6 +34,8 @@ export interface TestEventPatternCommandOutput extends TestEventPatternResponse,
  * const response = await client.send(command);
  * ```
  *
+ * @param TestEventPatternCommandInput - {@link TestEventPatternCommandInput}
+ * @returns {@link TestEventPatternCommandOutput}
  * @see {@link TestEventPatternCommandInput} for command's `input` shape.
  * @see {@link TestEventPatternCommandOutput} for command's `response` shape.
  * @see {@link EventBridgeClientResolvedConfig | config} for EventBridgeClient's `config` shape.
@@ -44,11 +51,20 @@ export interface TestEventPatternCommandOutput extends TestEventPatternResponse,
 export declare class TestEventPatternCommand extends $Command<TestEventPatternCommandInput, TestEventPatternCommandOutput, EventBridgeClientResolvedConfig> {
     readonly input: TestEventPatternCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: TestEventPatternCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EventBridgeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<TestEventPatternCommandInput, TestEventPatternCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { EventBridgeClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EventBridgeClient";
 import { UntagResourceRequest, UntagResourceResponse } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link UntagResourceCommand}.
  */
 export interface UntagResourceCommandInput extends UntagResourceRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link UntagResourceCommand}.
  */
 export interface UntagResourceCommandOutput extends UntagResourceResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Removes one or more tags from the specified EventBridge resource. In Amazon EventBridge
  *       (CloudWatch Events), rules and event buses can be tagged.</p>
  * @example
@@ -26,6 +31,8 @@ export interface UntagResourceCommandOutput extends UntagResourceResponse, __Met
  * const response = await client.send(command);
  * ```
  *
+ * @param UntagResourceCommandInput - {@link UntagResourceCommandInput}
+ * @returns {@link UntagResourceCommandOutput}
  * @see {@link UntagResourceCommandInput} for command's `input` shape.
  * @see {@link UntagResourceCommandOutput} for command's `response` shape.
  * @see {@link EventBridgeClientResolvedConfig | config} for EventBridgeClient's `config` shape.
@@ -52,11 +59,20 @@ export interface UntagResourceCommandOutput extends UntagResourceResponse, __Met
 export declare class UntagResourceCommand extends $Command<UntagResourceCommandInput, UntagResourceCommandOutput, EventBridgeClientResolvedConfig> {
     readonly input: UntagResourceCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: UntagResourceCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EventBridgeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UntagResourceCommandInput, UntagResourceCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

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

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

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