AWS.ConnectCases — AWS SDK for JavaScript (original) (raw)

We recommend that you migrate to AWS SDK for JavaScript v3. For dates, additional details, and information on how to migrate, please refer to the linked announcement.

Overview

Constructs a service interface object. Each API operation is exposed as a function on service.

Service Description

With Amazon Connect Cases, your agents can track and manage customer issues that require multiple interactions, follow-up tasks, and teams in your contact center. A case represents a customer issue. It records the issue, the steps and interactions taken to resolve the issue, and the outcome. For more information, see Amazon Connect Cases in the Amazon Connect Administrator Guide.

Sending a Request Using ConnectCases

var connectcases = new AWS.ConnectCases();
connectcases.batchGetField(params, function (err, data) {
  if (err) console.log(err, err.stack); // an error occurred
  else     console.log(data);           // successful response
});

Locking the API Version

In order to ensure that the ConnectCases object uses this specific API, you can construct the object by passing the apiVersion option to the constructor:

var connectcases = new AWS.ConnectCases({apiVersion: '2022-10-03'});

You can also set the API version globally in AWS.config.apiVersions using the connectcases service identifier:

AWS.config.apiVersions = {
  connectcases: '2022-10-03',
  // other service API versions
};

var connectcases = new AWS.ConnectCases();

Constructor Summarycollapse

Property Summarycollapse

Properties inherited from AWS.Service

apiVersions

Method Summarycollapse

 <p>Creates a case in the specified Cases domain.

``

````` * createDomain(params = {}, callback) ⇒ AWS.Request
Creates a domain, which is a container for all case data, such as cases, fields, templates and layouts.

 <note> <p>After deleting your domain you must disassociate the deleted domain from your Amazon Connect instance with another API call before being able to use Cases again with this Amazon Connect instance.

``

```` * deleteField(params = {}, callback) ⇒ AWS.Request
Deletes a field from a cases template.

 <p>Updates the values of fields on a case.

* updateField(params = {}, callback) ⇒ AWS.Request
Updates the properties of an existing field.

````` ```` ### Methods inherited from AWS.Service

makeRequest, makeUnauthenticatedRequest, waitFor, setupRequestListeners, defineService

Constructor Details

new AWS.ConnectCases(options = {}) ⇒ Object

Constructs a service object. This object has one method for each API operation.

Examples:

Constructing a ConnectCases object

var connectcases = new AWS.ConnectCases({apiVersion: '2022-10-03'});

Options Hash (options):

Property Details

endpoint ⇒ AWS.Endpoint (readwrite)

Returns an Endpoint object representing the endpoint URL for service requests.

Returns:

Method Details

batchGetField(params = {}, callback) ⇒ AWS.Request

Returns the description for the list of fields in the request parameters.

Examples:

Calling the batchGetField operation

var params = {
  domainId: 'STRING_VALUE', /* required */
  fields: [ /* required */
    {
      id: 'STRING_VALUE' /* required */
    },
    /* more items */
  ]
};
connectcases.batchGetField(params, function(err, data) {
  if (err) console.log(err, err.stack); // an error occurred
  else     console.log(data);           // successful response
});

Parameters:

Callback (callback):

Returns:

batchPutFieldOptions(params = {}, callback) ⇒ AWS.Request

Creates and updates a set of field options for a single select field in a Cases domain.

Examples:

Calling the batchPutFieldOptions operation

var params = {
  domainId: 'STRING_VALUE', /* required */
  fieldId: 'STRING_VALUE', /* required */
  options: [ /* required */
    {
      active: true || false, /* required */
      name: 'STRING_VALUE', /* required */
      value: 'STRING_VALUE' /* required */
    },
    /* more items */
  ]
};
connectcases.batchPutFieldOptions(params, function(err, data) {
  if (err) console.log(err, err.stack); // an error occurred
  else     console.log(data);           // successful response
});

Parameters:

Callback (callback):

Returns:

createCase(params = {}, callback) ⇒ AWS.Request

