@aws-sdk/client-connect 3.479.0 → 3.481.0

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

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

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

package/dist-types/ts3.4/commands/CreateInstanceCommand.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 {
   ConnectClientResolvedConfig,
   ServiceInputTypes,
@@ -20,19 +14,16 @@ export interface CreateInstanceCommandInput extends CreateInstanceRequest {}
 export interface CreateInstanceCommandOutput
   extends CreateInstanceResponse,
     __MetadataBearer {}
-export declare class CreateInstanceCommand extends $Command<
-  CreateInstanceCommandInput,
-  CreateInstanceCommandOutput,
-  ConnectClientResolvedConfig
-> {
-  readonly input: CreateInstanceCommandInput;
-  static getEndpointParameterInstructions(): EndpointParameterInstructions;
-  constructor(input: CreateInstanceCommandInput);
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: ConnectClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<CreateInstanceCommandInput, CreateInstanceCommandOutput>;
-  private serialize;
-  private deserialize;
-}
+declare const CreateInstanceCommand_base: {
+  new (
+    input: CreateInstanceCommandInput
+  ): import("@smithy/smithy-client").CommandImpl<
+    CreateInstanceCommandInput,
+    CreateInstanceCommandOutput,
+    ConnectClientResolvedConfig,
+    ServiceInputTypes,
+    ServiceOutputTypes
+  >;
+  getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
+export declare class CreateInstanceCommand extends CreateInstanceCommand_base {}

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

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

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

package/dist-types/ts3.4/commands/CreatePredefinedAttributeCommand.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 {
   ConnectClientResolvedConfig,
   ServiceInputTypes,
@@ -17,22 +11,16 @@ export interface CreatePredefinedAttributeCommandInput
   extends CreatePredefinedAttributeRequest {}
 export interface CreatePredefinedAttributeCommandOutput
   extends __MetadataBearer {}
-export declare class CreatePredefinedAttributeCommand extends $Command<
-  CreatePredefinedAttributeCommandInput,
-  CreatePredefinedAttributeCommandOutput,
-  ConnectClientResolvedConfig
-> {
-  readonly input: CreatePredefinedAttributeCommandInput;
-  static getEndpointParameterInstructions(): EndpointParameterInstructions;
-  constructor(input: CreatePredefinedAttributeCommandInput);
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: ConnectClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<
+declare const CreatePredefinedAttributeCommand_base: {
+  new (
+    input: CreatePredefinedAttributeCommandInput
+  ): import("@smithy/smithy-client").CommandImpl<
     CreatePredefinedAttributeCommandInput,
-    CreatePredefinedAttributeCommandOutput
+    CreatePredefinedAttributeCommandOutput,
+    ConnectClientResolvedConfig,
+    ServiceInputTypes,
+    ServiceOutputTypes
   >;
-  private serialize;
-  private deserialize;
-}
+  getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
+export declare class CreatePredefinedAttributeCommand extends CreatePredefinedAttributeCommand_base {}

package/dist-types/ts3.4/commands/CreatePromptCommand.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 {
   ConnectClientResolvedConfig,
   ServiceInputTypes,
@@ -17,19 +11,16 @@ export interface CreatePromptCommandInput extends CreatePromptRequest {}
 export interface CreatePromptCommandOutput
   extends CreatePromptResponse,
     __MetadataBearer {}
-export declare class CreatePromptCommand extends $Command<
-  CreatePromptCommandInput,
-  CreatePromptCommandOutput,
-  ConnectClientResolvedConfig
-> {
-  readonly input: CreatePromptCommandInput;
-  static getEndpointParameterInstructions(): EndpointParameterInstructions;
-  constructor(input: CreatePromptCommandInput);
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: ConnectClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<CreatePromptCommandInput, CreatePromptCommandOutput>;
-  private serialize;
-  private deserialize;
-}
+declare const CreatePromptCommand_base: {
+  new (
+    input: CreatePromptCommandInput
+  ): import("@smithy/smithy-client").CommandImpl<
+    CreatePromptCommandInput,
+    CreatePromptCommandOutput,
+    ConnectClientResolvedConfig,
+    ServiceInputTypes,
+    ServiceOutputTypes
+  >;
+  getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
+export declare class CreatePromptCommand extends CreatePromptCommand_base {}

package/dist-types/ts3.4/commands/CreateQueueCommand.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 {
   ConnectClientResolvedConfig,
   ServiceInputTypes,
@@ -17,19 +11,16 @@ export interface CreateQueueCommandInput extends CreateQueueRequest {}
 export interface CreateQueueCommandOutput
   extends CreateQueueResponse,
     __MetadataBearer {}
-export declare class CreateQueueCommand extends $Command<
-  CreateQueueCommandInput,
-  CreateQueueCommandOutput,
-  ConnectClientResolvedConfig
-> {
-  readonly input: CreateQueueCommandInput;
-  static getEndpointParameterInstructions(): EndpointParameterInstructions;
-  constructor(input: CreateQueueCommandInput);
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: ConnectClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<CreateQueueCommandInput, CreateQueueCommandOutput>;
-  private serialize;
-  private deserialize;
-}
+declare const CreateQueueCommand_base: {
+  new (
+    input: CreateQueueCommandInput
+  ): import("@smithy/smithy-client").CommandImpl<
+    CreateQueueCommandInput,
+    CreateQueueCommandOutput,
+    ConnectClientResolvedConfig,
+    ServiceInputTypes,
+    ServiceOutputTypes
+  >;
+  getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
+export declare class CreateQueueCommand extends CreateQueueCommand_base {}

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

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

package/dist-types/ts3.4/commands/CreateRuleCommand.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 {
   ConnectClientResolvedConfig,
   ServiceInputTypes,
@@ -17,19 +11,16 @@ export interface CreateRuleCommandInput extends CreateRuleRequest {}
 export interface CreateRuleCommandOutput
   extends CreateRuleResponse,
     __MetadataBearer {}
-export declare class CreateRuleCommand extends $Command<
-  CreateRuleCommandInput,
-  CreateRuleCommandOutput,
-  ConnectClientResolvedConfig
-> {
-  readonly input: CreateRuleCommandInput;
-  static getEndpointParameterInstructions(): EndpointParameterInstructions;
-  constructor(input: CreateRuleCommandInput);
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: ConnectClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<CreateRuleCommandInput, CreateRuleCommandOutput>;
-  private serialize;
-  private deserialize;
-}
+declare const CreateRuleCommand_base: {
+  new (
+    input: CreateRuleCommandInput
+  ): import("@smithy/smithy-client").CommandImpl<
+    CreateRuleCommandInput,
+    CreateRuleCommandOutput,
+    ConnectClientResolvedConfig,
+    ServiceInputTypes,
+    ServiceOutputTypes
+  >;
+  getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
+export declare class CreateRuleCommand extends CreateRuleCommand_base {}

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