@aws-sdk/client-eventbridge 3.478.0 → 3.481.0

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

@@ -1,6 +1,5 @@
-import { EndpointParameterInstructions } from "@smithy/middleware-endpoint";
 import { Command as $Command } from "@smithy/smithy-client";
-import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@smithy/types";
+import { MetadataBearer as __MetadataBearer } from "@smithy/types";
 import { EventBridgeClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EventBridgeClient";
 import { TestEventPatternRequest, TestEventPatternResponse } from "../models/models_0";
 /**
@@ -21,6 +20,10 @@ export interface TestEventPatternCommandInput extends TestEventPatternRequest {
  */
 export interface TestEventPatternCommandOutput extends TestEventPatternResponse, __MetadataBearer {
 }
+declare const TestEventPatternCommand_base: {
+    new (input: TestEventPatternCommandInput): import("@smithy/smithy-client").CommandImpl<TestEventPatternCommandInput, TestEventPatternCommandOutput, EventBridgeClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes>;
+    getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
 /**
  * @public
  * <p>Tests whether the specified event pattern matches the provided event.</p>
@@ -62,23 +65,5 @@ export interface TestEventPatternCommandOutput extends TestEventPatternResponse,
  * <p>Base exception class for all service exceptions from EventBridge service.</p>
  *
  */
-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;
+export declare class TestEventPatternCommand extends TestEventPatternCommand_base {
 }

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

@@ -1,6 +1,5 @@
-import { EndpointParameterInstructions } from "@smithy/middleware-endpoint";
 import { Command as $Command } from "@smithy/smithy-client";
-import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@smithy/types";
+import { MetadataBearer as __MetadataBearer } from "@smithy/types";
 import { EventBridgeClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EventBridgeClient";
 import { UntagResourceRequest, UntagResourceResponse } from "../models/models_0";
 /**
@@ -21,6 +20,10 @@ export interface UntagResourceCommandInput extends UntagResourceRequest {
  */
 export interface UntagResourceCommandOutput extends UntagResourceResponse, __MetadataBearer {
 }
+declare const UntagResourceCommand_base: {
+    new (input: UntagResourceCommandInput): import("@smithy/smithy-client").CommandImpl<UntagResourceCommandInput, UntagResourceCommandOutput, EventBridgeClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes>;
+    getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
 /**
  * @public
  * <p>Removes one or more tags from the specified EventBridge resource. In Amazon EventBridge
@@ -70,23 +73,5 @@ export interface UntagResourceCommandOutput extends UntagResourceResponse, __Met
  * <p>Base exception class for all service exceptions from EventBridge service.</p>
  *
  */
-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;
+export declare class UntagResourceCommand extends UntagResourceCommand_base {
 }

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

@@ -1,6 +1,5 @@
-import { EndpointParameterInstructions } from "@smithy/middleware-endpoint";
 import { Command as $Command } from "@smithy/smithy-client";
-import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@smithy/types";
+import { MetadataBearer as __MetadataBearer } from "@smithy/types";
 import { EventBridgeClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EventBridgeClient";
 import { UpdateApiDestinationRequest, UpdateApiDestinationResponse } from "../models/models_0";
 /**
@@ -21,6 +20,10 @@ export interface UpdateApiDestinationCommandInput extends UpdateApiDestinationRe
  */
 export interface UpdateApiDestinationCommandOutput extends UpdateApiDestinationResponse, __MetadataBearer {
 }
+declare const UpdateApiDestinationCommand_base: {
+    new (input: UpdateApiDestinationCommandInput): import("@smithy/smithy-client").CommandImpl<UpdateApiDestinationCommandInput, UpdateApiDestinationCommandOutput, EventBridgeClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes>;
+    getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
 /**
  * @public
  * <p>Updates an API destination.</p>
@@ -72,23 +75,5 @@ export interface UpdateApiDestinationCommandOutput extends UpdateApiDestinationR
  * <p>Base exception class for all service exceptions from EventBridge service.</p>
  *
  */
-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;
+export declare class UpdateApiDestinationCommand extends UpdateApiDestinationCommand_base {
 }

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

@@ -1,6 +1,5 @@
-import { EndpointParameterInstructions } from "@smithy/middleware-endpoint";
 import { Command as $Command } from "@smithy/smithy-client";
-import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@smithy/types";
+import { MetadataBearer as __MetadataBearer } from "@smithy/types";
 import { EventBridgeClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EventBridgeClient";
 import { UpdateArchiveRequest, UpdateArchiveResponse } from "../models/models_0";
 /**
@@ -21,6 +20,10 @@ export interface UpdateArchiveCommandInput extends UpdateArchiveRequest {
  */
 export interface UpdateArchiveCommandOutput extends UpdateArchiveResponse, __MetadataBearer {
 }
+declare const UpdateArchiveCommand_base: {
+    new (input: UpdateArchiveCommandInput): import("@smithy/smithy-client").CommandImpl<UpdateArchiveCommandInput, UpdateArchiveCommandOutput, EventBridgeClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes>;
+    getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
 /**
  * @public
  * <p>Updates the specified archive.</p>
@@ -73,23 +76,5 @@ export interface UpdateArchiveCommandOutput extends UpdateArchiveResponse, __Met
  * <p>Base exception class for all service exceptions from EventBridge service.</p>
  *
  */
-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;
+export declare class UpdateArchiveCommand extends UpdateArchiveCommand_base {
 }

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

@@ -1,6 +1,5 @@
-import { EndpointParameterInstructions } from "@smithy/middleware-endpoint";
 import { Command as $Command } from "@smithy/smithy-client";
-import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@smithy/types";
+import { MetadataBearer as __MetadataBearer } from "@smithy/types";
 import { EventBridgeClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EventBridgeClient";
 import { UpdateConnectionRequest, UpdateConnectionResponse } from "../models/models_0";
 /**
@@ -21,6 +20,10 @@ export interface UpdateConnectionCommandInput extends UpdateConnectionRequest {
  */
 export interface UpdateConnectionCommandOutput extends UpdateConnectionResponse, __MetadataBearer {
 }
+declare const UpdateConnectionCommand_base: {
+    new (input: UpdateConnectionCommandInput): import("@smithy/smithy-client").CommandImpl<UpdateConnectionCommandInput, UpdateConnectionCommandOutput, EventBridgeClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes>;
+    getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
 /**
  * @public
  * <p>Updates settings for a connection.</p>
@@ -134,23 +137,5 @@ export interface UpdateConnectionCommandOutput extends UpdateConnectionResponse,
  * <p>Base exception class for all service exceptions from EventBridge service.</p>
  *
  */
-export declare class UpdateConnectionCommand extends $Command<UpdateConnectionCommandInput, UpdateConnectionCommandOutput, EventBridgeClientResolvedConfig> {
-    readonly input: UpdateConnectionCommandInput;
-    static getEndpointParameterInstructions(): EndpointParameterInstructions;
-    /**
-     * @public
-     */
-    constructor(input: UpdateConnectionCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EventBridgeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateConnectionCommandInput, UpdateConnectionCommandOutput>;
-    /**
-     * @internal
-     */
-    private serialize;
-    /**
-     * @internal
-     */
-    private deserialize;
+export declare class UpdateConnectionCommand extends UpdateConnectionCommand_base {
 }

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

@@ -1,6 +1,5 @@
-import { EndpointParameterInstructions } from "@smithy/middleware-endpoint";
 import { Command as $Command } from "@smithy/smithy-client";
-import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@smithy/types";
+import { MetadataBearer as __MetadataBearer } from "@smithy/types";
 import { EventBridgeClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EventBridgeClient";
 import { UpdateEndpointRequest, UpdateEndpointResponse } from "../models/models_0";
 /**
@@ -21,6 +20,10 @@ export interface UpdateEndpointCommandInput extends UpdateEndpointRequest {
  */
 export interface UpdateEndpointCommandOutput extends UpdateEndpointResponse, __MetadataBearer {
 }
+declare const UpdateEndpointCommand_base: {
+    new (input: UpdateEndpointCommandInput): import("@smithy/smithy-client").CommandImpl<UpdateEndpointCommandInput, UpdateEndpointCommandOutput, EventBridgeClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes>;
+    getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
 /**
  * @public
  * <p>Update an existing 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 <i>Amazon EventBridge User Guide</i>.</p>
@@ -103,23 +106,5 @@ export interface UpdateEndpointCommandOutput extends UpdateEndpointResponse, __M
  * <p>Base exception class for all service exceptions from EventBridge service.</p>
  *
  */
-export declare class UpdateEndpointCommand extends $Command<UpdateEndpointCommandInput, UpdateEndpointCommandOutput, EventBridgeClientResolvedConfig> {
-    readonly input: UpdateEndpointCommandInput;
-    static getEndpointParameterInstructions(): EndpointParameterInstructions;
-    /**
-     * @public
-     */
-    constructor(input: UpdateEndpointCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EventBridgeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateEndpointCommandInput, UpdateEndpointCommandOutput>;
-    /**
-     * @internal
-     */
-    private serialize;
-    /**
-     * @internal
-     */
-    private deserialize;
+export declare class UpdateEndpointCommand extends UpdateEndpointCommand_base {
 }

package/dist-types/endpoint/EndpointParameters.d.ts

@@ -14,6 +14,24 @@ export type ClientResolvedEndpointParameters = ClientInputEndpointParameters & {
 export declare const resolveClientEndpointParameters: <T>(options: T & ClientInputEndpointParameters) => T & ClientInputEndpointParameters & {
     defaultSigningName: string;
 };
+export declare const commonParams: {
+    readonly UseFIPS: {
+        readonly type: "builtInParams";
+        readonly name: "useFipsEndpoint";
+    };
+    readonly Endpoint: {
+        readonly type: "builtInParams";
+        readonly name: "endpoint";
+    };
+    readonly Region: {
+        readonly type: "builtInParams";
+        readonly name: "region";
+    };
+    readonly UseDualStack: {
+        readonly type: "builtInParams";
+        readonly name: "useDualstackEndpoint";
+    };
+};
 export interface EndpointParameters extends __EndpointParameters {
     Region?: string;
     UseDualStack?: boolean;

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

@@ -1,11 +1,5 @@
-import { EndpointParameterInstructions } from "@smithy/middleware-endpoint";
 import { Command as $Command } from "@smithy/smithy-client";
-import {
-  Handler,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  MiddlewareStack,
-} from "@smithy/types";
+import { MetadataBearer as __MetadataBearer } from "@smithy/types";
 import {
   EventBridgeClientResolvedConfig,
   ServiceInputTypes,
@@ -16,19 +10,16 @@ export { __MetadataBearer, $Command };
 export interface ActivateEventSourceCommandInput
   extends ActivateEventSourceRequest {}
 export interface ActivateEventSourceCommandOutput extends __MetadataBearer {}
-export declare class ActivateEventSourceCommand extends $Command<
-  ActivateEventSourceCommandInput,
-  ActivateEventSourceCommandOutput,
-  EventBridgeClientResolvedConfig
-> {
-  readonly input: ActivateEventSourceCommandInput;
-  static getEndpointParameterInstructions(): EndpointParameterInstructions;
-  constructor(input: ActivateEventSourceCommandInput);
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: EventBridgeClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<ActivateEventSourceCommandInput, ActivateEventSourceCommandOutput>;
-  private serialize;
-  private deserialize;
-}
+declare const ActivateEventSourceCommand_base: {
+  new (
+    input: ActivateEventSourceCommandInput
+  ): import("@smithy/smithy-client").CommandImpl<
+    ActivateEventSourceCommandInput,
+    ActivateEventSourceCommandOutput,
+    EventBridgeClientResolvedConfig,
+    ServiceInputTypes,
+    ServiceOutputTypes
+  >;
+  getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
+export declare class ActivateEventSourceCommand extends ActivateEventSourceCommand_base {}

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

@@ -1,11 +1,5 @@
-import { EndpointParameterInstructions } from "@smithy/middleware-endpoint";
 import { Command as $Command } from "@smithy/smithy-client";
-import {
-  Handler,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  MiddlewareStack,
-} from "@smithy/types";
+import { MetadataBearer as __MetadataBearer } from "@smithy/types";
 import {
   EventBridgeClientResolvedConfig,
   ServiceInputTypes,
@@ -17,19 +11,16 @@ export interface CancelReplayCommandInput extends CancelReplayRequest {}
 export interface CancelReplayCommandOutput
   extends CancelReplayResponse,
     __MetadataBearer {}
-export declare class CancelReplayCommand extends $Command<
-  CancelReplayCommandInput,
-  CancelReplayCommandOutput,
-  EventBridgeClientResolvedConfig
-> {
-  readonly input: CancelReplayCommandInput;
-  static getEndpointParameterInstructions(): EndpointParameterInstructions;
-  constructor(input: CancelReplayCommandInput);
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: EventBridgeClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<CancelReplayCommandInput, CancelReplayCommandOutput>;
-  private serialize;
-  private deserialize;
-}
+declare const CancelReplayCommand_base: {
+  new (
+    input: CancelReplayCommandInput
+  ): import("@smithy/smithy-client").CommandImpl<
+    CancelReplayCommandInput,
+    CancelReplayCommandOutput,
+    EventBridgeClientResolvedConfig,
+    ServiceInputTypes,
+    ServiceOutputTypes
+  >;
+  getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
+export declare class CancelReplayCommand extends CancelReplayCommand_base {}

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

@@ -1,11 +1,5 @@
-import { EndpointParameterInstructions } from "@smithy/middleware-endpoint";
 import { Command as $Command } from "@smithy/smithy-client";
-import {
-  Handler,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  MiddlewareStack,
-} from "@smithy/types";
+import { MetadataBearer as __MetadataBearer } from "@smithy/types";
 import {
   EventBridgeClientResolvedConfig,
   ServiceInputTypes,
@@ -21,22 +15,16 @@ export interface CreateApiDestinationCommandInput
 export interface CreateApiDestinationCommandOutput
   extends CreateApiDestinationResponse,
     __MetadataBearer {}
-export declare class CreateApiDestinationCommand extends $Command<
-  CreateApiDestinationCommandInput,
-  CreateApiDestinationCommandOutput,
-  EventBridgeClientResolvedConfig
-> {
-  readonly input: CreateApiDestinationCommandInput;
-  static getEndpointParameterInstructions(): EndpointParameterInstructions;
-  constructor(input: CreateApiDestinationCommandInput);
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: EventBridgeClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<
+declare const CreateApiDestinationCommand_base: {
+  new (
+    input: CreateApiDestinationCommandInput
+  ): import("@smithy/smithy-client").CommandImpl<
     CreateApiDestinationCommandInput,
-    CreateApiDestinationCommandOutput
+    CreateApiDestinationCommandOutput,
+    EventBridgeClientResolvedConfig,
+    ServiceInputTypes,
+    ServiceOutputTypes
   >;
-  private serialize;
-  private deserialize;
-}
+  getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
+export declare class CreateApiDestinationCommand extends CreateApiDestinationCommand_base {}

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

@@ -1,11 +1,5 @@
-import { EndpointParameterInstructions } from "@smithy/middleware-endpoint";
 import { Command as $Command } from "@smithy/smithy-client";
-import {
-  Handler,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  MiddlewareStack,
-} from "@smithy/types";
+import { MetadataBearer as __MetadataBearer } from "@smithy/types";
 import {
   EventBridgeClientResolvedConfig,
   ServiceInputTypes,
@@ -20,19 +14,16 @@ export interface CreateArchiveCommandInput extends CreateArchiveRequest {}
 export interface CreateArchiveCommandOutput
   extends CreateArchiveResponse,
     __MetadataBearer {}
-export declare class CreateArchiveCommand extends $Command<
-  CreateArchiveCommandInput,
-  CreateArchiveCommandOutput,
-  EventBridgeClientResolvedConfig
-> {
-  readonly input: CreateArchiveCommandInput;
-  static getEndpointParameterInstructions(): EndpointParameterInstructions;
-  constructor(input: CreateArchiveCommandInput);
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: EventBridgeClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<CreateArchiveCommandInput, CreateArchiveCommandOutput>;
-  private serialize;
-  private deserialize;
-}
+declare const CreateArchiveCommand_base: {
+  new (
+    input: CreateArchiveCommandInput
+  ): import("@smithy/smithy-client").CommandImpl<
+    CreateArchiveCommandInput,
+    CreateArchiveCommandOutput,
+    EventBridgeClientResolvedConfig,
+    ServiceInputTypes,
+    ServiceOutputTypes
+  >;
+  getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
+export declare class CreateArchiveCommand extends CreateArchiveCommand_base {}

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

@@ -1,11 +1,5 @@
-import { EndpointParameterInstructions } from "@smithy/middleware-endpoint";
 import { Command as $Command } from "@smithy/smithy-client";
-import {
-  Handler,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  MiddlewareStack,
-} from "@smithy/types";
+import { MetadataBearer as __MetadataBearer } from "@smithy/types";
 import {
   EventBridgeClientResolvedConfig,
   ServiceInputTypes,
@@ -20,19 +14,16 @@ export interface CreateConnectionCommandInput extends CreateConnectionRequest {}
 export interface CreateConnectionCommandOutput
   extends CreateConnectionResponse,
     __MetadataBearer {}
-export declare class CreateConnectionCommand extends $Command<
-  CreateConnectionCommandInput,
-  CreateConnectionCommandOutput,
-  EventBridgeClientResolvedConfig
-> {
-  readonly input: CreateConnectionCommandInput;
-  static getEndpointParameterInstructions(): EndpointParameterInstructions;
-  constructor(input: CreateConnectionCommandInput);
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: EventBridgeClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<CreateConnectionCommandInput, CreateConnectionCommandOutput>;
-  private serialize;
-  private deserialize;
-}
+declare const CreateConnectionCommand_base: {
+  new (
+    input: CreateConnectionCommandInput
+  ): import("@smithy/smithy-client").CommandImpl<
+    CreateConnectionCommandInput,
+    CreateConnectionCommandOutput,
+    EventBridgeClientResolvedConfig,
+    ServiceInputTypes,
+    ServiceOutputTypes
+  >;
+  getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
+export declare class CreateConnectionCommand extends CreateConnectionCommand_base {}

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

@@ -1,11 +1,5 @@
-import { EndpointParameterInstructions } from "@smithy/middleware-endpoint";
 import { Command as $Command } from "@smithy/smithy-client";
-import {
-  Handler,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  MiddlewareStack,
-} from "@smithy/types";
+import { MetadataBearer as __MetadataBearer } from "@smithy/types";
 import {
   EventBridgeClientResolvedConfig,
   ServiceInputTypes,
@@ -20,19 +14,16 @@ export interface CreateEndpointCommandInput extends CreateEndpointRequest {}
 export interface CreateEndpointCommandOutput
   extends CreateEndpointResponse,
     __MetadataBearer {}
-export declare class CreateEndpointCommand extends $Command<
-  CreateEndpointCommandInput,
-  CreateEndpointCommandOutput,
-  EventBridgeClientResolvedConfig
-> {
-  readonly input: CreateEndpointCommandInput;
-  static getEndpointParameterInstructions(): EndpointParameterInstructions;
-  constructor(input: CreateEndpointCommandInput);
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: EventBridgeClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<CreateEndpointCommandInput, CreateEndpointCommandOutput>;
-  private serialize;
-  private deserialize;
-}
+declare const CreateEndpointCommand_base: {
+  new (
+    input: CreateEndpointCommandInput
+  ): import("@smithy/smithy-client").CommandImpl<
+    CreateEndpointCommandInput,
+    CreateEndpointCommandOutput,
+    EventBridgeClientResolvedConfig,
+    ServiceInputTypes,
+    ServiceOutputTypes
+  >;
+  getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
+export declare class CreateEndpointCommand extends CreateEndpointCommand_base {}

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

@@ -1,11 +1,5 @@
-import { EndpointParameterInstructions } from "@smithy/middleware-endpoint";
 import { Command as $Command } from "@smithy/smithy-client";
-import {
-  Handler,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  MiddlewareStack,
-} from "@smithy/types";
+import { MetadataBearer as __MetadataBearer } from "@smithy/types";
 import {
   EventBridgeClientResolvedConfig,
   ServiceInputTypes,
@@ -20,19 +14,16 @@ export interface CreateEventBusCommandInput extends CreateEventBusRequest {}
 export interface CreateEventBusCommandOutput
   extends CreateEventBusResponse,
     __MetadataBearer {}
-export declare class CreateEventBusCommand extends $Command<
-  CreateEventBusCommandInput,
-  CreateEventBusCommandOutput,
-  EventBridgeClientResolvedConfig
-> {
-  readonly input: CreateEventBusCommandInput;
-  static getEndpointParameterInstructions(): EndpointParameterInstructions;
-  constructor(input: CreateEventBusCommandInput);
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: EventBridgeClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<CreateEventBusCommandInput, CreateEventBusCommandOutput>;
-  private serialize;
-  private deserialize;
-}
+declare const CreateEventBusCommand_base: {
+  new (
+    input: CreateEventBusCommandInput
+  ): import("@smithy/smithy-client").CommandImpl<
+    CreateEventBusCommandInput,
+    CreateEventBusCommandOutput,
+    EventBridgeClientResolvedConfig,
+    ServiceInputTypes,
+    ServiceOutputTypes
+  >;
+  getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
+export declare class CreateEventBusCommand extends CreateEventBusCommand_base {}