@aws-sdk/client-eventbridge 3.477.0 → 3.481.0

package/dist-types/ts3.4/commands/DescribeEventBusCommand.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 DescribeEventBusCommandInput extends DescribeEventBusRequest {}
 export interface DescribeEventBusCommandOutput
   extends DescribeEventBusResponse,
     __MetadataBearer {}
-export declare class DescribeEventBusCommand extends $Command<
-  DescribeEventBusCommandInput,
-  DescribeEventBusCommandOutput,
-  EventBridgeClientResolvedConfig
-> {
-  readonly input: DescribeEventBusCommandInput;
-  static getEndpointParameterInstructions(): EndpointParameterInstructions;
-  constructor(input: DescribeEventBusCommandInput);
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: EventBridgeClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<DescribeEventBusCommandInput, DescribeEventBusCommandOutput>;
-  private serialize;
-  private deserialize;
-}
+declare const DescribeEventBusCommand_base: {
+  new (
+    input: DescribeEventBusCommandInput
+  ): import("@smithy/smithy-client").CommandImpl<
+    DescribeEventBusCommandInput,
+    DescribeEventBusCommandOutput,
+    EventBridgeClientResolvedConfig,
+    ServiceInputTypes,
+    ServiceOutputTypes
+  >;
+  getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
+export declare class DescribeEventBusCommand extends DescribeEventBusCommand_base {}

package/dist-types/ts3.4/commands/DescribeEventSourceCommand.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,19 +15,16 @@ export interface DescribeEventSourceCommandInput
 export interface DescribeEventSourceCommandOutput
   extends DescribeEventSourceResponse,
     __MetadataBearer {}
-export declare class DescribeEventSourceCommand extends $Command<
-  DescribeEventSourceCommandInput,
-  DescribeEventSourceCommandOutput,
-  EventBridgeClientResolvedConfig
-> {
-  readonly input: DescribeEventSourceCommandInput;
-  static getEndpointParameterInstructions(): EndpointParameterInstructions;
-  constructor(input: DescribeEventSourceCommandInput);
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: EventBridgeClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<DescribeEventSourceCommandInput, DescribeEventSourceCommandOutput>;
-  private serialize;
-  private deserialize;
-}
+declare const DescribeEventSourceCommand_base: {
+  new (
+    input: DescribeEventSourceCommandInput
+  ): import("@smithy/smithy-client").CommandImpl<
+    DescribeEventSourceCommandInput,
+    DescribeEventSourceCommandOutput,
+    EventBridgeClientResolvedConfig,
+    ServiceInputTypes,
+    ServiceOutputTypes
+  >;
+  getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
+export declare class DescribeEventSourceCommand extends DescribeEventSourceCommand_base {}

package/dist-types/ts3.4/commands/DescribePartnerEventSourceCommand.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 DescribePartnerEventSourceCommandInput
 export interface DescribePartnerEventSourceCommandOutput
   extends DescribePartnerEventSourceResponse,
     __MetadataBearer {}
-export declare class DescribePartnerEventSourceCommand extends $Command<
-  DescribePartnerEventSourceCommandInput,
-  DescribePartnerEventSourceCommandOutput,
-  EventBridgeClientResolvedConfig
-> {
-  readonly input: DescribePartnerEventSourceCommandInput;
-  static getEndpointParameterInstructions(): EndpointParameterInstructions;
-  constructor(input: DescribePartnerEventSourceCommandInput);
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: EventBridgeClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<
+declare const DescribePartnerEventSourceCommand_base: {
+  new (
+    input: DescribePartnerEventSourceCommandInput
+  ): import("@smithy/smithy-client").CommandImpl<
     DescribePartnerEventSourceCommandInput,
-    DescribePartnerEventSourceCommandOutput
+    DescribePartnerEventSourceCommandOutput,
+    EventBridgeClientResolvedConfig,
+    ServiceInputTypes,
+    ServiceOutputTypes
   >;
-  private serialize;
-  private deserialize;
-}
+  getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
+export declare class DescribePartnerEventSourceCommand extends DescribePartnerEventSourceCommand_base {}

package/dist-types/ts3.4/commands/DescribeReplayCommand.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 DescribeReplayCommandInput extends DescribeReplayRequest {}
 export interface DescribeReplayCommandOutput
   extends DescribeReplayResponse,
     __MetadataBearer {}
-export declare class DescribeReplayCommand extends $Command<
-  DescribeReplayCommandInput,
-  DescribeReplayCommandOutput,
-  EventBridgeClientResolvedConfig
-> {
-  readonly input: DescribeReplayCommandInput;
-  static getEndpointParameterInstructions(): EndpointParameterInstructions;
-  constructor(input: DescribeReplayCommandInput);
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: EventBridgeClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<DescribeReplayCommandInput, DescribeReplayCommandOutput>;
-  private serialize;
-  private deserialize;
-}
+declare const DescribeReplayCommand_base: {
+  new (
+    input: DescribeReplayCommandInput
+  ): import("@smithy/smithy-client").CommandImpl<
+    DescribeReplayCommandInput,
+    DescribeReplayCommandOutput,
+    EventBridgeClientResolvedConfig,
+    ServiceInputTypes,
+    ServiceOutputTypes
+  >;
+  getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
+export declare class DescribeReplayCommand extends DescribeReplayCommand_base {}

package/dist-types/ts3.4/commands/DescribeRuleCommand.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 DescribeRuleCommandInput extends DescribeRuleRequest {}
 export interface DescribeRuleCommandOutput
   extends DescribeRuleResponse,
     __MetadataBearer {}
-export declare class DescribeRuleCommand extends $Command<
-  DescribeRuleCommandInput,
-  DescribeRuleCommandOutput,
-  EventBridgeClientResolvedConfig
-> {
-  readonly input: DescribeRuleCommandInput;
-  static getEndpointParameterInstructions(): EndpointParameterInstructions;
-  constructor(input: DescribeRuleCommandInput);
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: EventBridgeClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<DescribeRuleCommandInput, DescribeRuleCommandOutput>;
-  private serialize;
-  private deserialize;
-}
+declare const DescribeRuleCommand_base: {
+  new (
+    input: DescribeRuleCommandInput
+  ): import("@smithy/smithy-client").CommandImpl<
+    DescribeRuleCommandInput,
+    DescribeRuleCommandOutput,
+    EventBridgeClientResolvedConfig,
+    ServiceInputTypes,
+    ServiceOutputTypes
+  >;
+  getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
+export declare class DescribeRuleCommand extends DescribeRuleCommand_base {}

package/dist-types/ts3.4/commands/DisableRuleCommand.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,
@@ -15,19 +9,16 @@ import { DisableRuleRequest } from "../models/models_0";
 export { __MetadataBearer, $Command };
 export interface DisableRuleCommandInput extends DisableRuleRequest {}
 export interface DisableRuleCommandOutput extends __MetadataBearer {}
-export declare class DisableRuleCommand extends $Command<
-  DisableRuleCommandInput,
-  DisableRuleCommandOutput,
-  EventBridgeClientResolvedConfig
-> {
-  readonly input: DisableRuleCommandInput;
-  static getEndpointParameterInstructions(): EndpointParameterInstructions;
-  constructor(input: DisableRuleCommandInput);
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: EventBridgeClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<DisableRuleCommandInput, DisableRuleCommandOutput>;
-  private serialize;
-  private deserialize;
-}
+declare const DisableRuleCommand_base: {
+  new (
+    input: DisableRuleCommandInput
+  ): import("@smithy/smithy-client").CommandImpl<
+    DisableRuleCommandInput,
+    DisableRuleCommandOutput,
+    EventBridgeClientResolvedConfig,
+    ServiceInputTypes,
+    ServiceOutputTypes
+  >;
+  getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
+export declare class DisableRuleCommand extends DisableRuleCommand_base {}

package/dist-types/ts3.4/commands/EnableRuleCommand.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,
@@ -15,19 +9,16 @@ import { EnableRuleRequest } from "../models/models_0";
 export { __MetadataBearer, $Command };
 export interface EnableRuleCommandInput extends EnableRuleRequest {}
 export interface EnableRuleCommandOutput extends __MetadataBearer {}
-export declare class EnableRuleCommand extends $Command<
-  EnableRuleCommandInput,
-  EnableRuleCommandOutput,
-  EventBridgeClientResolvedConfig
-> {
-  readonly input: EnableRuleCommandInput;
-  static getEndpointParameterInstructions(): EndpointParameterInstructions;
-  constructor(input: EnableRuleCommandInput);
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: EventBridgeClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<EnableRuleCommandInput, EnableRuleCommandOutput>;
-  private serialize;
-  private deserialize;
-}
+declare const EnableRuleCommand_base: {
+  new (
+    input: EnableRuleCommandInput
+  ): import("@smithy/smithy-client").CommandImpl<
+    EnableRuleCommandInput,
+    EnableRuleCommandOutput,
+    EventBridgeClientResolvedConfig,
+    ServiceInputTypes,
+    ServiceOutputTypes
+  >;
+  getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
+export declare class EnableRuleCommand extends EnableRuleCommand_base {}

package/dist-types/ts3.4/commands/ListApiDestinationsCommand.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,19 +15,16 @@ export interface ListApiDestinationsCommandInput
 export interface ListApiDestinationsCommandOutput
   extends ListApiDestinationsResponse,
     __MetadataBearer {}
-export declare class ListApiDestinationsCommand extends $Command<
-  ListApiDestinationsCommandInput,
-  ListApiDestinationsCommandOutput,
-  EventBridgeClientResolvedConfig
-> {
-  readonly input: ListApiDestinationsCommandInput;
-  static getEndpointParameterInstructions(): EndpointParameterInstructions;
-  constructor(input: ListApiDestinationsCommandInput);
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: EventBridgeClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<ListApiDestinationsCommandInput, ListApiDestinationsCommandOutput>;
-  private serialize;
-  private deserialize;
-}
+declare const ListApiDestinationsCommand_base: {
+  new (
+    input: ListApiDestinationsCommandInput
+  ): import("@smithy/smithy-client").CommandImpl<
+    ListApiDestinationsCommandInput,
+    ListApiDestinationsCommandOutput,
+    EventBridgeClientResolvedConfig,
+    ServiceInputTypes,
+    ServiceOutputTypes
+  >;
+  getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
+export declare class ListApiDestinationsCommand extends ListApiDestinationsCommand_base {}

package/dist-types/ts3.4/commands/ListArchivesCommand.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 ListArchivesCommandInput extends ListArchivesRequest {}
 export interface ListArchivesCommandOutput
   extends ListArchivesResponse,
     __MetadataBearer {}
-export declare class ListArchivesCommand extends $Command<
-  ListArchivesCommandInput,
-  ListArchivesCommandOutput,
-  EventBridgeClientResolvedConfig
-> {
-  readonly input: ListArchivesCommandInput;
-  static getEndpointParameterInstructions(): EndpointParameterInstructions;
-  constructor(input: ListArchivesCommandInput);
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: EventBridgeClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<ListArchivesCommandInput, ListArchivesCommandOutput>;
-  private serialize;
-  private deserialize;
-}
+declare const ListArchivesCommand_base: {
+  new (
+    input: ListArchivesCommandInput
+  ): import("@smithy/smithy-client").CommandImpl<
+    ListArchivesCommandInput,
+    ListArchivesCommandOutput,
+    EventBridgeClientResolvedConfig,
+    ServiceInputTypes,
+    ServiceOutputTypes
+  >;
+  getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
+export declare class ListArchivesCommand extends ListArchivesCommand_base {}

package/dist-types/ts3.4/commands/ListConnectionsCommand.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 ListConnectionsCommandInput extends ListConnectionsRequest {}
 export interface ListConnectionsCommandOutput
   extends ListConnectionsResponse,
     __MetadataBearer {}
-export declare class ListConnectionsCommand extends $Command<
-  ListConnectionsCommandInput,
-  ListConnectionsCommandOutput,
-  EventBridgeClientResolvedConfig
-> {
-  readonly input: ListConnectionsCommandInput;
-  static getEndpointParameterInstructions(): EndpointParameterInstructions;
-  constructor(input: ListConnectionsCommandInput);
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: EventBridgeClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<ListConnectionsCommandInput, ListConnectionsCommandOutput>;
-  private serialize;
-  private deserialize;
-}
+declare const ListConnectionsCommand_base: {
+  new (
+    input: ListConnectionsCommandInput
+  ): import("@smithy/smithy-client").CommandImpl<
+    ListConnectionsCommandInput,
+    ListConnectionsCommandOutput,
+    EventBridgeClientResolvedConfig,
+    ServiceInputTypes,
+    ServiceOutputTypes
+  >;
+  getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
+export declare class ListConnectionsCommand extends ListConnectionsCommand_base {}

package/dist-types/ts3.4/commands/ListEndpointsCommand.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 ListEndpointsCommandInput extends ListEndpointsRequest {}
 export interface ListEndpointsCommandOutput
   extends ListEndpointsResponse,
     __MetadataBearer {}
-export declare class ListEndpointsCommand extends $Command<
-  ListEndpointsCommandInput,
-  ListEndpointsCommandOutput,
-  EventBridgeClientResolvedConfig
-> {
-  readonly input: ListEndpointsCommandInput;
-  static getEndpointParameterInstructions(): EndpointParameterInstructions;
-  constructor(input: ListEndpointsCommandInput);
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: EventBridgeClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<ListEndpointsCommandInput, ListEndpointsCommandOutput>;
-  private serialize;
-  private deserialize;
-}
+declare const ListEndpointsCommand_base: {
+  new (
+    input: ListEndpointsCommandInput
+  ): import("@smithy/smithy-client").CommandImpl<
+    ListEndpointsCommandInput,
+    ListEndpointsCommandOutput,
+    EventBridgeClientResolvedConfig,
+    ServiceInputTypes,
+    ServiceOutputTypes
+  >;
+  getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
+export declare class ListEndpointsCommand extends ListEndpointsCommand_base {}

package/dist-types/ts3.4/commands/ListEventBusesCommand.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 ListEventBusesCommandInput extends ListEventBusesRequest {}
 export interface ListEventBusesCommandOutput
   extends ListEventBusesResponse,
     __MetadataBearer {}
-export declare class ListEventBusesCommand extends $Command<
-  ListEventBusesCommandInput,
-  ListEventBusesCommandOutput,
-  EventBridgeClientResolvedConfig
-> {
-  readonly input: ListEventBusesCommandInput;
-  static getEndpointParameterInstructions(): EndpointParameterInstructions;
-  constructor(input: ListEventBusesCommandInput);
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: EventBridgeClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<ListEventBusesCommandInput, ListEventBusesCommandOutput>;
-  private serialize;
-  private deserialize;
-}
+declare const ListEventBusesCommand_base: {
+  new (
+    input: ListEventBusesCommandInput
+  ): import("@smithy/smithy-client").CommandImpl<
+    ListEventBusesCommandInput,
+    ListEventBusesCommandOutput,
+    EventBridgeClientResolvedConfig,
+    ServiceInputTypes,
+    ServiceOutputTypes
+  >;
+  getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
+export declare class ListEventBusesCommand extends ListEventBusesCommand_base {}

package/dist-types/ts3.4/commands/ListEventSourcesCommand.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 ListEventSourcesCommandInput extends ListEventSourcesRequest {}
 export interface ListEventSourcesCommandOutput
   extends ListEventSourcesResponse,
     __MetadataBearer {}
-export declare class ListEventSourcesCommand extends $Command<
-  ListEventSourcesCommandInput,
-  ListEventSourcesCommandOutput,
-  EventBridgeClientResolvedConfig
-> {
-  readonly input: ListEventSourcesCommandInput;
-  static getEndpointParameterInstructions(): EndpointParameterInstructions;
-  constructor(input: ListEventSourcesCommandInput);
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: EventBridgeClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<ListEventSourcesCommandInput, ListEventSourcesCommandOutput>;
-  private serialize;
-  private deserialize;
-}
+declare const ListEventSourcesCommand_base: {
+  new (
+    input: ListEventSourcesCommandInput
+  ): import("@smithy/smithy-client").CommandImpl<
+    ListEventSourcesCommandInput,
+    ListEventSourcesCommandOutput,
+    EventBridgeClientResolvedConfig,
+    ServiceInputTypes,
+    ServiceOutputTypes
+  >;
+  getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
+export declare class ListEventSourcesCommand extends ListEventSourcesCommand_base {}

package/dist-types/ts3.4/commands/ListPartnerEventSourceAccountsCommand.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 ListPartnerEventSourceAccountsCommandInput
 export interface ListPartnerEventSourceAccountsCommandOutput
   extends ListPartnerEventSourceAccountsResponse,
     __MetadataBearer {}
-export declare class ListPartnerEventSourceAccountsCommand extends $Command<
-  ListPartnerEventSourceAccountsCommandInput,
-  ListPartnerEventSourceAccountsCommandOutput,
-  EventBridgeClientResolvedConfig
-> {
-  readonly input: ListPartnerEventSourceAccountsCommandInput;
-  static getEndpointParameterInstructions(): EndpointParameterInstructions;
-  constructor(input: ListPartnerEventSourceAccountsCommandInput);
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: EventBridgeClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<
+declare const ListPartnerEventSourceAccountsCommand_base: {
+  new (
+    input: ListPartnerEventSourceAccountsCommandInput
+  ): import("@smithy/smithy-client").CommandImpl<
     ListPartnerEventSourceAccountsCommandInput,
-    ListPartnerEventSourceAccountsCommandOutput
+    ListPartnerEventSourceAccountsCommandOutput,
+    EventBridgeClientResolvedConfig,
+    ServiceInputTypes,
+    ServiceOutputTypes
   >;
-  private serialize;
-  private deserialize;
-}
+  getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
+export declare class ListPartnerEventSourceAccountsCommand extends ListPartnerEventSourceAccountsCommand_base {}