@aws-sdk/client-connectcases 3.184.0

package/dist-types/commands/ListLayoutsCommand.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 { ListLayoutsRequest, ListLayoutsResponse } from "../models/models_0";
+export interface ListLayoutsCommandInput extends ListLayoutsRequest {
+}
+export interface ListLayoutsCommandOutput extends ListLayoutsResponse, __MetadataBearer {
+}
+/**
+ * <p>Lists all layouts in the given cases domain. Each list item is a condensed summary object
+ *       of the layout.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ConnectCasesClient, ListLayoutsCommand } from "@aws-sdk/client-connectcases"; // ES Modules import
+ * // const { ConnectCasesClient, ListLayoutsCommand } = require("@aws-sdk/client-connectcases"); // CommonJS import
+ * const client = new ConnectCasesClient(config);
+ * const command = new ListLayoutsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListLayoutsCommandInput} for command's `input` shape.
+ * @see {@link ListLayoutsCommandOutput} for command's `response` shape.
+ * @see {@link ConnectCasesClientResolvedConfig | config} for ConnectCasesClient's `config` shape.
+ *
+ */
+export declare class ListLayoutsCommand extends $Command<ListLayoutsCommandInput, ListLayoutsCommandOutput, ConnectCasesClientResolvedConfig> {
+    readonly input: ListLayoutsCommandInput;
+    constructor(input: ListLayoutsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConnectCasesClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListLayoutsCommandInput, ListLayoutsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/ListTagsForResourceCommand.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 { ListTagsForResourceRequest, ListTagsForResourceResponse } from "../models/models_0";
+export interface ListTagsForResourceCommandInput extends ListTagsForResourceRequest {
+}
+export interface ListTagsForResourceCommandOutput extends ListTagsForResourceResponse, __MetadataBearer {
+}
+/**
+ * <p>Lists tags for a resource.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ConnectCasesClient, ListTagsForResourceCommand } from "@aws-sdk/client-connectcases"; // ES Modules import
+ * // const { ConnectCasesClient, ListTagsForResourceCommand } = require("@aws-sdk/client-connectcases"); // CommonJS import
+ * const client = new ConnectCasesClient(config);
+ * const command = new ListTagsForResourceCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListTagsForResourceCommandInput} for command's `input` shape.
+ * @see {@link ListTagsForResourceCommandOutput} for command's `response` shape.
+ * @see {@link ConnectCasesClientResolvedConfig | config} for ConnectCasesClient's `config` shape.
+ *
+ */
+export declare class ListTagsForResourceCommand extends $Command<ListTagsForResourceCommandInput, ListTagsForResourceCommandOutput, ConnectCasesClientResolvedConfig> {
+    readonly input: ListTagsForResourceCommandInput;
+    constructor(input: ListTagsForResourceCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConnectCasesClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListTagsForResourceCommandInput, ListTagsForResourceCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/ListTemplatesCommand.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 { ListTemplatesRequest, ListTemplatesResponse } from "../models/models_0";
+export interface ListTemplatesCommandInput extends ListTemplatesRequest {
+}
+export interface ListTemplatesCommandOutput extends ListTemplatesResponse, __MetadataBearer {
+}
+/**
+ * <p>Lists all of the templates in a Cases domain. Each list item is a condensed summary
+ *       object of the template. </p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ConnectCasesClient, ListTemplatesCommand } from "@aws-sdk/client-connectcases"; // ES Modules import
+ * // const { ConnectCasesClient, ListTemplatesCommand } = require("@aws-sdk/client-connectcases"); // CommonJS import
+ * const client = new ConnectCasesClient(config);
+ * const command = new ListTemplatesCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListTemplatesCommandInput} for command's `input` shape.
+ * @see {@link ListTemplatesCommandOutput} for command's `response` shape.
+ * @see {@link ConnectCasesClientResolvedConfig | config} for ConnectCasesClient's `config` shape.
+ *
+ */
+export declare class ListTemplatesCommand extends $Command<ListTemplatesCommandInput, ListTemplatesCommandOutput, ConnectCasesClientResolvedConfig> {
+    readonly input: ListTemplatesCommandInput;
+    constructor(input: ListTemplatesCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConnectCasesClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListTemplatesCommandInput, ListTemplatesCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/PutCaseEventConfigurationCommand.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 { PutCaseEventConfigurationRequest, PutCaseEventConfigurationResponse } from "../models/models_0";
+export interface PutCaseEventConfigurationCommandInput extends PutCaseEventConfigurationRequest {
+}
+export interface PutCaseEventConfigurationCommandOutput extends PutCaseEventConfigurationResponse, __MetadataBearer {
+}
+/**
+ * <p>API for adding case event publishing configuration</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ConnectCasesClient, PutCaseEventConfigurationCommand } from "@aws-sdk/client-connectcases"; // ES Modules import
+ * // const { ConnectCasesClient, PutCaseEventConfigurationCommand } = require("@aws-sdk/client-connectcases"); // CommonJS import
+ * const client = new ConnectCasesClient(config);
+ * const command = new PutCaseEventConfigurationCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link PutCaseEventConfigurationCommandInput} for command's `input` shape.
+ * @see {@link PutCaseEventConfigurationCommandOutput} for command's `response` shape.
+ * @see {@link ConnectCasesClientResolvedConfig | config} for ConnectCasesClient's `config` shape.
+ *
+ */
+export declare class PutCaseEventConfigurationCommand extends $Command<PutCaseEventConfigurationCommandInput, PutCaseEventConfigurationCommandOutput, ConnectCasesClientResolvedConfig> {
+    readonly input: PutCaseEventConfigurationCommandInput;
+    constructor(input: PutCaseEventConfigurationCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConnectCasesClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutCaseEventConfigurationCommandInput, PutCaseEventConfigurationCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/SearchCasesCommand.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 { SearchCasesRequest, SearchCasesResponse } from "../models/models_0";
+export interface SearchCasesCommandInput extends SearchCasesRequest {
+}
+export interface SearchCasesCommandOutput extends SearchCasesResponse, __MetadataBearer {
+}
+/**
+ * <p>Searches for cases within their associated Cases domain. Search results are returned
+ *       as a paginated list of abridged case documents.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ConnectCasesClient, SearchCasesCommand } from "@aws-sdk/client-connectcases"; // ES Modules import
+ * // const { ConnectCasesClient, SearchCasesCommand } = require("@aws-sdk/client-connectcases"); // CommonJS import
+ * const client = new ConnectCasesClient(config);
+ * const command = new SearchCasesCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link SearchCasesCommandInput} for command's `input` shape.
+ * @see {@link SearchCasesCommandOutput} for command's `response` shape.
+ * @see {@link ConnectCasesClientResolvedConfig | config} for ConnectCasesClient's `config` shape.
+ *
+ */
+export declare class SearchCasesCommand extends $Command<SearchCasesCommandInput, SearchCasesCommandOutput, ConnectCasesClientResolvedConfig> {
+    readonly input: SearchCasesCommandInput;
+    constructor(input: SearchCasesCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConnectCasesClientResolvedConfig, options?: __HttpHandlerOptions): Handler<SearchCasesCommandInput, SearchCasesCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,39 @@
+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 { SearchRelatedItemsRequest, SearchRelatedItemsResponse } from "../models/models_0";
+export interface SearchRelatedItemsCommandInput extends SearchRelatedItemsRequest {
+}
+export interface SearchRelatedItemsCommandOutput extends SearchRelatedItemsResponse, __MetadataBearer {
+}
+/**
+ * <p>Searches for related items that are associated with a case.</p>
+ *          <note>
+ *             <p>If no filters are provided, this returns all related items associated with a
+ *         case.</p>
+ *          </note>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ConnectCasesClient, SearchRelatedItemsCommand } from "@aws-sdk/client-connectcases"; // ES Modules import
+ * // const { ConnectCasesClient, SearchRelatedItemsCommand } = require("@aws-sdk/client-connectcases"); // CommonJS import
+ * const client = new ConnectCasesClient(config);
+ * const command = new SearchRelatedItemsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link SearchRelatedItemsCommandInput} for command's `input` shape.
+ * @see {@link SearchRelatedItemsCommandOutput} for command's `response` shape.
+ * @see {@link ConnectCasesClientResolvedConfig | config} for ConnectCasesClient's `config` shape.
+ *
+ */
+export declare class SearchRelatedItemsCommand extends $Command<SearchRelatedItemsCommandInput, SearchRelatedItemsCommandOutput, ConnectCasesClientResolvedConfig> {
+    readonly input: SearchRelatedItemsCommandInput;
+    constructor(input: SearchRelatedItemsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConnectCasesClientResolvedConfig, options?: __HttpHandlerOptions): Handler<SearchRelatedItemsCommandInput, SearchRelatedItemsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/TagResourceCommand.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 { TagResourceRequest } from "../models/models_0";
+export interface TagResourceCommandInput extends TagResourceRequest {
+}
+export interface TagResourceCommandOutput extends __MetadataBearer {
+}
+/**
+ * <p>Adds tags to a resource.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ConnectCasesClient, TagResourceCommand } from "@aws-sdk/client-connectcases"; // ES Modules import
+ * // const { ConnectCasesClient, TagResourceCommand } = require("@aws-sdk/client-connectcases"); // CommonJS import
+ * const client = new ConnectCasesClient(config);
+ * const command = new TagResourceCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link TagResourceCommandInput} for command's `input` shape.
+ * @see {@link TagResourceCommandOutput} for command's `response` shape.
+ * @see {@link ConnectCasesClientResolvedConfig | config} for ConnectCasesClient's `config` shape.
+ *
+ */
+export declare class TagResourceCommand extends $Command<TagResourceCommandInput, TagResourceCommandOutput, ConnectCasesClientResolvedConfig> {
+    readonly input: TagResourceCommandInput;
+    constructor(input: TagResourceCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConnectCasesClientResolvedConfig, options?: __HttpHandlerOptions): Handler<TagResourceCommandInput, TagResourceCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/UntagResourceCommand.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 { UntagResourceRequest } from "../models/models_0";
+export interface UntagResourceCommandInput extends UntagResourceRequest {
+}
+export interface UntagResourceCommandOutput extends __MetadataBearer {
+}
+/**
+ * <p>Untags a resource.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ConnectCasesClient, UntagResourceCommand } from "@aws-sdk/client-connectcases"; // ES Modules import
+ * // const { ConnectCasesClient, UntagResourceCommand } = require("@aws-sdk/client-connectcases"); // CommonJS import
+ * const client = new ConnectCasesClient(config);
+ * const command = new UntagResourceCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link UntagResourceCommandInput} for command's `input` shape.
+ * @see {@link UntagResourceCommandOutput} for command's `response` shape.
+ * @see {@link ConnectCasesClientResolvedConfig | config} for ConnectCasesClient's `config` shape.
+ *
+ */
+export declare class UntagResourceCommand extends $Command<UntagResourceCommandInput, UntagResourceCommandOutput, ConnectCasesClientResolvedConfig> {
+    readonly input: UntagResourceCommandInput;
+    constructor(input: UntagResourceCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConnectCasesClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UntagResourceCommandInput, UntagResourceCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/UpdateCaseCommand.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 { UpdateCaseRequest, UpdateCaseResponse } from "../models/models_0";
+export interface UpdateCaseCommandInput extends UpdateCaseRequest {
+}
+export interface UpdateCaseCommandOutput extends UpdateCaseResponse, __MetadataBearer {
+}
+/**
+ * <p>Updates the values of fields on a case. Fields to be updated are
+ *       received as an array of id/value pairs identical to the <code>CreateCase</code> input .</p>
+ *          <p>If the action is successful, the service sends back an HTTP 200 response with an empty
+ *       HTTP body.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ConnectCasesClient, UpdateCaseCommand } from "@aws-sdk/client-connectcases"; // ES Modules import
+ * // const { ConnectCasesClient, UpdateCaseCommand } = require("@aws-sdk/client-connectcases"); // CommonJS import
+ * const client = new ConnectCasesClient(config);
+ * const command = new UpdateCaseCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link UpdateCaseCommandInput} for command's `input` shape.
+ * @see {@link UpdateCaseCommandOutput} for command's `response` shape.
+ * @see {@link ConnectCasesClientResolvedConfig | config} for ConnectCasesClient's `config` shape.
+ *
+ */
+export declare class UpdateCaseCommand extends $Command<UpdateCaseCommandInput, UpdateCaseCommandOutput, ConnectCasesClientResolvedConfig> {
+    readonly input: UpdateCaseCommandInput;
+    constructor(input: UpdateCaseCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConnectCasesClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateCaseCommandInput, UpdateCaseCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/UpdateFieldCommand.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 { UpdateFieldRequest, UpdateFieldResponse } from "../models/models_0";
+export interface UpdateFieldCommandInput extends UpdateFieldRequest {
+}
+export interface UpdateFieldCommandOutput extends UpdateFieldResponse, __MetadataBearer {
+}
+/**
+ * <p>Updates the properties of an existing field. </p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ConnectCasesClient, UpdateFieldCommand } from "@aws-sdk/client-connectcases"; // ES Modules import
+ * // const { ConnectCasesClient, UpdateFieldCommand } = require("@aws-sdk/client-connectcases"); // CommonJS import
+ * const client = new ConnectCasesClient(config);
+ * const command = new UpdateFieldCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link UpdateFieldCommandInput} for command's `input` shape.
+ * @see {@link UpdateFieldCommandOutput} for command's `response` shape.
+ * @see {@link ConnectCasesClientResolvedConfig | config} for ConnectCasesClient's `config` shape.
+ *
+ */
+export declare class UpdateFieldCommand extends $Command<UpdateFieldCommandInput, UpdateFieldCommandOutput, ConnectCasesClientResolvedConfig> {
+    readonly input: UpdateFieldCommandInput;
+    constructor(input: UpdateFieldCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConnectCasesClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateFieldCommandInput, UpdateFieldCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/UpdateLayoutCommand.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 { UpdateLayoutRequest, UpdateLayoutResponse } from "../models/models_0";
+export interface UpdateLayoutCommandInput extends UpdateLayoutRequest {
+}
+export interface UpdateLayoutCommandOutput extends UpdateLayoutResponse, __MetadataBearer {
+}
+/**
+ * <p>Updates the attributes of an existing layout.</p>
+ *          <p>If the action is successful, the service sends back an HTTP 200 response with an empty
+ *       HTTP body.</p>
+ *          <p>A <code>ValidationException</code> is returned when you add non-existent
+ *         <code>fieldIds</code> to a layout.</p>
+ *          <note>
+ *             <p>Title and Status fields cannot be part of layouts because 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, UpdateLayoutCommand } from "@aws-sdk/client-connectcases"; // ES Modules import
+ * // const { ConnectCasesClient, UpdateLayoutCommand } = require("@aws-sdk/client-connectcases"); // CommonJS import
+ * const client = new ConnectCasesClient(config);
+ * const command = new UpdateLayoutCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link UpdateLayoutCommandInput} for command's `input` shape.
+ * @see {@link UpdateLayoutCommandOutput} for command's `response` shape.
+ * @see {@link ConnectCasesClientResolvedConfig | config} for ConnectCasesClient's `config` shape.
+ *
+ */
+export declare class UpdateLayoutCommand extends $Command<UpdateLayoutCommandInput, UpdateLayoutCommandOutput, ConnectCasesClientResolvedConfig> {
+    readonly input: UpdateLayoutCommandInput;
+    constructor(input: UpdateLayoutCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConnectCasesClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateLayoutCommandInput, UpdateLayoutCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,39 @@
+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 { UpdateTemplateRequest, UpdateTemplateResponse } from "../models/models_0";
+export interface UpdateTemplateCommandInput extends UpdateTemplateRequest {
+}
+export interface UpdateTemplateCommandOutput extends UpdateTemplateResponse, __MetadataBearer {
+}
+/**
+ * <p>Updates the attributes of an existing template. The template attributes that can be
+ *       modified include <code>name</code>, <code>description</code>, <code>layouts</code>,
+ *         and <code>requiredFields</code>. At least one of these
+ *       attributes must not be null. If a null value is provided for a given attribute, that attribute
+ *       is ignored and its current value is preserved.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ConnectCasesClient, UpdateTemplateCommand } from "@aws-sdk/client-connectcases"; // ES Modules import
+ * // const { ConnectCasesClient, UpdateTemplateCommand } = require("@aws-sdk/client-connectcases"); // CommonJS import
+ * const client = new ConnectCasesClient(config);
+ * const command = new UpdateTemplateCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link UpdateTemplateCommandInput} for command's `input` shape.
+ * @see {@link UpdateTemplateCommandOutput} for command's `response` shape.
+ * @see {@link ConnectCasesClientResolvedConfig | config} for ConnectCasesClient's `config` shape.
+ *
+ */
+export declare class UpdateTemplateCommand extends $Command<UpdateTemplateCommandInput, UpdateTemplateCommandOutput, ConnectCasesClientResolvedConfig> {
+    readonly input: UpdateTemplateCommandInput;
+    constructor(input: UpdateTemplateCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConnectCasesClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateTemplateCommandInput, UpdateTemplateCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,29 @@
+export * from "./BatchGetFieldCommand";
+export * from "./BatchPutFieldOptionsCommand";
+export * from "./CreateCaseCommand";
+export * from "./CreateDomainCommand";
+export * from "./CreateFieldCommand";
+export * from "./CreateLayoutCommand";
+export * from "./CreateRelatedItemCommand";
+export * from "./CreateTemplateCommand";
+export * from "./GetCaseCommand";
+export * from "./GetCaseEventConfigurationCommand";
+export * from "./GetDomainCommand";
+export * from "./GetLayoutCommand";
+export * from "./GetTemplateCommand";
+export * from "./ListCasesForContactCommand";
+export * from "./ListDomainsCommand";
+export * from "./ListFieldOptionsCommand";
+export * from "./ListFieldsCommand";
+export * from "./ListLayoutsCommand";
+export * from "./ListTagsForResourceCommand";
+export * from "./ListTemplatesCommand";
+export * from "./PutCaseEventConfigurationCommand";
+export * from "./SearchCasesCommand";
+export * from "./SearchRelatedItemsCommand";
+export * from "./TagResourceCommand";
+export * from "./UntagResourceCommand";
+export * from "./UpdateCaseCommand";
+export * from "./UpdateFieldCommand";
+export * from "./UpdateLayoutCommand";
+export * from "./UpdateTemplateCommand";

package/dist-types/endpoints.d.ts

@@ -0,0 +1,2 @@
+import { RegionInfoProvider } from "@aws-sdk/types";
+export declare const defaultRegionInfoProvider: RegionInfoProvider;

package/dist-types/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./ConnectCases";
+export * from "./ConnectCasesClient";
+export * from "./commands";
+export * from "./models";
+export * from "./pagination";
+export { ConnectCasesServiceException } from "./models/ConnectCasesServiceException";

package/dist-types/models/ConnectCasesServiceException.d.ts

@@ -0,0 +1,10 @@
+import { ServiceException as __ServiceException, ServiceExceptionOptions as __ServiceExceptionOptions } from "@aws-sdk/smithy-client";
+/**
+ * Base exception class for all service exceptions from ConnectCases service.
+ */
+export declare class ConnectCasesServiceException extends __ServiceException {
+    /**
+     * @internal
+     */
+    constructor(options: __ServiceExceptionOptions);
+}

package/dist-types/models/index.d.ts

@@ -0,0 +1 @@
+export * from "./models_0";