docs: function(apiClient) {
      this.apiClient = apiClient || ApiClient.instance;
  
  
  
      /**
       * Assign the interaction to a contact
       * @param {String} id id of the Interaction
       * @param {module:model/AssignInteractionToContactData} assignInteractionToContactData 
       * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/ApiSuccessResponse} and HTTP response
       */
      this.assignInteractionToContactWithHttpInfo = function(id, assignInteractionToContactData) {
        var postBody = assignInteractionToContactData;
  
        // verify the required parameter 'id' is set
        if (id === undefined || id === null) {
          throw new Error("Missing the required parameter 'id' when calling assignInteractionToContact");
        }
  
        // verify the required parameter 'assignInteractionToContactData' is set
        if (assignInteractionToContactData === undefined || assignInteractionToContactData === null) {
          throw new Error("Missing the required parameter 'assignInteractionToContactData' when calling assignInteractionToContact");
        }
  
  
        var pathParams = {
          'id': id
        };
        var queryParams = {
        };
        var collectionQueryParams = {
        };
        var headerParams = {
        };
        var formParams = {
        };
  
        var authNames = [];
        var contentTypes = ['application/json'];
        var accepts = ['application/json'];
        var returnType = ApiSuccessResponse;
  
        return this.apiClient.callApi(
          '/ucs/interactions/{id}/assign-contact', 'POST',
          pathParams, queryParams, collectionQueryParams, headerParams, formParams, postBody,
          authNames, contentTypes, accepts, returnType
        );
      }
  
      /**
       * Assign the interaction to a contact
       * @param {String} id id of the Interaction
       * @param {module:model/AssignInteractionToContactData} assignInteractionToContactData 
       * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/ApiSuccessResponse}
       */
      this.assignInteractionToContact = function(id, assignInteractionToContactData) {
        return this.assignInteractionToContactWithHttpInfo(id, assignInteractionToContactData)
          .then(function(response_and_data) {
            return response_and_data.data;
          });
      }
  
  
      /**
       * Create a new contact
       * @param {module:model/CreateContactData} createContactData 
       * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/ApiSuccessResponse} and HTTP response
       */
      this.createContactWithHttpInfo = function(createContactData) {
        var postBody = createContactData;
  
        // verify the required parameter 'createContactData' is set
        if (createContactData === undefined || createContactData === null) {
          throw new Error("Missing the required parameter 'createContactData' when calling createContact");
        }
  
  
        var pathParams = {
        };
        var queryParams = {
        };
        var collectionQueryParams = {
        };
        var headerParams = {
        };
        var formParams = {
        };
  
        var authNames = [];
        var contentTypes = ['application/json'];
        var accepts = ['application/json'];
        var returnType = ApiSuccessResponse;
  
        return this.apiClient.callApi(
          '/ucs/contacts/create', 'POST',
          pathParams, queryParams, collectionQueryParams, headerParams, formParams, postBody,
          authNames, contentTypes, accepts, returnType
        );
      }
  
      /**
       * Create a new contact
       * @param {module:model/CreateContactData} createContactData 
       * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/ApiSuccessResponse}
       */
      this.createContact = function(createContactData) {
        return this.createContactWithHttpInfo(createContactData)
          .then(function(response_and_data) {
            return response_and_data.data;
          });
      }
  
  
      /**
       * Delete an existing contact
       * @param {String} id id of the Contact
       * @param {Object} opts Optional parameters
       * @param {module:model/DeletelData} opts.deletelData Request parameters.
       * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/ApiSuccessResponse} and HTTP response
       */
      this.deleteContactWithHttpInfo = function(id, opts) {
        opts = opts || {};
        var postBody = opts['deletelData'];
  
        // verify the required parameter 'id' is set
        if (id === undefined || id === null) {
          throw new Error("Missing the required parameter 'id' when calling deleteContact");
        }
  
  
        var pathParams = {
          'id': id
        };
        var queryParams = {
        };
        var collectionQueryParams = {
        };
        var headerParams = {
        };
        var formParams = {
        };
  
        var authNames = [];
        var contentTypes = ['application/json'];
        var accepts = ['application/json'];
        var returnType = ApiSuccessResponse;
  
        return this.apiClient.callApi(
          '/ucs/contacts/{id}/delete', 'POST',
          pathParams, queryParams, collectionQueryParams, headerParams, formParams, postBody,
          authNames, contentTypes, accepts, returnType
        );
      }
  
      /**
       * Delete an existing contact
       * @param {String} id id of the Contact
       * @param {Object} opts Optional parameters
       * @param {module:model/DeletelData} opts.deletelData Request parameters.
       * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/ApiSuccessResponse}
       */
      this.deleteContact = function(id, opts) {
        return this.deleteContactWithHttpInfo(id, opts)
          .then(function(response_and_data) {
            return response_and_data.data;
          });
      }
  
  
      /**
       * Search for interactions based on elastic search query, using ucs 9
       * @param {module:model/EsSearchInteractionData} esSearchInteractionData 
       * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/ApiSuccessResponse} and HTTP response
       */
      this.elastiscSearchInteractionsWithHttpInfo = function(esSearchInteractionData) {
        var postBody = esSearchInteractionData;
  
        // verify the required parameter 'esSearchInteractionData' is set
        if (esSearchInteractionData === undefined || esSearchInteractionData === null) {
          throw new Error("Missing the required parameter 'esSearchInteractionData' when calling elastiscSearchInteractions");
        }
  
  
        var pathParams = {
        };
        var queryParams = {
        };
        var collectionQueryParams = {
        };
        var headerParams = {
        };
        var formParams = {
        };
  
        var authNames = [];
        var contentTypes = ['application/json'];
        var accepts = ['application/json'];
        var returnType = ApiSuccessResponse;
  
        return this.apiClient.callApi(
          '/ucs/interactions/elastic-search', 'POST',
          pathParams, queryParams, collectionQueryParams, headerParams, formParams, postBody,
          authNames, contentTypes, accepts, returnType
        );
      }
  
      /**
       * Search for interactions based on elastic search query, using ucs 9
       * @param {module:model/EsSearchInteractionData} esSearchInteractionData 
       * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/ApiSuccessResponse}
       */
      this.elastiscSearchInteractions = function(esSearchInteractionData) {
        return this.elastiscSearchInteractionsWithHttpInfo(esSearchInteractionData)
          .then(function(response_and_data) {
            return response_and_data.data;
          });
      }
  
  
      /**
       * Find or create phone call in UCS
       * @param {String} id id of the Voice Interaction
       * @param {Object} opts Optional parameters
       * @param {module:model/FindOrCreateData} opts.findOrCreateData Request parameters.
       * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/ApiSuccessResponse} and HTTP response
       */
      this.findOrCreatePhoneCallWithHttpInfo = function(id, opts) {
        opts = opts || {};
        var postBody = opts['findOrCreateData'];
  
        // verify the required parameter 'id' is set
        if (id === undefined || id === null) {
          throw new Error("Missing the required parameter 'id' when calling findOrCreatePhoneCall");
        }
  
  
        var pathParams = {
          'id': id
        };
        var queryParams = {
        };
        var collectionQueryParams = {
        };
        var headerParams = {
        };
        var formParams = {
        };
  
        var authNames = [];
        var contentTypes = ['application/json'];
        var accepts = ['application/json'];
        var returnType = ApiSuccessResponse;
  
        return this.apiClient.callApi(
          '/ucs/voice/{id}/find-or-create', 'POST',
          pathParams, queryParams, collectionQueryParams, headerParams, formParams, postBody,
          authNames, contentTypes, accepts, returnType
        );
      }
  
      /**
       * Find or create phone call in UCS
       * @param {String} id id of the Voice Interaction
       * @param {Object} opts Optional parameters
       * @param {module:model/FindOrCreateData} opts.findOrCreateData Request parameters.
       * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/ApiSuccessResponse}
       */
      this.findOrCreatePhoneCall = function(id, opts) {
        return this.findOrCreatePhoneCallWithHttpInfo(id, opts)
          .then(function(response_and_data) {
            return response_and_data.data;
          });
      }
  
  
      /**
       * Get the history of interactions for the agent
       * @param {Object} opts Optional parameters
       * @param {module:model/AgentHistoryData} opts.agentHistoryData 
       * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/ApiSuccessResponse} and HTTP response
       */
      this.getAgentHistoryWithHttpInfo = function(opts) {
        opts = opts || {};
        var postBody = opts['agentHistoryData'];
  
  
        var pathParams = {
        };
        var queryParams = {
        };
        var collectionQueryParams = {
        };
        var headerParams = {
        };
        var formParams = {
        };
  
        var authNames = [];
        var contentTypes = ['application/json'];
        var accepts = ['application/json'];
        var returnType = ApiSuccessResponse;
  
        return this.apiClient.callApi(
          '/ucs/get-agent-history', 'POST',
          pathParams, queryParams, collectionQueryParams, headerParams, formParams, postBody,
          authNames, contentTypes, accepts, returnType
        );
      }
  
      /**
       * Get the history of interactions for the agent
       * @param {Object} opts Optional parameters
       * @param {module:model/AgentHistoryData} opts.agentHistoryData 
       * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/ApiSuccessResponse}
       */
      this.getAgentHistory = function(opts) {
        return this.getAgentHistoryWithHttpInfo(opts)
          .then(function(response_and_data) {
            return response_and_data.data;
          });
      }
  
  
      /**
       * Get the details of a contact
       * @param {String} id id of the Contact
       * @param {module:model/ContactDetailsData} contactDetailsData 
       * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/ApiSuccessResponse} and HTTP response
       */
      this.getContactDetailsWithHttpInfo = function(id, contactDetailsData) {
        var postBody = contactDetailsData;
  
        // verify the required parameter 'id' is set
        if (id === undefined || id === null) {
          throw new Error("Missing the required parameter 'id' when calling getContactDetails");
        }
  
        // verify the required parameter 'contactDetailsData' is set
        if (contactDetailsData === undefined || contactDetailsData === null) {
          throw new Error("Missing the required parameter 'contactDetailsData' when calling getContactDetails");
        }
  
  
        var pathParams = {
          'id': id
        };
        var queryParams = {
        };
        var collectionQueryParams = {
        };
        var headerParams = {
        };
        var formParams = {
        };
  
        var authNames = [];
        var contentTypes = ['application/json'];
        var accepts = ['application/json'];
        var returnType = ApiSuccessResponse;
  
        return this.apiClient.callApi(
          '/ucs/contacts/{id}/get-details', 'POST',
          pathParams, queryParams, collectionQueryParams, headerParams, formParams, postBody,
          authNames, contentTypes, accepts, returnType
        );
      }
  
      /**
       * Get the details of a contact
       * @param {String} id id of the Contact
       * @param {module:model/ContactDetailsData} contactDetailsData 
       * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/ApiSuccessResponse}
       */
      this.getContactDetails = function(id, contactDetailsData) {
        return this.getContactDetailsWithHttpInfo(id, contactDetailsData)
          .then(function(response_and_data) {
            return response_and_data.data;
          });
      }
  
  
      /**
       * Get the history of interactions for a contact
       * @param {String} id id of the Contact
       * @param {module:model/ContactHistoryData} contactHistoryData 
       * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/ApiSuccessResponse} and HTTP response
       */
      this.getContactHistoryWithHttpInfo = function(id, contactHistoryData) {
        var postBody = contactHistoryData;
  
        // verify the required parameter 'id' is set
        if (id === undefined || id === null) {
          throw new Error("Missing the required parameter 'id' when calling getContactHistory");
        }
  
        // verify the required parameter 'contactHistoryData' is set
        if (contactHistoryData === undefined || contactHistoryData === null) {
          throw new Error("Missing the required parameter 'contactHistoryData' when calling getContactHistory");
        }
  
  
        var pathParams = {
          'id': id
        };
        var queryParams = {
        };
        var collectionQueryParams = {
        };
        var headerParams = {
        };
        var formParams = {
        };
  
        var authNames = [];
        var contentTypes = ['application/json'];
        var accepts = ['application/json'];
        var returnType = ApiSuccessResponse;
  
        return this.apiClient.callApi(
          '/ucs/contacts/{id}/get-history', 'POST',
          pathParams, queryParams, collectionQueryParams, headerParams, formParams, postBody,
          authNames, contentTypes, accepts, returnType
        );
      }
  
      /**
       * Get the history of interactions for a contact
       * @param {String} id id of the Contact
       * @param {module:model/ContactHistoryData} contactHistoryData 
       * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/ApiSuccessResponse}
       */
      this.getContactHistory = function(id, contactHistoryData) {
        return this.getContactHistoryWithHttpInfo(id, contactHistoryData)
          .then(function(response_and_data) {
            return response_and_data.data;
          });
      }
  
  
      /**
       * Get the content of the interaction
       * @param {String} id id of the Interaction
       * @param {Object} opts Optional parameters
       * @param {module:model/InteractionDetailsData} opts.interactionDetailsData 
       * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/ApiSuccessResponse} and HTTP response
       */
      this.getInteractionDetailsWithHttpInfo = function(id, opts) {
        opts = opts || {};
        var postBody = opts['interactionDetailsData'];
  
        // verify the required parameter 'id' is set
        if (id === undefined || id === null) {
          throw new Error("Missing the required parameter 'id' when calling getInteractionDetails");
        }
  
  
        var pathParams = {
          'id': id
        };
        var queryParams = {
        };
        var collectionQueryParams = {
        };
        var headerParams = {
        };
        var formParams = {
        };
  
        var authNames = [];
        var contentTypes = ['application/json'];
        var accepts = ['application/json'];
        var returnType = ApiSuccessResponse;
  
        return this.apiClient.callApi(
          '/ucs/interactions/{id}/get-details', 'POST',
          pathParams, queryParams, collectionQueryParams, headerParams, formParams, postBody,
          authNames, contentTypes, accepts, returnType
        );
      }
  
      /**
       * Get the content of the interaction
       * @param {String} id id of the Interaction
       * @param {Object} opts Optional parameters
       * @param {module:model/InteractionDetailsData} opts.interactionDetailsData 
       * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/ApiSuccessResponse}
       */
      this.getInteractionDetails = function(id, opts) {
        return this.getInteractionDetailsWithHttpInfo(id, opts)
          .then(function(response_and_data) {
            return response_and_data.data;
          });
      }
  
  
      /**
       * Get the lucene indexes for ucs
       * This request returns all the lucene indexes for contact.
       * @param {Object} opts Optional parameters
       * @param {module:model/LuceneIndexesData} opts.luceneIndexesData Request parameters.
       * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/ConfigResponse} and HTTP response
       */
      this.getLuceneIndexesWithHttpInfo = function(opts) {
        opts = opts || {};
        var postBody = opts['luceneIndexesData'];
  
  
        var pathParams = {
        };
        var queryParams = {
        };
        var collectionQueryParams = {
        };
        var headerParams = {
        };
        var formParams = {
        };
  
        var authNames = [];
        var contentTypes = ['application/json'];
        var accepts = ['application/json'];
        var returnType = ConfigResponse;
  
        return this.apiClient.callApi(
          '/ucs/get-lucene-indexes', 'POST',
          pathParams, queryParams, collectionQueryParams, headerParams, formParams, postBody,
          authNames, contentTypes, accepts, returnType
        );
      }
  
      /**
       * Get the lucene indexes for ucs
       * This request returns all the lucene indexes for contact.
       * @param {Object} opts Optional parameters
       * @param {module:model/LuceneIndexesData} opts.luceneIndexesData Request parameters.
       * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/ConfigResponse}
       */
      this.getLuceneIndexes = function(opts) {
        return this.getLuceneIndexesWithHttpInfo(opts)
          .then(function(response_and_data) {
            return response_and_data.data;
          });
      }
  
  
      /**
       * Identify the contact for the interaction
       * @param {String} id id of the Interaction
       * @param {module:model/IdentifyContactData} identifyContactData 
       * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/ApiSuccessResponse} and HTTP response
       */
      this.identifyContactWithHttpInfo = function(id, identifyContactData) {
        var postBody = identifyContactData;
  
        // verify the required parameter 'id' is set
        if (id === undefined || id === null) {
          throw new Error("Missing the required parameter 'id' when calling identifyContact");
        }
  
        // verify the required parameter 'identifyContactData' is set
        if (identifyContactData === undefined || identifyContactData === null) {
          throw new Error("Missing the required parameter 'identifyContactData' when calling identifyContact");
        }
  
  
        var pathParams = {
          'id': id
        };
        var queryParams = {
        };
        var collectionQueryParams = {
        };
        var headerParams = {
        };
        var formParams = {
        };
  
        var authNames = [];
        var contentTypes = ['application/json'];
        var accepts = ['application/json'];
        var returnType = ApiSuccessResponse;
  
        return this.apiClient.callApi(
          '/ucs/interactions/{id}/identify-contact', 'POST',
          pathParams, queryParams, collectionQueryParams, headerParams, formParams, postBody,
          authNames, contentTypes, accepts, returnType
        );
      }
  
      /**
       * Identify the contact for the interaction
       * @param {String} id id of the Interaction
       * @param {module:model/IdentifyContactData} identifyContactData 
       * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/ApiSuccessResponse}
       */
      this.identifyContact = function(id, identifyContactData) {
        return this.identifyContactWithHttpInfo(id, identifyContactData)
          .then(function(response_and_data) {
            return response_and_data.data;
          });
      }
  
  
      /**
       * Search for contacts. If ‘sortCriteria’ or ‘startIndex’ is specified, the query is based on SQL, otherwise on Lucene
       * @param {module:model/LuceneSearchData} luceneSearchData 
       * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/ApiSuccessResponse} and HTTP response
       */
      this.searchContactsWithHttpInfo = function(luceneSearchData) {
        var postBody = luceneSearchData;
  
        // verify the required parameter 'luceneSearchData' is set
        if (luceneSearchData === undefined || luceneSearchData === null) {
          throw new Error("Missing the required parameter 'luceneSearchData' when calling searchContacts");
        }
  
  
        var pathParams = {
        };
        var queryParams = {
        };
        var collectionQueryParams = {
        };
        var headerParams = {
        };
        var formParams = {
        };
  
        var authNames = [];
        var contentTypes = ['application/json'];
        var accepts = ['application/json'];
        var returnType = ApiSuccessResponse;
  
        return this.apiClient.callApi(
          '/ucs/contacts/search', 'POST',
          pathParams, queryParams, collectionQueryParams, headerParams, formParams, postBody,
          authNames, contentTypes, accepts, returnType
        );
      }
  
      /**
       * Search for contacts. If ‘sortCriteria’ or ‘startIndex’ is specified, the query is based on SQL, otherwise on Lucene
       * @param {module:model/LuceneSearchData} luceneSearchData 
       * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/ApiSuccessResponse}
       */
      this.searchContacts = function(luceneSearchData) {
        return this.searchContactsWithHttpInfo(luceneSearchData)
          .then(function(response_and_data) {
            return response_and_data.data;
          });
      }
  
  
      /**
       * Search for interactions based on search query, using lucene search
       * @param {module:model/LuceneSearchInteractionData} luceneSearchInteractionData 
       * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/ApiSuccessResponse} and HTTP response
       */
      this.searchInteractionsWithHttpInfo = function(luceneSearchInteractionData) {
        var postBody = luceneSearchInteractionData;
  
        // verify the required parameter 'luceneSearchInteractionData' is set
        if (luceneSearchInteractionData === undefined || luceneSearchInteractionData === null) {
          throw new Error("Missing the required parameter 'luceneSearchInteractionData' when calling searchInteractions");
        }
  
  
        var pathParams = {
        };
        var queryParams = {
        };
        var collectionQueryParams = {
        };
        var headerParams = {
        };
        var formParams = {
        };
  
        var authNames = [];
        var contentTypes = ['application/json'];
        var accepts = ['application/json'];
        var returnType = ApiSuccessResponse;
  
        return this.apiClient.callApi(
          '/ucs/interactions/search', 'POST',
          pathParams, queryParams, collectionQueryParams, headerParams, formParams, postBody,
          authNames, contentTypes, accepts, returnType
        );
      }
  
      /**
       * Search for interactions based on search query, using lucene search
       * @param {module:model/LuceneSearchInteractionData} luceneSearchInteractionData 
       * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/ApiSuccessResponse}
       */
      this.searchInteractions = function(luceneSearchInteractionData) {
        return this.searchInteractionsWithHttpInfo(luceneSearchInteractionData)
          .then(function(response_and_data) {
            return response_and_data.data;
          });
      }
  
  
      /**
       * Set the comment for the call
       * @param {String} id id of the Interaction
       * @param {module:model/CallCommentData} callCommentData 
       * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/ApiSuccessResponse} and HTTP response
       */
      this.setCallCommentWithHttpInfo = function(id, callCommentData) {
        var postBody = callCommentData;
  
        // verify the required parameter 'id' is set
        if (id === undefined || id === null) {
          throw new Error("Missing the required parameter 'id' when calling setCallComment");
        }
  
        // verify the required parameter 'callCommentData' is set
        if (callCommentData === undefined || callCommentData === null) {
          throw new Error("Missing the required parameter 'callCommentData' when calling setCallComment");
        }
  
  
        var pathParams = {
          'id': id
        };
        var queryParams = {
        };
        var collectionQueryParams = {
        };
        var headerParams = {
        };
        var formParams = {
        };
  
        var authNames = [];
        var contentTypes = ['application/json'];
        var accepts = ['application/json'];
        var returnType = ApiSuccessResponse;
  
        return this.apiClient.callApi(
          '/ucs/interactions/{id}/set-comment', 'POST',
          pathParams, queryParams, collectionQueryParams, headerParams, formParams, postBody,
          authNames, contentTypes, accepts, returnType
        );
      }
  
      /**
       * Set the comment for the call
       * @param {String} id id of the Interaction
       * @param {module:model/CallCommentData} callCommentData 
       * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/ApiSuccessResponse}
       */
      this.setCallComment = function(id, callCommentData) {
        return this.setCallCommentWithHttpInfo(id, callCommentData)
          .then(function(response_and_data) {
            return response_and_data.data;
          });
      }
  
  
      /**
       * Set the call as being completed
       * @param {String} id id of the Interaction
       * @param {module:model/CallCompletedData} callCompletedData 
       * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/ApiSuccessResponse} and HTTP response
       */
      this.setCallCompletedWithHttpInfo = function(id, callCompletedData) {
        var postBody = callCompletedData;
  
        // verify the required parameter 'id' is set
        if (id === undefined || id === null) {
          throw new Error("Missing the required parameter 'id' when calling setCallCompleted");
        }
  
        // verify the required parameter 'callCompletedData' is set
        if (callCompletedData === undefined || callCompletedData === null) {
          throw new Error("Missing the required parameter 'callCompletedData' when calling setCallCompleted");
        }
  
  
        var pathParams = {
          'id': id
        };
        var queryParams = {
        };
        var collectionQueryParams = {
        };
        var headerParams = {
        };
        var formParams = {
        };
  
        var authNames = [];
        var contentTypes = ['application/json'];
        var accepts = ['application/json'];
        var returnType = ApiSuccessResponse;
  
        return this.apiClient.callApi(
          '/ucs/interactions/{id}/set-call-completed', 'POST',
          pathParams, queryParams, collectionQueryParams, headerParams, formParams, postBody,
          authNames, contentTypes, accepts, returnType
        );
      }
  
      /**
       * Set the call as being completed
       * @param {String} id id of the Interaction
       * @param {module:model/CallCompletedData} callCompletedData 
       * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/ApiSuccessResponse}
       */
      this.setCallCompleted = function(id, callCompletedData) {
        return this.setCallCompletedWithHttpInfo(id, callCompletedData)
          .then(function(response_and_data) {
            return response_and_data.data;
          });
      }
  
  
      /**
       * Set the interaction as being completed
       * @param {String} id id of the Interaction
       * @param {Object} opts Optional parameters
       * @param {module:model/CompletedData} opts.completedData 
       * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/ApiSuccessResponse} and HTTP response
       */
      this.setCompletedWithHttpInfo = function(id, opts) {
        opts = opts || {};
        var postBody = opts['completedData'];
  
        // verify the required parameter 'id' is set
        if (id === undefined || id === null) {
          throw new Error("Missing the required parameter 'id' when calling setCompleted");
        }
  
  
        var pathParams = {
          'id': id
        };
        var queryParams = {
        };
        var collectionQueryParams = {
        };
        var headerParams = {
        };
        var formParams = {
        };
  
        var authNames = [];
        var contentTypes = ['application/json'];
        var accepts = ['application/json'];
        var returnType = ApiSuccessResponse;
  
        return this.apiClient.callApi(
          '/ucs/interactions/{id}/set-completed', 'POST',
          pathParams, queryParams, collectionQueryParams, headerParams, formParams, postBody,
          authNames, contentTypes, accepts, returnType
        );
      }
  
      /**
       * Set the interaction as being completed
       * @param {String} id id of the Interaction
       * @param {Object} opts Optional parameters
       * @param {module:model/CompletedData} opts.completedData 
       * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/ApiSuccessResponse}
       */
      this.setCompleted = function(id, opts) {
        return this.setCompletedWithHttpInfo(id, opts)
          .then(function(response_and_data) {
            return response_and_data.data;
          });
      }
  
  
      /**
       * Update attributes of an existing contact
       * @param {String} id id of the Contact
       * @param {module:model/UpdateContactData} updateContactData 
       * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/ApiSuccessResponse} and HTTP response
       */
      this.updateContactWithHttpInfo = function(id, updateContactData) {
        var postBody = updateContactData;
  
        // verify the required parameter 'id' is set
        if (id === undefined || id === null) {
          throw new Error("Missing the required parameter 'id' when calling updateContact");
        }
  
        // verify the required parameter 'updateContactData' is set
        if (updateContactData === undefined || updateContactData === null) {
          throw new Error("Missing the required parameter 'updateContactData' when calling updateContact");
        }
  
  
        var pathParams = {
          'id': id
        };
        var queryParams = {
        };
        var collectionQueryParams = {
        };
        var headerParams = {
        };
        var formParams = {
        };
  
        var authNames = [];
        var contentTypes = ['application/json'];
        var accepts = ['application/json'];
        var returnType = ApiSuccessResponse;
  
        return this.apiClient.callApi(
          '/ucs/contacts/{id}/update', 'POST',
          pathParams, queryParams, collectionQueryParams, headerParams, formParams, postBody,
          authNames, contentTypes, accepts, returnType
        );
      }
  
      /**
       * Update attributes of an existing contact
       * @param {String} id id of the Contact
       * @param {module:model/UpdateContactData} updateContactData 
       * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/ApiSuccessResponse}
       */
      this.updateContact = function(id, updateContactData) {
        return this.updateContactWithHttpInfo(id, updateContactData)
          .then(function(response_and_data) {
            return response_and_data.data;
          });
      }
    }