@aws-sdk/client-connectcases 3.478.0 → 3.484.0

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

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

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

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

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

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

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

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

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

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

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

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

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

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