@aws-sdk/client-eventbridge 3.34.0 → 3.37.0

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

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { EventBridgeClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EventBridgeClient";
+import { ListRuleNamesByTargetRequest, ListRuleNamesByTargetResponse } from "../models/models_0";
+export interface ListRuleNamesByTargetCommandInput extends ListRuleNamesByTargetRequest {
+}
+export interface ListRuleNamesByTargetCommandOutput extends ListRuleNamesByTargetResponse, __MetadataBearer {
+}
+
+export declare class ListRuleNamesByTargetCommand extends $Command<ListRuleNamesByTargetCommandInput, ListRuleNamesByTargetCommandOutput, EventBridgeClientResolvedConfig> {
+    readonly input: ListRuleNamesByTargetCommandInput;
+    constructor(input: ListRuleNamesByTargetCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EventBridgeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListRuleNamesByTargetCommandInput, ListRuleNamesByTargetCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { EventBridgeClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EventBridgeClient";
+import { ListRulesRequest, ListRulesResponse } from "../models/models_0";
+export interface ListRulesCommandInput extends ListRulesRequest {
+}
+export interface ListRulesCommandOutput extends ListRulesResponse, __MetadataBearer {
+}
+
+export declare class ListRulesCommand extends $Command<ListRulesCommandInput, ListRulesCommandOutput, EventBridgeClientResolvedConfig> {
+    readonly input: ListRulesCommandInput;
+    constructor(input: ListRulesCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EventBridgeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListRulesCommandInput, ListRulesCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { EventBridgeClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EventBridgeClient";
+import { ListTagsForResourceRequest, ListTagsForResourceResponse } from "../models/models_0";
+export interface ListTagsForResourceCommandInput extends ListTagsForResourceRequest {
+}
+export interface ListTagsForResourceCommandOutput extends ListTagsForResourceResponse, __MetadataBearer {
+}
+
+export declare class ListTagsForResourceCommand extends $Command<ListTagsForResourceCommandInput, ListTagsForResourceCommandOutput, EventBridgeClientResolvedConfig> {
+    readonly input: ListTagsForResourceCommandInput;
+    constructor(input: ListTagsForResourceCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EventBridgeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListTagsForResourceCommandInput, ListTagsForResourceCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/{dist/types → dist-types}/ts3.4/commands/ListTargetsByRuleCommand.d.ts

@@ -1,34 +1,16 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
 import { EventBridgeClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EventBridgeClient";
 import { ListTargetsByRuleRequest, ListTargetsByRuleResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
 export interface ListTargetsByRuleCommandInput extends ListTargetsByRuleRequest {
 }
 export interface ListTargetsByRuleCommandOutput extends ListTargetsByRuleResponse, __MetadataBearer {
 }
-/**
- * <p>Lists the targets assigned to the specified rule.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EventBridgeClient, ListTargetsByRuleCommand } from "@aws-sdk/client-eventbridge"; // ES Modules import
- * // const { EventBridgeClient, ListTargetsByRuleCommand } = require("@aws-sdk/client-eventbridge"); // CommonJS import
- * const client = new EventBridgeClient(config);
- * const command = new ListTargetsByRuleCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListTargetsByRuleCommandInput} for command's `input` shape.
- * @see {@link ListTargetsByRuleCommandOutput} for command's `response` shape.
- * @see {@link EventBridgeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListTargetsByRuleCommand extends $Command<ListTargetsByRuleCommandInput, ListTargetsByRuleCommandOutput, EventBridgeClientResolvedConfig> {
     readonly input: ListTargetsByRuleCommandInput;
     constructor(input: ListTargetsByRuleCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EventBridgeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListTargetsByRuleCommandInput, ListTargetsByRuleCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { EventBridgeClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EventBridgeClient";
+import { PutEventsRequest, PutEventsResponse } from "../models/models_0";
+export interface PutEventsCommandInput extends PutEventsRequest {
+}
+export interface PutEventsCommandOutput extends PutEventsResponse, __MetadataBearer {
+}
+
+export declare class PutEventsCommand extends $Command<PutEventsCommandInput, PutEventsCommandOutput, EventBridgeClientResolvedConfig> {
+    readonly input: PutEventsCommandInput;
+    constructor(input: PutEventsCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EventBridgeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutEventsCommandInput, PutEventsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { EventBridgeClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EventBridgeClient";
+import { PutPartnerEventsRequest, PutPartnerEventsResponse } from "../models/models_0";
+export interface PutPartnerEventsCommandInput extends PutPartnerEventsRequest {
+}
+export interface PutPartnerEventsCommandOutput extends PutPartnerEventsResponse, __MetadataBearer {
+}
+
+export declare class PutPartnerEventsCommand extends $Command<PutPartnerEventsCommandInput, PutPartnerEventsCommandOutput, EventBridgeClientResolvedConfig> {
+    readonly input: PutPartnerEventsCommandInput;
+    constructor(input: PutPartnerEventsCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EventBridgeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutPartnerEventsCommandInput, PutPartnerEventsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { EventBridgeClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EventBridgeClient";
+import { PutPermissionRequest } from "../models/models_0";
+export interface PutPermissionCommandInput extends PutPermissionRequest {
+}
+export interface PutPermissionCommandOutput extends __MetadataBearer {
+}
+
+export declare class PutPermissionCommand extends $Command<PutPermissionCommandInput, PutPermissionCommandOutput, EventBridgeClientResolvedConfig> {
+    readonly input: PutPermissionCommandInput;
+    constructor(input: PutPermissionCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EventBridgeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutPermissionCommandInput, PutPermissionCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { EventBridgeClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EventBridgeClient";
+import { PutRuleRequest, PutRuleResponse } from "../models/models_0";
+export interface PutRuleCommandInput extends PutRuleRequest {
+}
+export interface PutRuleCommandOutput extends PutRuleResponse, __MetadataBearer {
+}
+
+export declare class PutRuleCommand extends $Command<PutRuleCommandInput, PutRuleCommandOutput, EventBridgeClientResolvedConfig> {
+    readonly input: PutRuleCommandInput;
+    constructor(input: PutRuleCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EventBridgeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutRuleCommandInput, PutRuleCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { EventBridgeClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EventBridgeClient";
+import { PutTargetsRequest, PutTargetsResponse } from "../models/models_0";
+export interface PutTargetsCommandInput extends PutTargetsRequest {
+}
+export interface PutTargetsCommandOutput extends PutTargetsResponse, __MetadataBearer {
+}
+
+export declare class PutTargetsCommand extends $Command<PutTargetsCommandInput, PutTargetsCommandOutput, EventBridgeClientResolvedConfig> {
+    readonly input: PutTargetsCommandInput;
+    constructor(input: PutTargetsCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EventBridgeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutTargetsCommandInput, PutTargetsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { EventBridgeClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EventBridgeClient";
+import { RemovePermissionRequest } from "../models/models_0";
+export interface RemovePermissionCommandInput extends RemovePermissionRequest {
+}
+export interface RemovePermissionCommandOutput extends __MetadataBearer {
+}
+
+export declare class RemovePermissionCommand extends $Command<RemovePermissionCommandInput, RemovePermissionCommandOutput, EventBridgeClientResolvedConfig> {
+    readonly input: RemovePermissionCommandInput;
+    constructor(input: RemovePermissionCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EventBridgeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<RemovePermissionCommandInput, RemovePermissionCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { EventBridgeClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EventBridgeClient";
+import { RemoveTargetsRequest, RemoveTargetsResponse } from "../models/models_0";
+export interface RemoveTargetsCommandInput extends RemoveTargetsRequest {
+}
+export interface RemoveTargetsCommandOutput extends RemoveTargetsResponse, __MetadataBearer {
+}
+
+export declare class RemoveTargetsCommand extends $Command<RemoveTargetsCommandInput, RemoveTargetsCommandOutput, EventBridgeClientResolvedConfig> {
+    readonly input: RemoveTargetsCommandInput;
+    constructor(input: RemoveTargetsCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EventBridgeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<RemoveTargetsCommandInput, RemoveTargetsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { EventBridgeClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EventBridgeClient";
+import { StartReplayRequest, StartReplayResponse } from "../models/models_0";
+export interface StartReplayCommandInput extends StartReplayRequest {
+}
+export interface StartReplayCommandOutput extends StartReplayResponse, __MetadataBearer {
+}
+
+export declare class StartReplayCommand extends $Command<StartReplayCommandInput, StartReplayCommandOutput, EventBridgeClientResolvedConfig> {
+    readonly input: StartReplayCommandInput;
+    constructor(input: StartReplayCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EventBridgeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StartReplayCommandInput, StartReplayCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { EventBridgeClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EventBridgeClient";
+import { TagResourceRequest, TagResourceResponse } from "../models/models_0";
+export interface TagResourceCommandInput extends TagResourceRequest {
+}
+export interface TagResourceCommandOutput extends TagResourceResponse, __MetadataBearer {
+}
+
+export declare class TagResourceCommand extends $Command<TagResourceCommandInput, TagResourceCommandOutput, EventBridgeClientResolvedConfig> {
+    readonly input: TagResourceCommandInput;
+    constructor(input: TagResourceCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EventBridgeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<TagResourceCommandInput, TagResourceCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { EventBridgeClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EventBridgeClient";
+import { TestEventPatternRequest, TestEventPatternResponse } from "../models/models_0";
+export interface TestEventPatternCommandInput extends TestEventPatternRequest {
+}
+export interface TestEventPatternCommandOutput extends TestEventPatternResponse, __MetadataBearer {
+}
+
+export declare class TestEventPatternCommand extends $Command<TestEventPatternCommandInput, TestEventPatternCommandOutput, EventBridgeClientResolvedConfig> {
+    readonly input: TestEventPatternCommandInput;
+    constructor(input: TestEventPatternCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EventBridgeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<TestEventPatternCommandInput, TestEventPatternCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { EventBridgeClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EventBridgeClient";
+import { UntagResourceRequest, UntagResourceResponse } from "../models/models_0";
+export interface UntagResourceCommandInput extends UntagResourceRequest {
+}
+export interface UntagResourceCommandOutput extends UntagResourceResponse, __MetadataBearer {
+}
+
+export declare class UntagResourceCommand extends $Command<UntagResourceCommandInput, UntagResourceCommandOutput, EventBridgeClientResolvedConfig> {
+    readonly input: UntagResourceCommandInput;
+    constructor(input: UntagResourceCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EventBridgeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UntagResourceCommandInput, UntagResourceCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

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

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

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

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

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