@aws-sdk/client-connectcases 3.184.0

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

@@ -0,0 +1,36 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ConnectCasesClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ConnectCasesClient";
+import { BatchPutFieldOptionsRequest, BatchPutFieldOptionsResponse } from "../models/models_0";
+export interface BatchPutFieldOptionsCommandInput extends BatchPutFieldOptionsRequest {
+}
+export interface BatchPutFieldOptionsCommandOutput extends BatchPutFieldOptionsResponse, __MetadataBearer {
+}
+/**
+ * <p>Creates and updates a set of field options for a single select field in a Cases
+ *       domain.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ConnectCasesClient, BatchPutFieldOptionsCommand } from "@aws-sdk/client-connectcases"; // ES Modules import
+ * // const { ConnectCasesClient, BatchPutFieldOptionsCommand } = require("@aws-sdk/client-connectcases"); // CommonJS import
+ * const client = new ConnectCasesClient(config);
+ * const command = new BatchPutFieldOptionsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link BatchPutFieldOptionsCommandInput} for command's `input` shape.
+ * @see {@link BatchPutFieldOptionsCommandOutput} for command's `response` shape.
+ * @see {@link ConnectCasesClientResolvedConfig | config} for ConnectCasesClient's `config` shape.
+ *
+ */
+export declare class BatchPutFieldOptionsCommand extends $Command<BatchPutFieldOptionsCommandInput, BatchPutFieldOptionsCommandOutput, ConnectCasesClientResolvedConfig> {
+    readonly input: BatchPutFieldOptionsCommandInput;
+    constructor(input: BatchPutFieldOptionsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConnectCasesClientResolvedConfig, options?: __HttpHandlerOptions): Handler<BatchPutFieldOptionsCommandInput, BatchPutFieldOptionsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,40 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ConnectCasesClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ConnectCasesClient";
+import { CreateCaseRequest, CreateCaseResponse } from "../models/models_0";
+export interface CreateCaseCommandInput extends CreateCaseRequest {
+}
+export interface CreateCaseCommandOutput extends CreateCaseResponse, __MetadataBearer {
+}
+/**
+ * <p>Creates a case in the specified Cases domain. Case system and custom fields are taken
+ *       as an array id/value pairs with a declared data types.</p>
+ *          <note>
+ *             <p>
+ *                <code>customer_id</code> is a required field when creating a case.</p>
+ *          </note>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ConnectCasesClient, CreateCaseCommand } from "@aws-sdk/client-connectcases"; // ES Modules import
+ * // const { ConnectCasesClient, CreateCaseCommand } = require("@aws-sdk/client-connectcases"); // CommonJS import
+ * const client = new ConnectCasesClient(config);
+ * const command = new CreateCaseCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateCaseCommandInput} for command's `input` shape.
+ * @see {@link CreateCaseCommandOutput} for command's `response` shape.
+ * @see {@link ConnectCasesClientResolvedConfig | config} for ConnectCasesClient's `config` shape.
+ *
+ */
+export declare class CreateCaseCommand extends $Command<CreateCaseCommandInput, CreateCaseCommandOutput, ConnectCasesClientResolvedConfig> {
+    readonly input: CreateCaseCommandInput;
+    constructor(input: CreateCaseCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConnectCasesClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateCaseCommandInput, CreateCaseCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,42 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ConnectCasesClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ConnectCasesClient";
+import { CreateDomainRequest, CreateDomainResponse } from "../models/models_0";
+export interface CreateDomainCommandInput extends CreateDomainRequest {
+}
+export interface CreateDomainCommandOutput extends CreateDomainResponse, __MetadataBearer {
+}
+/**
+ * <p>Creates a domain, which is a container for all case data, such as cases, fields, templates
+ *       and layouts. Each Amazon Connect instance can be associated with only one Cases
+ *       domain.</p>
+ *          <important>
+ *             <p>This will not associate your connect instance to Cases domain. Instead, use the
+ *           Amazon Connect
+ *         <a href="https://docs.aws.amazon.com/connect/latest/APIReference/API_CreateIntegrationAssociation.html">CreateIntegrationAssociation</a> API.</p>
+ *          </important>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ConnectCasesClient, CreateDomainCommand } from "@aws-sdk/client-connectcases"; // ES Modules import
+ * // const { ConnectCasesClient, CreateDomainCommand } = require("@aws-sdk/client-connectcases"); // CommonJS import
+ * const client = new ConnectCasesClient(config);
+ * const command = new CreateDomainCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateDomainCommandInput} for command's `input` shape.
+ * @see {@link CreateDomainCommandOutput} for command's `response` shape.
+ * @see {@link ConnectCasesClientResolvedConfig | config} for ConnectCasesClient's `config` shape.
+ *
+ */
+export declare class CreateDomainCommand extends $Command<CreateDomainCommandInput, CreateDomainCommandOutput, ConnectCasesClientResolvedConfig> {
+    readonly input: CreateDomainCommandInput;
+    constructor(input: CreateDomainCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConnectCasesClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateDomainCommandInput, CreateDomainCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,36 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ConnectCasesClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ConnectCasesClient";
+import { CreateFieldRequest, CreateFieldResponse } from "../models/models_0";
+export interface CreateFieldCommandInput extends CreateFieldRequest {
+}
+export interface CreateFieldCommandOutput extends CreateFieldResponse, __MetadataBearer {
+}
+/**
+ * <p>Creates a field in the Cases domain. This field is used to define the case object
+ *       model (that is, defines what data can be captured on cases) in a Cases domain. </p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ConnectCasesClient, CreateFieldCommand } from "@aws-sdk/client-connectcases"; // ES Modules import
+ * // const { ConnectCasesClient, CreateFieldCommand } = require("@aws-sdk/client-connectcases"); // CommonJS import
+ * const client = new ConnectCasesClient(config);
+ * const command = new CreateFieldCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateFieldCommandInput} for command's `input` shape.
+ * @see {@link CreateFieldCommandOutput} for command's `response` shape.
+ * @see {@link ConnectCasesClientResolvedConfig | config} for ConnectCasesClient's `config` shape.
+ *
+ */
+export declare class CreateFieldCommand extends $Command<CreateFieldCommandInput, CreateFieldCommandOutput, ConnectCasesClientResolvedConfig> {
+    readonly input: CreateFieldCommandInput;
+    constructor(input: CreateFieldCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConnectCasesClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateFieldCommandInput, CreateFieldCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,48 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ConnectCasesClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ConnectCasesClient";
+import { CreateLayoutRequest, CreateLayoutResponse } from "../models/models_0";
+export interface CreateLayoutCommandInput extends CreateLayoutRequest {
+}
+export interface CreateLayoutCommandOutput extends CreateLayoutResponse, __MetadataBearer {
+}
+/**
+ * <p>Creates a layout in the Cases domain. Layouts define the following configuration in
+ *       the top section and More Info tab of the Cases user interface:</p>
+ *          <ul>
+ *             <li>
+ *                <p>Fields to display to the users</p>
+ *             </li>
+ *             <li>
+ *                <p>Field ordering</p>
+ *             </li>
+ *          </ul>
+ *          <note>
+ *             <p>Title and Status fields cannot be part of layouts since they are not
+ *         configurable.</p>
+ *          </note>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ConnectCasesClient, CreateLayoutCommand } from "@aws-sdk/client-connectcases"; // ES Modules import
+ * // const { ConnectCasesClient, CreateLayoutCommand } = require("@aws-sdk/client-connectcases"); // CommonJS import
+ * const client = new ConnectCasesClient(config);
+ * const command = new CreateLayoutCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateLayoutCommandInput} for command's `input` shape.
+ * @see {@link CreateLayoutCommandOutput} for command's `response` shape.
+ * @see {@link ConnectCasesClientResolvedConfig | config} for ConnectCasesClient's `config` shape.
+ *
+ */
+export declare class CreateLayoutCommand extends $Command<CreateLayoutCommandInput, CreateLayoutCommandOutput, ConnectCasesClientResolvedConfig> {
+    readonly input: CreateLayoutCommandInput;
+    constructor(input: CreateLayoutCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConnectCasesClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateLayoutCommandInput, CreateLayoutCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,43 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ConnectCasesClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ConnectCasesClient";
+import { CreateRelatedItemRequest, CreateRelatedItemResponse } from "../models/models_0";
+export interface CreateRelatedItemCommandInput extends CreateRelatedItemRequest {
+}
+export interface CreateRelatedItemCommandOutput extends CreateRelatedItemResponse, __MetadataBearer {
+}
+/**
+ * <p>Creates a related item (comments, tasks, and contacts) and associates it with a
+ *       case.</p>
+ *          <note>
+ *             <p>A Related Item is a resource that is associated with a case. It may or may not have an
+ *         external identifier linking it to an external resource (for example, a
+ *           <code>contactArn</code>). All Related Items have their own internal identifier, the
+ *           <code>relatedItemArn</code>. Examples of related items include <code>comments</code> and
+ *           <code>contacts</code>.</p>
+ *          </note>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ConnectCasesClient, CreateRelatedItemCommand } from "@aws-sdk/client-connectcases"; // ES Modules import
+ * // const { ConnectCasesClient, CreateRelatedItemCommand } = require("@aws-sdk/client-connectcases"); // CommonJS import
+ * const client = new ConnectCasesClient(config);
+ * const command = new CreateRelatedItemCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateRelatedItemCommandInput} for command's `input` shape.
+ * @see {@link CreateRelatedItemCommandOutput} for command's `response` shape.
+ * @see {@link ConnectCasesClientResolvedConfig | config} for ConnectCasesClient's `config` shape.
+ *
+ */
+export declare class CreateRelatedItemCommand extends $Command<CreateRelatedItemCommandInput, CreateRelatedItemCommandOutput, ConnectCasesClientResolvedConfig> {
+    readonly input: CreateRelatedItemCommandInput;
+    constructor(input: CreateRelatedItemCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConnectCasesClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateRelatedItemCommandInput, CreateRelatedItemCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,38 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ConnectCasesClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ConnectCasesClient";
+import { CreateTemplateRequest, CreateTemplateResponse } from "../models/models_0";
+export interface CreateTemplateCommandInput extends CreateTemplateRequest {
+}
+export interface CreateTemplateCommandOutput extends CreateTemplateResponse, __MetadataBearer {
+}
+/**
+ * <p>Creates a template in the Cases domain. This template is used to define the case
+ *       object model (that is, define what data can be captured on cases) in a Cases domain. A
+ *       template must have a unique name within a domain, and it must reference existing field IDs and layout
+ *       IDs. Additionally, multiple fields with same IDs are not allowed within the same Template.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ConnectCasesClient, CreateTemplateCommand } from "@aws-sdk/client-connectcases"; // ES Modules import
+ * // const { ConnectCasesClient, CreateTemplateCommand } = require("@aws-sdk/client-connectcases"); // CommonJS import
+ * const client = new ConnectCasesClient(config);
+ * const command = new CreateTemplateCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateTemplateCommandInput} for command's `input` shape.
+ * @see {@link CreateTemplateCommandOutput} for command's `response` shape.
+ * @see {@link ConnectCasesClientResolvedConfig | config} for ConnectCasesClient's `config` shape.
+ *
+ */
+export declare class CreateTemplateCommand extends $Command<CreateTemplateCommandInput, CreateTemplateCommandOutput, ConnectCasesClientResolvedConfig> {
+    readonly input: CreateTemplateCommandInput;
+    constructor(input: CreateTemplateCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConnectCasesClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateTemplateCommandInput, CreateTemplateCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ConnectCasesClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ConnectCasesClient";
+import { GetCaseRequest, GetCaseResponse } from "../models/models_0";
+export interface GetCaseCommandInput extends GetCaseRequest {
+}
+export interface GetCaseCommandOutput extends GetCaseResponse, __MetadataBearer {
+}
+/**
+ * <p>Returns information about a specific case if it exists. </p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ConnectCasesClient, GetCaseCommand } from "@aws-sdk/client-connectcases"; // ES Modules import
+ * // const { ConnectCasesClient, GetCaseCommand } = require("@aws-sdk/client-connectcases"); // CommonJS import
+ * const client = new ConnectCasesClient(config);
+ * const command = new GetCaseCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetCaseCommandInput} for command's `input` shape.
+ * @see {@link GetCaseCommandOutput} for command's `response` shape.
+ * @see {@link ConnectCasesClientResolvedConfig | config} for ConnectCasesClient's `config` shape.
+ *
+ */
+export declare class GetCaseCommand extends $Command<GetCaseCommandInput, GetCaseCommandOutput, ConnectCasesClientResolvedConfig> {
+    readonly input: GetCaseCommandInput;
+    constructor(input: GetCaseCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConnectCasesClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetCaseCommandInput, GetCaseCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ConnectCasesClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ConnectCasesClient";
+import { GetCaseEventConfigurationRequest, GetCaseEventConfigurationResponse } from "../models/models_0";
+export interface GetCaseEventConfigurationCommandInput extends GetCaseEventConfigurationRequest {
+}
+export interface GetCaseEventConfigurationCommandOutput extends GetCaseEventConfigurationResponse, __MetadataBearer {
+}
+/**
+ * <p>Returns the case event publishing configuration.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ConnectCasesClient, GetCaseEventConfigurationCommand } from "@aws-sdk/client-connectcases"; // ES Modules import
+ * // const { ConnectCasesClient, GetCaseEventConfigurationCommand } = require("@aws-sdk/client-connectcases"); // CommonJS import
+ * const client = new ConnectCasesClient(config);
+ * const command = new GetCaseEventConfigurationCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetCaseEventConfigurationCommandInput} for command's `input` shape.
+ * @see {@link GetCaseEventConfigurationCommandOutput} for command's `response` shape.
+ * @see {@link ConnectCasesClientResolvedConfig | config} for ConnectCasesClient's `config` shape.
+ *
+ */
+export declare class GetCaseEventConfigurationCommand extends $Command<GetCaseEventConfigurationCommandInput, GetCaseEventConfigurationCommandOutput, ConnectCasesClientResolvedConfig> {
+    readonly input: GetCaseEventConfigurationCommandInput;
+    constructor(input: GetCaseEventConfigurationCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConnectCasesClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetCaseEventConfigurationCommandInput, GetCaseEventConfigurationCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ConnectCasesClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ConnectCasesClient";
+import { GetDomainRequest, GetDomainResponse } from "../models/models_0";
+export interface GetDomainCommandInput extends GetDomainRequest {
+}
+export interface GetDomainCommandOutput extends GetDomainResponse, __MetadataBearer {
+}
+/**
+ * <p>Returns information about a specific domain if it exists. </p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ConnectCasesClient, GetDomainCommand } from "@aws-sdk/client-connectcases"; // ES Modules import
+ * // const { ConnectCasesClient, GetDomainCommand } = require("@aws-sdk/client-connectcases"); // CommonJS import
+ * const client = new ConnectCasesClient(config);
+ * const command = new GetDomainCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetDomainCommandInput} for command's `input` shape.
+ * @see {@link GetDomainCommandOutput} for command's `response` shape.
+ * @see {@link ConnectCasesClientResolvedConfig | config} for ConnectCasesClient's `config` shape.
+ *
+ */
+export declare class GetDomainCommand extends $Command<GetDomainCommandInput, GetDomainCommandOutput, ConnectCasesClientResolvedConfig> {
+    readonly input: GetDomainCommandInput;
+    constructor(input: GetDomainCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConnectCasesClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetDomainCommandInput, GetDomainCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ConnectCasesClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ConnectCasesClient";
+import { GetLayoutRequest, GetLayoutResponse } from "../models/models_0";
+export interface GetLayoutCommandInput extends GetLayoutRequest {
+}
+export interface GetLayoutCommandOutput extends GetLayoutResponse, __MetadataBearer {
+}
+/**
+ * <p>Returns the details for the requested layout.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ConnectCasesClient, GetLayoutCommand } from "@aws-sdk/client-connectcases"; // ES Modules import
+ * // const { ConnectCasesClient, GetLayoutCommand } = require("@aws-sdk/client-connectcases"); // CommonJS import
+ * const client = new ConnectCasesClient(config);
+ * const command = new GetLayoutCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetLayoutCommandInput} for command's `input` shape.
+ * @see {@link GetLayoutCommandOutput} for command's `response` shape.
+ * @see {@link ConnectCasesClientResolvedConfig | config} for ConnectCasesClient's `config` shape.
+ *
+ */
+export declare class GetLayoutCommand extends $Command<GetLayoutCommandInput, GetLayoutCommandOutput, ConnectCasesClientResolvedConfig> {
+    readonly input: GetLayoutCommandInput;
+    constructor(input: GetLayoutCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConnectCasesClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetLayoutCommandInput, GetLayoutCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ConnectCasesClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ConnectCasesClient";
+import { GetTemplateRequest, GetTemplateResponse } from "../models/models_0";
+export interface GetTemplateCommandInput extends GetTemplateRequest {
+}
+export interface GetTemplateCommandOutput extends GetTemplateResponse, __MetadataBearer {
+}
+/**
+ * <p>Returns the details for the requested template. </p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ConnectCasesClient, GetTemplateCommand } from "@aws-sdk/client-connectcases"; // ES Modules import
+ * // const { ConnectCasesClient, GetTemplateCommand } = require("@aws-sdk/client-connectcases"); // CommonJS import
+ * const client = new ConnectCasesClient(config);
+ * const command = new GetTemplateCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetTemplateCommandInput} for command's `input` shape.
+ * @see {@link GetTemplateCommandOutput} for command's `response` shape.
+ * @see {@link ConnectCasesClientResolvedConfig | config} for ConnectCasesClient's `config` shape.
+ *
+ */
+export declare class GetTemplateCommand extends $Command<GetTemplateCommandInput, GetTemplateCommandOutput, ConnectCasesClientResolvedConfig> {
+    readonly input: GetTemplateCommandInput;
+    constructor(input: GetTemplateCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConnectCasesClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetTemplateCommandInput, GetTemplateCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ConnectCasesClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ConnectCasesClient";
+import { ListCasesForContactRequest, ListCasesForContactResponse } from "../models/models_0";
+export interface ListCasesForContactCommandInput extends ListCasesForContactRequest {
+}
+export interface ListCasesForContactCommandOutput extends ListCasesForContactResponse, __MetadataBearer {
+}
+/**
+ * <p>Lists cases for a given contact.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ConnectCasesClient, ListCasesForContactCommand } from "@aws-sdk/client-connectcases"; // ES Modules import
+ * // const { ConnectCasesClient, ListCasesForContactCommand } = require("@aws-sdk/client-connectcases"); // CommonJS import
+ * const client = new ConnectCasesClient(config);
+ * const command = new ListCasesForContactCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListCasesForContactCommandInput} for command's `input` shape.
+ * @see {@link ListCasesForContactCommandOutput} for command's `response` shape.
+ * @see {@link ConnectCasesClientResolvedConfig | config} for ConnectCasesClient's `config` shape.
+ *
+ */
+export declare class ListCasesForContactCommand extends $Command<ListCasesForContactCommandInput, ListCasesForContactCommandOutput, ConnectCasesClientResolvedConfig> {
+    readonly input: ListCasesForContactCommandInput;
+    constructor(input: ListCasesForContactCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConnectCasesClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListCasesForContactCommandInput, ListCasesForContactCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,36 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ConnectCasesClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ConnectCasesClient";
+import { ListDomainsRequest, ListDomainsResponse } from "../models/models_0";
+export interface ListDomainsCommandInput extends ListDomainsRequest {
+}
+export interface ListDomainsCommandOutput extends ListDomainsResponse, __MetadataBearer {
+}
+/**
+ * <p>Lists all cases domains in the Amazon Web Services account. Each list item is a condensed
+ *       summary object of the domain.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ConnectCasesClient, ListDomainsCommand } from "@aws-sdk/client-connectcases"; // ES Modules import
+ * // const { ConnectCasesClient, ListDomainsCommand } = require("@aws-sdk/client-connectcases"); // CommonJS import
+ * const client = new ConnectCasesClient(config);
+ * const command = new ListDomainsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListDomainsCommandInput} for command's `input` shape.
+ * @see {@link ListDomainsCommandOutput} for command's `response` shape.
+ * @see {@link ConnectCasesClientResolvedConfig | config} for ConnectCasesClient's `config` shape.
+ *
+ */
+export declare class ListDomainsCommand extends $Command<ListDomainsCommandInput, ListDomainsCommandOutput, ConnectCasesClientResolvedConfig> {
+    readonly input: ListDomainsCommandInput;
+    constructor(input: ListDomainsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConnectCasesClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListDomainsCommandInput, ListDomainsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ConnectCasesClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ConnectCasesClient";
+import { ListFieldOptionsRequest, ListFieldOptionsResponse } from "../models/models_0";
+export interface ListFieldOptionsCommandInput extends ListFieldOptionsRequest {
+}
+export interface ListFieldOptionsCommandOutput extends ListFieldOptionsResponse, __MetadataBearer {
+}
+/**
+ * <p>Lists all of the field options for a field identifier in the domain. </p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ConnectCasesClient, ListFieldOptionsCommand } from "@aws-sdk/client-connectcases"; // ES Modules import
+ * // const { ConnectCasesClient, ListFieldOptionsCommand } = require("@aws-sdk/client-connectcases"); // CommonJS import
+ * const client = new ConnectCasesClient(config);
+ * const command = new ListFieldOptionsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListFieldOptionsCommandInput} for command's `input` shape.
+ * @see {@link ListFieldOptionsCommandOutput} for command's `response` shape.
+ * @see {@link ConnectCasesClientResolvedConfig | config} for ConnectCasesClient's `config` shape.
+ *
+ */
+export declare class ListFieldOptionsCommand extends $Command<ListFieldOptionsCommandInput, ListFieldOptionsCommandOutput, ConnectCasesClientResolvedConfig> {
+    readonly input: ListFieldOptionsCommandInput;
+    constructor(input: ListFieldOptionsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConnectCasesClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListFieldOptionsCommandInput, ListFieldOptionsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ConnectCasesClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ConnectCasesClient";
+import { ListFieldsRequest, ListFieldsResponse } from "../models/models_0";
+export interface ListFieldsCommandInput extends ListFieldsRequest {
+}
+export interface ListFieldsCommandOutput extends ListFieldsResponse, __MetadataBearer {
+}
+/**
+ * <p>Lists all fields in a Cases domain.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ConnectCasesClient, ListFieldsCommand } from "@aws-sdk/client-connectcases"; // ES Modules import
+ * // const { ConnectCasesClient, ListFieldsCommand } = require("@aws-sdk/client-connectcases"); // CommonJS import
+ * const client = new ConnectCasesClient(config);
+ * const command = new ListFieldsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListFieldsCommandInput} for command's `input` shape.
+ * @see {@link ListFieldsCommandOutput} for command's `response` shape.
+ * @see {@link ConnectCasesClientResolvedConfig | config} for ConnectCasesClient's `config` shape.
+ *
+ */
+export declare class ListFieldsCommand extends $Command<ListFieldsCommandInput, ListFieldsCommandOutput, ConnectCasesClientResolvedConfig> {
+    readonly input: ListFieldsCommandInput;
+    constructor(input: ListFieldsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConnectCasesClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListFieldsCommandInput, ListFieldsCommandOutput>;
+    private serialize;
+    private deserialize;
+}