Note: If you provide a value for PerformedBy.UserArn you must also have connect:DescribeUser permission on the User ARN resource that you provide 

 <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> <p>The following fields are required when creating a case:</p> <ul> <li> <p> <code>customer_id</code> - You must provide the full customer profile ARN in this format: <code>arn:aws:profile:your_AWS_Region:your_AWS_account ID:domains/your_profiles_domain_name/profiles/profile_ID</code> </p> </li> <li> <p> <code>title</code> </p> </li> </ul>

Examples:

Calling the createCase operation

var params = {
  domainId: 'STRING_VALUE', /* required */
  fields: [ /* required */
    {
      id: 'STRING_VALUE', /* required */
      value: { /* required */
        booleanValue: true || false,
        doubleValue: 'NUMBER_VALUE',
        emptyValue: {
        },
        stringValue: 'STRING_VALUE',
        userArnValue: 'STRING_VALUE'
      }
    },
    /* more items */
  ],
  templateId: 'STRING_VALUE', /* required */
  clientToken: 'STRING_VALUE',
  performedBy: {
    userArn: 'STRING_VALUE'
  }
};
connectcases.createCase(params, function(err, data) {
  if (err) console.log(err, err.stack); // an error occurred
  else     console.log(data);           // successful response
});

Parameters:

Callback (callback):

Returns:

createDomain(params = {}, callback) ⇒ AWS.Request

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.

This will not associate your connect instance to Cases domain. Instead, use the Amazon Connect CreateIntegrationAssociation API. You need specific IAM permissions to successfully associate the Cases domain. For more information, see Onboard to Cases.

 </important>

Examples:

Calling the createDomain operation

var params = {
  name: 'STRING_VALUE' /* required */
};
connectcases.createDomain(params, function(err, data) {
  if (err) console.log(err, err.stack); // an error occurred
  else     console.log(data);           // successful response
});

Parameters:

Callback (callback):

Returns:

createField(params = {}, callback) ⇒ AWS.Request

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.

Examples:

Calling the createField operation

var params = {
  domainId: 'STRING_VALUE', /* required */
  name: 'STRING_VALUE', /* required */
  type: Text | Number | Boolean | DateTime | SingleSelect | Url | User, /* required */
  description: 'STRING_VALUE'
};
connectcases.createField(params, function(err, data) {
  if (err) console.log(err, err.stack); // an error occurred
  else     console.log(data);           // successful response
});

Parameters:

Callback (callback):

Returns:

createLayout(params = {}, callback) ⇒ AWS.Request

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:

Note: Title and Status fields cannot be part of layouts since they are not configurable.

Examples:

Calling the createLayout operation

var params = {
  content: { /* required */
    basic: {
      moreInfo: {
        sections: [
          {
            fieldGroup: {
              fields: [ /* required */
                {
                  id: 'STRING_VALUE' /* required */
                },
                /* more items */
              ],
              name: 'STRING_VALUE'
            }
          },
          /* more items */
        ]
      },
      topPanel: {
        sections: [
          {
            fieldGroup: {
              fields: [ /* required */
                {
                  id: 'STRING_VALUE' /* required */
                },
                /* more items */
              ],
              name: 'STRING_VALUE'
            }
          },
          /* more items */
        ]
      }
    }
  },
  domainId: 'STRING_VALUE', /* required */
  name: 'STRING_VALUE' /* required */
};
connectcases.createLayout(params, function(err, data) {
  if (err) console.log(err, err.stack); // an error occurred
  else     console.log(data);           // successful response
});

Parameters:

Callback (callback):

Returns:

createRelatedItem(params = {}, callback) ⇒ AWS.Request

Creates a related item (comments, tasks, and contacts) and associates it with a case.

 </note>

Examples:

Calling the createRelatedItem operation

var params = {
  caseId: 'STRING_VALUE', /* required */
  content: { /* required */
    comment: {
      body: 'STRING_VALUE', /* required */
      contentType: Text/Plain /* required */
    },
    contact: {
      contactArn: 'STRING_VALUE' /* required */
    },
    file: {
      fileArn: 'STRING_VALUE' /* required */
    }
  },
  domainId: 'STRING_VALUE', /* required */
  type: Contact | Comment | File, /* required */
  performedBy: {
    userArn: 'STRING_VALUE'
  }
};
connectcases.createRelatedItem(params, function(err, data) {
  if (err) console.log(err, err.stack); // an error occurred
  else     console.log(data);           // successful response
});

Parameters:

Callback (callback):

Returns:

createTemplate(params = {}, callback) ⇒ AWS.Request

Creates a template in the Cases domain. This template is used to define the case object model (that is, to 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. A template can be either Active or Inactive, as indicated by its status. Inactive templates cannot be used to create cases.

Examples:

Calling the createTemplate operation

var params = {
  domainId: 'STRING_VALUE', /* required */
  name: 'STRING_VALUE', /* required */
  description: 'STRING_VALUE',
  layoutConfiguration: {
    defaultLayout: 'STRING_VALUE'
  },
  requiredFields: [
    {
      fieldId: 'STRING_VALUE' /* required */
    },
    /* more items */
  ],
  status: Active | Inactive
};
connectcases.createTemplate(params, function(err, data) {
  if (err) console.log(err, err.stack); // an error occurred
  else     console.log(data);           // successful response
});

Parameters:

Callback (callback):

Returns:

deleteDomain(params = {}, callback) ⇒ AWS.Request

Deletes a Cases domain.

 <note> <p>After deleting your domain you must disassociate the deleted domain from your Amazon Connect instance with another API call before being able to use Cases again with this Amazon Connect instance. See <a href="https://docs.aws.amazon.com/connect/latest/APIReference/API&#95;DeleteIntegrationAssociation.html&quot;&gt;DeleteIntegrationAssociation&lt;/a&gt;.&lt;/p&gt; </note>

Examples:

Calling the deleteDomain operation

var params = {
  domainId: 'STRING_VALUE' /* required */
};
connectcases.deleteDomain(params, function(err, data) {
  if (err) console.log(err, err.stack); // an error occurred
  else     console.log(data);           // successful response
});

Parameters:

Callback (callback):

Returns:

deleteField(params = {}, callback) ⇒ AWS.Request

Deletes a field from a cases template. You can delete up to 100 fields per domain.

After a field is deleted:

Examples:

Calling the deleteField operation

var params = {
  domainId: 'STRING_VALUE', /* required */
  fieldId: 'STRING_VALUE' /* required */
};
connectcases.deleteField(params, function(err, data) {
  if (err) console.log(err, err.stack); // an error occurred
  else     console.log(data);           // successful response
});

Parameters:

Callback (callback):

Returns:

deleteLayout(params = {}, callback) ⇒ AWS.Request

Deletes a layout from a cases template. You can delete up to 100 layouts per domain.

 <p>After a layout is deleted:</p> <ul> <li> <p>You can still retrieve the layout by calling <code>GetLayout</code>.</p> </li> <li> <p>You cannot update a deleted layout by calling <code>UpdateLayout</code>; it throws a <code>ValidationException</code>.</p> </li> <li> <p>Deleted layouts are not included in the <code>ListLayouts</code> response.</p> </li> </ul>

Examples:

Calling the deleteLayout operation

var params = {
  domainId: 'STRING_VALUE', /* required */
  layoutId: 'STRING_VALUE' /* required */
};
connectcases.deleteLayout(params, function(err, data) {
  if (err) console.log(err, err.stack); // an error occurred
  else     console.log(data);           // successful response
});

Parameters:

Callback (callback):

Returns:

deleteTemplate(params = {}, callback) ⇒ AWS.Request

Deletes a cases template. You can delete up to 100 templates per domain.

 <p>After a cases template is deleted:</p> <ul> <li> <p>You can still retrieve the template by calling <code>GetTemplate</code>.</p> </li> <li> <p>You cannot update the template. </p> </li> <li> <p>You cannot create a case by using the deleted template.</p> </li> <li> <p>Deleted templates are not included in the <code>ListTemplates</code> response.</p> </li> </ul>

Examples:

Calling the deleteTemplate operation

var params = {
  domainId: 'STRING_VALUE', /* required */
  templateId: 'STRING_VALUE' /* required */
};
connectcases.deleteTemplate(params, function(err, data) {
  if (err) console.log(err, err.stack); // an error occurred
  else     console.log(data);           // successful response
});

Parameters:

Callback (callback):

Returns:

getCase(params = {}, callback) ⇒ AWS.Request

Returns information about a specific case if it exists.

Examples:

Calling the getCase operation

var params = {
  caseId: 'STRING_VALUE', /* required */
  domainId: 'STRING_VALUE', /* required */
  fields: [ /* required */
    {
      id: 'STRING_VALUE' /* required */
    },
    /* more items */
  ],
  nextToken: 'STRING_VALUE'
};
connectcases.getCase(params, function(err, data) {
  if (err) console.log(err, err.stack); // an error occurred
  else     console.log(data);           // successful response
});

Parameters:

Callback (callback):

Returns:

getCaseAuditEvents(params = {}, callback) ⇒ AWS.Request

Returns the audit history about a specific case if it exists.

Examples:

Calling the getCaseAuditEvents operation

var params = {
  caseId: 'STRING_VALUE', /* required */
  domainId: 'STRING_VALUE', /* required */
  maxResults: 'NUMBER_VALUE',
  nextToken: 'STRING_VALUE'
};
connectcases.getCaseAuditEvents(params, function(err, data) {
  if (err) console.log(err, err.stack); // an error occurred
  else     console.log(data);           // successful response
});

Parameters:

Callback (callback):

Returns:

getCaseEventConfiguration(params = {}, callback) ⇒ AWS.Request

Returns the case event publishing configuration.

Examples:

Calling the getCaseEventConfiguration operation

var params = {
  domainId: 'STRING_VALUE' /* required */
};
connectcases.getCaseEventConfiguration(params, function(err, data) {
  if (err) console.log(err, err.stack); // an error occurred
  else     console.log(data);           // successful response
});

Parameters:

Callback (callback):

Returns:

getDomain(params = {}, callback) ⇒ AWS.Request

Returns information about a specific domain if it exists.

Examples:

Calling the getDomain operation

var params = {
  domainId: 'STRING_VALUE' /* required */
};
connectcases.getDomain(params, function(err, data) {
  if (err) console.log(err, err.stack); // an error occurred
  else     console.log(data);           // successful response
});

Parameters:

Callback (callback):

Returns:

getLayout(params = {}, callback) ⇒ AWS.Request

Returns the details for the requested layout.

Examples:

Calling the getLayout operation

var params = {
  domainId: 'STRING_VALUE', /* required */
  layoutId: 'STRING_VALUE' /* required */
};
connectcases.getLayout(params, function(err, data) {
  if (err) console.log(err, err.stack); // an error occurred
  else     console.log(data);           // successful response
});

Parameters:

Callback (callback):

Returns:

getTemplate(params = {}, callback) ⇒ AWS.Request

Returns the details for the requested template.

Examples:

Calling the getTemplate operation

var params = {
  domainId: 'STRING_VALUE', /* required */
  templateId: 'STRING_VALUE' /* required */
};
connectcases.getTemplate(params, function(err, data) {
  if (err) console.log(err, err.stack); // an error occurred
  else     console.log(data);           // successful response
});

Parameters:

Callback (callback):

Returns:

listCasesForContact(params = {}, callback) ⇒ AWS.Request

Lists cases for a given contact.

Examples:

Calling the listCasesForContact operation

var params = {
  contactArn: 'STRING_VALUE', /* required */
  domainId: 'STRING_VALUE', /* required */
  maxResults: 'NUMBER_VALUE',
  nextToken: 'STRING_VALUE'
};
connectcases.listCasesForContact(params, function(err, data) {
  if (err) console.log(err, err.stack); // an error occurred
  else     console.log(data);           // successful response
});

Parameters:

Callback (callback):

Returns:

listDomains(params = {}, callback) ⇒ AWS.Request

Lists all cases domains in the Amazon Web Services account. Each list item is a condensed summary object of the domain.

Examples:

Calling the listDomains operation

var params = {
  maxResults: 'NUMBER_VALUE',
  nextToken: 'STRING_VALUE'
};
connectcases.listDomains(params, function(err, data) {
  if (err) console.log(err, err.stack); // an error occurred
  else     console.log(data);           // successful response
});

Parameters:

Callback (callback):

Returns:

listFieldOptions(params = {}, callback) ⇒ AWS.Request

Lists all of the field options for a field identifier in the domain.

Examples:

Calling the listFieldOptions operation

var params = {
  domainId: 'STRING_VALUE', /* required */
  fieldId: 'STRING_VALUE', /* required */
  maxResults: 'NUMBER_VALUE',
  nextToken: 'STRING_VALUE',
  values: [
    'STRING_VALUE',
    /* more items */
  ]
};
connectcases.listFieldOptions(params, function(err, data) {
  if (err) console.log(err, err.stack); // an error occurred
  else     console.log(data);           // successful response
});

Parameters:

Callback (callback):

Returns:

listFields(params = {}, callback) ⇒ AWS.Request

Lists all fields in a Cases domain.

Examples:

Calling the listFields operation

var params = {
  domainId: 'STRING_VALUE', /* required */
  maxResults: 'NUMBER_VALUE',
  nextToken: 'STRING_VALUE'
};
connectcases.listFields(params, function(err, data) {
  if (err) console.log(err, err.stack); // an error occurred
  else     console.log(data);           // successful response
});

Parameters:

Callback (callback):

Returns:

listLayouts(params = {}, callback) ⇒ AWS.Request

Lists all layouts in the given cases domain. Each list item is a condensed summary object of the layout.

Examples:

Calling the listLayouts operation

var params = {
  domainId: 'STRING_VALUE', /* required */
  maxResults: 'NUMBER_VALUE',
  nextToken: 'STRING_VALUE'
};
connectcases.listLayouts(params, function(err, data) {
  if (err) console.log(err, err.stack); // an error occurred
  else     console.log(data);           // successful response
});

Parameters:

Callback (callback):

Returns:

listTagsForResource(params = {}, callback) ⇒ AWS.Request

Lists tags for a resource.

Examples:

Calling the listTagsForResource operation

var params = {
  arn: 'STRING_VALUE' /* required */
};
connectcases.listTagsForResource(params, function(err, data) {
  if (err) console.log(err, err.stack); // an error occurred
  else     console.log(data);           // successful response
});

Parameters:

Callback (callback):

Returns:

listTemplates(params = {}, callback) ⇒ AWS.Request

Lists all of the templates in a Cases domain. Each list item is a condensed summary object of the template.

Examples:

Calling the listTemplates operation

var params = {
  domainId: 'STRING_VALUE', /* required */
  maxResults: 'NUMBER_VALUE',
  nextToken: 'STRING_VALUE',
  status: [
    Active | Inactive,
    /* more items */
  ]
};
connectcases.listTemplates(params, function(err, data) {
  if (err) console.log(err, err.stack); // an error occurred
  else     console.log(data);           // successful response
});

Parameters:

Callback (callback):

Returns:

putCaseEventConfiguration(params = {}, callback) ⇒ AWS.Request

Adds case event publishing configuration. For a complete list of fields you can add to the event message, see Create case fields in the Amazon Connect Administrator Guide

Examples:

Calling the putCaseEventConfiguration operation

var params = {
  domainId: 'STRING_VALUE', /* required */
  eventBridge: { /* required */
    enabled: true || false, /* required */
    includedData: {
      caseData: {
        fields: [ /* required */
          {
            id: 'STRING_VALUE' /* required */
          },
          /* more items */
        ]
      },
      relatedItemData: {
        includeContent: true || false /* required */
      }
    }
  }
};
connectcases.putCaseEventConfiguration(params, function(err, data) {
  if (err) console.log(err, err.stack); // an error occurred
  else     console.log(data);           // successful response
});

Parameters:

Callback (callback):

Returns:

searchCases(params = {}, callback) ⇒ AWS.Request

Searches for cases within their associated Cases domain. Search results are returned as a paginated list of abridged case documents.

Note: For customer_id you must provide the full customer profile ARN in this format: arn:aws:profile:your AWS Region:your AWS account ID:domains/profiles domain name/profiles/profile ID.

Examples:

Calling the searchCases operation

var params = {
  domainId: 'STRING_VALUE', /* required */
  fields: [
    {
      id: 'STRING_VALUE' /* required */
    },
    /* more items */
  ],
  filter: { /* CaseFilter */
    andAll: [
      /* recursive CaseFilter */,
      /* more items */
    ],
    field: {
      contains: {
        id: 'STRING_VALUE', /* required */
        value: { /* required */
          booleanValue: true || false,
          doubleValue: 'NUMBER_VALUE',
          emptyValue: {
          },
          stringValue: 'STRING_VALUE',
          userArnValue: 'STRING_VALUE'
        }
      },
      equalTo: {
        id: 'STRING_VALUE', /* required */
        value: { /* required */
          booleanValue: true || false,
          doubleValue: 'NUMBER_VALUE',
          emptyValue: {
          },
          stringValue: 'STRING_VALUE',
          userArnValue: 'STRING_VALUE'
        }
      },
      greaterThan: {
        id: 'STRING_VALUE', /* required */
        value: { /* required */
          booleanValue: true || false,
          doubleValue: 'NUMBER_VALUE',
          emptyValue: {
          },
          stringValue: 'STRING_VALUE',
          userArnValue: 'STRING_VALUE'
        }
      },
      greaterThanOrEqualTo: {
        id: 'STRING_VALUE', /* required */
        value: { /* required */
          booleanValue: true || false,
          doubleValue: 'NUMBER_VALUE',
          emptyValue: {
          },
          stringValue: 'STRING_VALUE',
          userArnValue: 'STRING_VALUE'
        }
      },
      lessThan: {
        id: 'STRING_VALUE', /* required */
        value: { /* required */
          booleanValue: true || false,
          doubleValue: 'NUMBER_VALUE',
          emptyValue: {
          },
          stringValue: 'STRING_VALUE',
          userArnValue: 'STRING_VALUE'
        }
      },
      lessThanOrEqualTo: {
        id: 'STRING_VALUE', /* required */
        value: { /* required */
          booleanValue: true || false,
          doubleValue: 'NUMBER_VALUE',
          emptyValue: {
          },
          stringValue: 'STRING_VALUE',
          userArnValue: 'STRING_VALUE'
        }
      }
    },
    not: /* recursive CaseFilter */,
    orAll: [
      /* recursive CaseFilter */,
      /* more items */
    ]
  },
  maxResults: 'NUMBER_VALUE',
  nextToken: 'STRING_VALUE',
  searchTerm: 'STRING_VALUE',
  sorts: [
    {
      fieldId: 'STRING_VALUE', /* required */
      sortOrder: Asc | Desc /* required */
    },
    /* more items */
  ]
};
connectcases.searchCases(params, function(err, data) {
  if (err) console.log(err, err.stack); // an error occurred
  else     console.log(data);           // successful response
});

Parameters:

Callback (callback):

Returns:

searchRelatedItems(params = {}, callback) ⇒ AWS.Request

Searches for related items that are associated with a case.

Note: If no filters are provided, this returns all related items associated with a case.

Examples:

Calling the searchRelatedItems operation

var params = {
  caseId: 'STRING_VALUE', /* required */
  domainId: 'STRING_VALUE', /* required */
  filters: [
    {
      comment: {
      },
      contact: {
        channel: [
          'STRING_VALUE',
          /* more items */
        ],
        contactArn: 'STRING_VALUE'
      },
      file: {
        fileArn: 'STRING_VALUE'
      }
    },
    /* more items */
  ],
  maxResults: 'NUMBER_VALUE',
  nextToken: 'STRING_VALUE'
};
connectcases.searchRelatedItems(params, function(err, data) {
  if (err) console.log(err, err.stack); // an error occurred
  else     console.log(data);           // successful response
});

Parameters:

Callback (callback):

Returns:

tagResource(params = {}, callback) ⇒ AWS.Request

Adds tags to a resource.

Examples:

Calling the tagResource operation

var params = {
  arn: 'STRING_VALUE', /* required */
  tags: { /* required */
    '<String>': 'STRING_VALUE',
    /* '<String>': ... */
  }
};
connectcases.tagResource(params, function(err, data) {
  if (err) console.log(err, err.stack); // an error occurred
  else     console.log(data);           // successful response
});

Parameters:

Callback (callback):

Returns:

untagResource(params = {}, callback) ⇒ AWS.Request

Untags a resource.

Examples:

Calling the untagResource operation

var params = {
  arn: 'STRING_VALUE', /* required */
  tagKeys: [ /* required */
    'STRING_VALUE',
    /* more items */
  ]
};
connectcases.untagResource(params, function(err, data) {
  if (err) console.log(err, err.stack); // an error occurred
  else     console.log(data);           // successful response
});

Parameters:

Callback (callback):

Returns:

updateCase(params = {}, callback) ⇒ AWS.Request

Note: If you provide a value for PerformedBy.UserArn you must also have connect:DescribeUser permission on the User ARN resource that you provide 

 <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>

Examples:

Calling the updateCase operation

var params = {
  caseId: 'STRING_VALUE', /* required */
  domainId: 'STRING_VALUE', /* required */
  fields: [ /* required */
    {
      id: 'STRING_VALUE', /* required */
      value: { /* required */
        booleanValue: true || false,
        doubleValue: 'NUMBER_VALUE',
        emptyValue: {
        },
        stringValue: 'STRING_VALUE',
        userArnValue: 'STRING_VALUE'
      }
    },
    /* more items */
  ],
  performedBy: {
    userArn: 'STRING_VALUE'
  }
};
connectcases.updateCase(params, function(err, data) {
  if (err) console.log(err, err.stack); // an error occurred
  else     console.log(data);           // successful response
});

Parameters:

Callback (callback):

Returns:

updateField(params = {}, callback) ⇒ AWS.Request

Updates the properties of an existing field.

Examples:

Calling the updateField operation

var params = {
  domainId: 'STRING_VALUE', /* required */
  fieldId: 'STRING_VALUE', /* required */
  description: 'STRING_VALUE',
  name: 'STRING_VALUE'
};
connectcases.updateField(params, function(err, data) {
  if (err) console.log(err, err.stack); // an error occurred
  else     console.log(data);           // successful response
});

Parameters:

Callback (callback):

Returns:

updateLayout(params = {}, callback) ⇒ AWS.Request

Updates the attributes of an existing layout.

If the action is successful, the service sends back an HTTP 200 response with an empty HTTP body.

A ValidationException is returned when you add non-existent fieldIds to a layout.

Note: Title and Status fields cannot be part of layouts because they are not configurable.

Examples:

Calling the updateLayout operation

var params = {
  domainId: 'STRING_VALUE', /* required */
  layoutId: 'STRING_VALUE', /* required */
  content: {
    basic: {
      moreInfo: {
        sections: [
          {
            fieldGroup: {
              fields: [ /* required */
                {
                  id: 'STRING_VALUE' /* required */
                },
                /* more items */
              ],
              name: 'STRING_VALUE'
            }
          },
          /* more items */
        ]
      },
      topPanel: {
        sections: [
          {
            fieldGroup: {
              fields: [ /* required */
                {
                  id: 'STRING_VALUE' /* required */
                },
                /* more items */
              ],
              name: 'STRING_VALUE'
            }
          },
          /* more items */
        ]
      }
    }
  },
  name: 'STRING_VALUE'
};
connectcases.updateLayout(params, function(err, data) {
  if (err) console.log(err, err.stack); // an error occurred
  else     console.log(data);           // successful response
});

Parameters:

Callback (callback):

Returns:

updateTemplate(params = {}, callback) ⇒ AWS.Request

Updates the attributes of an existing template. The template attributes that can be modified include name, description, layoutConfiguration, requiredFields, and status. 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.

Examples:

Calling the updateTemplate operation

var params = {
  domainId: 'STRING_VALUE', /* required */
  templateId: 'STRING_VALUE', /* required */
  description: 'STRING_VALUE',
  layoutConfiguration: {
    defaultLayout: 'STRING_VALUE'
  },
  name: 'STRING_VALUE',
  requiredFields: [
    {
      fieldId: 'STRING_VALUE' /* required */
    },
    /* more items */
  ],
  status: Active | Inactive
};
connectcases.updateTemplate(params, function(err, data) {
  if (err) console.log(err, err.stack); // an error occurred
  else     console.log(data);           // successful response
});

Parameters:

Callback (callback):

Returns:

```` `````