• Home
• com.mypurecloud
• platform-client
• 0.58.4.140
• source code
• RoutingApi.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

com.mypurecloud.sdk.api.RoutingApi Maven / Gradle / Ivy

package com.mypurecloud.sdk.api;

import com.fasterxml.jackson.core.type.TypeReference;

import com.mypurecloud.sdk.ApiException;
import com.mypurecloud.sdk.ApiClient;
import com.mypurecloud.sdk.ApiResponse;
import com.mypurecloud.sdk.Configuration;
import com.mypurecloud.sdk.model.*;
import com.mypurecloud.sdk.Pair;

import com.mypurecloud.sdk.model.ErrorBody;
import com.mypurecloud.sdk.model.InboundDomainEntityListing;
import com.mypurecloud.sdk.model.InboundDomain;
import com.mypurecloud.sdk.model.InboundRouteEntityListing;
import com.mypurecloud.sdk.model.InboundRoute;
import com.mypurecloud.sdk.model.EmailSetup;
import com.mypurecloud.sdk.model.LanguageEntityListing;
import com.mypurecloud.sdk.model.QueueEntityListing;
import com.mypurecloud.sdk.model.Queue;
import com.mypurecloud.sdk.model.EstimatedWaitTimePredictions;
import com.mypurecloud.sdk.model.QueueMemberEntityListing;
import com.mypurecloud.sdk.model.WrapupCodeEntityListing;
import com.mypurecloud.sdk.model.SkillEntityListing;
import com.mypurecloud.sdk.model.RoutingSkill;
import com.mypurecloud.sdk.model.UserSkillEntityListing;
import com.mypurecloud.sdk.model.Utilization;
import com.mypurecloud.sdk.model.WrapupCode;
import com.mypurecloud.sdk.model.QueueMember;
import com.mypurecloud.sdk.model.Language;
import com.mypurecloud.sdk.model.CreateQueueRequest;
import com.mypurecloud.sdk.model.QualifierMappingObservationQueryResponse;
import com.mypurecloud.sdk.model.ObservationQuery;
import com.mypurecloud.sdk.model.UserRoutingSkillPost;
import com.mypurecloud.sdk.model.UserRoutingSkill;


import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;


public class RoutingApi {
  private ApiClient pcapiClient;

  public RoutingApi() {
    this(Configuration.getDefaultApiClient());
  }

  public RoutingApi(ApiClient apiClient) {
    this.pcapiClient = apiClient;
  }

  public ApiClient getApiClient() {
    return pcapiClient;
  }

  public void setApiClient(ApiClient apiClient) {
    this.pcapiClient = apiClient;
  }

  /**
   * Delete a domain
   * 
   * @param domainId domain ID (required)
   * @return String
   * @throws ApiException if fails to make API call
   */
  public String deleteEmailDomainsDomainId(String domainId) throws ApiException {
    return deleteEmailDomainsDomainIdWithHttpInfo(domainId).getResponseObject();
  }

  /**
   * Delete a domain
   * 
   * @param domainId domain ID (required)
   * @return String
   * @throws ApiException if fails to make API call
   */
  public ApiResponse deleteEmailDomainsDomainIdWithHttpInfo(String domainId) throws ApiException {
    Object pclocalVarPostBody = null;
    
    // verify the required parameter 'domainId' is set
    if (domainId == null) {
      throw new ApiException(400, "Missing the required parameter 'domainId' when calling deleteEmailDomainsDomainId");
    }
    
    // create path and map variables
    String pclocalVarPath = "/api/v2/routing/email/domains/{domainId}".replaceAll("\\{format\\}","json")
      .replaceAll("\\{" + "domainId" + "\\}", pcapiClient.escapeString(domainId.toString()));

    // query params
    List pclocalVarQueryParams = new ArrayList();
    Map pclocalVarHeaderParams = new HashMap();
    Map pclocalVarFormParams = new HashMap();


    
    
    final String[] pclocalVarAccepts = {
      "application/json"
    };
    final String pclocalVarAccept = pcapiClient.selectHeaderAccept(pclocalVarAccepts);

    final String[] pclocalVarContentTypes = {
      "application/json"
    };
    final String pclocalVarContentType = pcapiClient.selectHeaderContentType(pclocalVarContentTypes);

    String[] pclocalVarAuthNames = new String[] { "PureCloud Auth" };

    return pcapiClient.invokeAPIVerbose(pclocalVarPath, "DELETE", pclocalVarQueryParams, pclocalVarPostBody, pclocalVarHeaderParams, pclocalVarFormParams, pclocalVarAccept, pclocalVarContentType, pclocalVarAuthNames, new TypeReference() {});
  }
  /**
   * Delete a route
   * 
   * @param domainName email domain (required)
   * @param routeId route ID (required)
   * @return String
   * @throws ApiException if fails to make API call
   */
  public String deleteEmailDomainsDomainnameRoutesRouteId(String domainName, String routeId) throws ApiException {
    return deleteEmailDomainsDomainnameRoutesRouteIdWithHttpInfo(domainName, routeId).getResponseObject();
  }

  /**
   * Delete a route
   * 
   * @param domainName email domain (required)
   * @param routeId route ID (required)
   * @return String
   * @throws ApiException if fails to make API call
   */
  public ApiResponse deleteEmailDomainsDomainnameRoutesRouteIdWithHttpInfo(String domainName, String routeId) throws ApiException {
    Object pclocalVarPostBody = null;
    
    // verify the required parameter 'domainName' is set
    if (domainName == null) {
      throw new ApiException(400, "Missing the required parameter 'domainName' when calling deleteEmailDomainsDomainnameRoutesRouteId");
    }
    
    // verify the required parameter 'routeId' is set
    if (routeId == null) {
      throw new ApiException(400, "Missing the required parameter 'routeId' when calling deleteEmailDomainsDomainnameRoutesRouteId");
    }
    
    // create path and map variables
    String pclocalVarPath = "/api/v2/routing/email/domains/{domainName}/routes/{routeId}".replaceAll("\\{format\\}","json")
      .replaceAll("\\{" + "domainName" + "\\}", pcapiClient.escapeString(domainName.toString()))
      .replaceAll("\\{" + "routeId" + "\\}", pcapiClient.escapeString(routeId.toString()));

    // query params
    List pclocalVarQueryParams = new ArrayList();
    Map pclocalVarHeaderParams = new HashMap();
    Map pclocalVarFormParams = new HashMap();


    
    
    final String[] pclocalVarAccepts = {
      "application/json"
    };
    final String pclocalVarAccept = pcapiClient.selectHeaderAccept(pclocalVarAccepts);

    final String[] pclocalVarContentTypes = {
      "application/json"
    };
    final String pclocalVarContentType = pcapiClient.selectHeaderContentType(pclocalVarContentTypes);

    String[] pclocalVarAuthNames = new String[] { "PureCloud Auth" };

    return pcapiClient.invokeAPIVerbose(pclocalVarPath, "DELETE", pclocalVarQueryParams, pclocalVarPostBody, pclocalVarHeaderParams, pclocalVarFormParams, pclocalVarAccept, pclocalVarContentType, pclocalVarAuthNames, new TypeReference() {});
  }
  /**
   * Delete a queue
   * 
   * @param queueId Queue ID (required)
   * @param forceDelete forceDelete (optional)
   * @return String
   * @throws ApiException if fails to make API call
   */
  public String deleteQueuesQueueId(String queueId, Boolean forceDelete) throws ApiException {
    return deleteQueuesQueueIdWithHttpInfo(queueId, forceDelete).getResponseObject();
  }

  /**
   * Delete a queue
   * 
   * @param queueId Queue ID (required)
   * @param forceDelete forceDelete (optional)
   * @return String
   * @throws ApiException if fails to make API call
   */
  public ApiResponse deleteQueuesQueueIdWithHttpInfo(String queueId, Boolean forceDelete) throws ApiException {
    Object pclocalVarPostBody = null;
    
    // verify the required parameter 'queueId' is set
    if (queueId == null) {
      throw new ApiException(400, "Missing the required parameter 'queueId' when calling deleteQueuesQueueId");
    }
    
    // create path and map variables
    String pclocalVarPath = "/api/v2/routing/queues/{queueId}".replaceAll("\\{format\\}","json")
      .replaceAll("\\{" + "queueId" + "\\}", pcapiClient.escapeString(queueId.toString()));

    // query params
    List pclocalVarQueryParams = new ArrayList();
    Map pclocalVarHeaderParams = new HashMap();
    Map pclocalVarFormParams = new HashMap();

    pclocalVarQueryParams.addAll(pcapiClient.parameterToPairs("", "forceDelete", forceDelete));

    
    
    final String[] pclocalVarAccepts = {
      "application/json"
    };
    final String pclocalVarAccept = pcapiClient.selectHeaderAccept(pclocalVarAccepts);

    final String[] pclocalVarContentTypes = {
      "application/json"
    };
    final String pclocalVarContentType = pcapiClient.selectHeaderContentType(pclocalVarContentTypes);

    String[] pclocalVarAuthNames = new String[] { "PureCloud Auth" };

    return pcapiClient.invokeAPIVerbose(pclocalVarPath, "DELETE", pclocalVarQueryParams, pclocalVarPostBody, pclocalVarHeaderParams, pclocalVarFormParams, pclocalVarAccept, pclocalVarContentType, pclocalVarAuthNames, new TypeReference() {});
  }
  /**
   * Delete queue member
   * 
   * @param queueId Queue ID (required)
   * @param memberId Member ID (required)
   * @return String
   * @throws ApiException if fails to make API call
   */
  public String deleteQueuesQueueIdUsersMemberId(String queueId, String memberId) throws ApiException {
    return deleteQueuesQueueIdUsersMemberIdWithHttpInfo(queueId, memberId).getResponseObject();
  }

  /**
   * Delete queue member
   * 
   * @param queueId Queue ID (required)
   * @param memberId Member ID (required)
   * @return String
   * @throws ApiException if fails to make API call
   */
  public ApiResponse deleteQueuesQueueIdUsersMemberIdWithHttpInfo(String queueId, String memberId) throws ApiException {
    Object pclocalVarPostBody = null;
    
    // verify the required parameter 'queueId' is set
    if (queueId == null) {
      throw new ApiException(400, "Missing the required parameter 'queueId' when calling deleteQueuesQueueIdUsersMemberId");
    }
    
    // verify the required parameter 'memberId' is set
    if (memberId == null) {
      throw new ApiException(400, "Missing the required parameter 'memberId' when calling deleteQueuesQueueIdUsersMemberId");
    }
    
    // create path and map variables
    String pclocalVarPath = "/api/v2/routing/queues/{queueId}/users/{memberId}".replaceAll("\\{format\\}","json")
      .replaceAll("\\{" + "queueId" + "\\}", pcapiClient.escapeString(queueId.toString()))
      .replaceAll("\\{" + "memberId" + "\\}", pcapiClient.escapeString(memberId.toString()));

    // query params
    List pclocalVarQueryParams = new ArrayList();
    Map pclocalVarHeaderParams = new HashMap();
    Map pclocalVarFormParams = new HashMap();


    
    
    final String[] pclocalVarAccepts = {
      "application/json"
    };
    final String pclocalVarAccept = pcapiClient.selectHeaderAccept(pclocalVarAccepts);

    final String[] pclocalVarContentTypes = {
      "application/json"
    };
    final String pclocalVarContentType = pcapiClient.selectHeaderContentType(pclocalVarContentTypes);

    String[] pclocalVarAuthNames = new String[] { "PureCloud Auth" };

    return pcapiClient.invokeAPIVerbose(pclocalVarPath, "DELETE", pclocalVarQueryParams, pclocalVarPostBody, pclocalVarHeaderParams, pclocalVarFormParams, pclocalVarAccept, pclocalVarContentType, pclocalVarAuthNames, new TypeReference() {});
  }
  /**
   * Delete a wrap-up code from a queue
   * 
   * @param queueId Queue ID (required)
   * @param codeId Code ID (required)
   * @return String
   * @throws ApiException if fails to make API call
   */
  public String deleteQueuesQueueIdWrapupcodesCodeId(String queueId, String codeId) throws ApiException {
    return deleteQueuesQueueIdWrapupcodesCodeIdWithHttpInfo(queueId, codeId).getResponseObject();
  }

  /**
   * Delete a wrap-up code from a queue
   * 
   * @param queueId Queue ID (required)
   * @param codeId Code ID (required)
   * @return String
   * @throws ApiException if fails to make API call
   */
  public ApiResponse deleteQueuesQueueIdWrapupcodesCodeIdWithHttpInfo(String queueId, String codeId) throws ApiException {
    Object pclocalVarPostBody = null;
    
    // verify the required parameter 'queueId' is set
    if (queueId == null) {
      throw new ApiException(400, "Missing the required parameter 'queueId' when calling deleteQueuesQueueIdWrapupcodesCodeId");
    }
    
    // verify the required parameter 'codeId' is set
    if (codeId == null) {
      throw new ApiException(400, "Missing the required parameter 'codeId' when calling deleteQueuesQueueIdWrapupcodesCodeId");
    }
    
    // create path and map variables
    String pclocalVarPath = "/api/v2/routing/queues/{queueId}/wrapupcodes/{codeId}".replaceAll("\\{format\\}","json")
      .replaceAll("\\{" + "queueId" + "\\}", pcapiClient.escapeString(queueId.toString()))
      .replaceAll("\\{" + "codeId" + "\\}", pcapiClient.escapeString(codeId.toString()));

    // query params
    List pclocalVarQueryParams = new ArrayList();
    Map pclocalVarHeaderParams = new HashMap();
    Map pclocalVarFormParams = new HashMap();


    
    
    final String[] pclocalVarAccepts = {
      "application/json"
    };
    final String pclocalVarAccept = pcapiClient.selectHeaderAccept(pclocalVarAccepts);

    final String[] pclocalVarContentTypes = {
      "application/json"
    };
    final String pclocalVarContentType = pcapiClient.selectHeaderContentType(pclocalVarContentTypes);

    String[] pclocalVarAuthNames = new String[] { "PureCloud Auth" };

    return pcapiClient.invokeAPIVerbose(pclocalVarPath, "DELETE", pclocalVarQueryParams, pclocalVarPostBody, pclocalVarHeaderParams, pclocalVarFormParams, pclocalVarAccept, pclocalVarContentType, pclocalVarAuthNames, new TypeReference() {});
  }
  /**
   * Delete Routing Skill
   * 
   * @param skillId Skill ID (required)
   * @return String
   * @throws ApiException if fails to make API call
   */
  public String deleteSkillsSkillId(String skillId) throws ApiException {
    return deleteSkillsSkillIdWithHttpInfo(skillId).getResponseObject();
  }

  /**
   * Delete Routing Skill
   * 
   * @param skillId Skill ID (required)
   * @return String
   * @throws ApiException if fails to make API call
   */
  public ApiResponse deleteSkillsSkillIdWithHttpInfo(String skillId) throws ApiException {
    Object pclocalVarPostBody = null;
    
    // verify the required parameter 'skillId' is set
    if (skillId == null) {
      throw new ApiException(400, "Missing the required parameter 'skillId' when calling deleteSkillsSkillId");
    }
    
    // create path and map variables
    String pclocalVarPath = "/api/v2/routing/skills/{skillId}".replaceAll("\\{format\\}","json")
      .replaceAll("\\{" + "skillId" + "\\}", pcapiClient.escapeString(skillId.toString()));

    // query params
    List pclocalVarQueryParams = new ArrayList();
    Map pclocalVarHeaderParams = new HashMap();
    Map pclocalVarFormParams = new HashMap();


    
    
    final String[] pclocalVarAccepts = {
      "application/json"
    };
    final String pclocalVarAccept = pcapiClient.selectHeaderAccept(pclocalVarAccepts);

    final String[] pclocalVarContentTypes = {
      "application/json"
    };
    final String pclocalVarContentType = pcapiClient.selectHeaderContentType(pclocalVarContentTypes);

    String[] pclocalVarAuthNames = new String[] { "PureCloud Auth" };

    return pcapiClient.invokeAPIVerbose(pclocalVarPath, "DELETE", pclocalVarQueryParams, pclocalVarPostBody, pclocalVarHeaderParams, pclocalVarFormParams, pclocalVarAccept, pclocalVarContentType, pclocalVarAuthNames, new TypeReference() {});
  }
  /**
   * Remove routing skill from user
   * 
   * @param userId User ID (required)
   * @param skillId skillId (required)
   * @return String
   * @throws ApiException if fails to make API call
   */
  public String deleteUserIdRoutingskillsSkillId(String userId, String skillId) throws ApiException {
    return deleteUserIdRoutingskillsSkillIdWithHttpInfo(userId, skillId).getResponseObject();
  }

  /**
   * Remove routing skill from user
   * 
   * @param userId User ID (required)
   * @param skillId skillId (required)
   * @return String
   * @throws ApiException if fails to make API call
   */
  public ApiResponse deleteUserIdRoutingskillsSkillIdWithHttpInfo(String userId, String skillId) throws ApiException {
    Object pclocalVarPostBody = null;
    
    // verify the required parameter 'userId' is set
    if (userId == null) {
      throw new ApiException(400, "Missing the required parameter 'userId' when calling deleteUserIdRoutingskillsSkillId");
    }
    
    // verify the required parameter 'skillId' is set
    if (skillId == null) {
      throw new ApiException(400, "Missing the required parameter 'skillId' when calling deleteUserIdRoutingskillsSkillId");
    }
    
    // create path and map variables
    String pclocalVarPath = "/api/v2/users/{userId}/routingskills/{skillId}".replaceAll("\\{format\\}","json")
      .replaceAll("\\{" + "userId" + "\\}", pcapiClient.escapeString(userId.toString()))
      .replaceAll("\\{" + "skillId" + "\\}", pcapiClient.escapeString(skillId.toString()));

    // query params
    List pclocalVarQueryParams = new ArrayList();
    Map pclocalVarHeaderParams = new HashMap();
    Map pclocalVarFormParams = new HashMap();


    
    
    final String[] pclocalVarAccepts = {
      "application/json"
    };
    final String pclocalVarAccept = pcapiClient.selectHeaderAccept(pclocalVarAccepts);

    final String[] pclocalVarContentTypes = {
      "application/json"
    };
    final String pclocalVarContentType = pcapiClient.selectHeaderContentType(pclocalVarContentTypes);

    String[] pclocalVarAuthNames = new String[] { "PureCloud Auth" };

    return pcapiClient.invokeAPIVerbose(pclocalVarPath, "DELETE", pclocalVarQueryParams, pclocalVarPostBody, pclocalVarHeaderParams, pclocalVarFormParams, pclocalVarAccept, pclocalVarContentType, pclocalVarAuthNames, new TypeReference() {});
  }
  /**
   * Delete utilization settings and revert to system defaults.
   * 
   * @return String
   * @throws ApiException if fails to make API call
   */
  public String deleteUtilization() throws ApiException {
    return deleteUtilizationWithHttpInfo().getResponseObject();
  }

  /**
   * Delete utilization settings and revert to system defaults.
   * 
   * @return String
   * @throws ApiException if fails to make API call
   */
  public ApiResponse deleteUtilizationWithHttpInfo() throws ApiException {
    Object pclocalVarPostBody = null;
    
    // create path and map variables
    String pclocalVarPath = "/api/v2/routing/utilization".replaceAll("\\{format\\}","json");

    // query params
    List pclocalVarQueryParams = new ArrayList();
    Map pclocalVarHeaderParams = new HashMap();
    Map pclocalVarFormParams = new HashMap();


    
    
    final String[] pclocalVarAccepts = {
      "application/json"
    };
    final String pclocalVarAccept = pcapiClient.selectHeaderAccept(pclocalVarAccepts);

    final String[] pclocalVarContentTypes = {
      "application/json"
    };
    final String pclocalVarContentType = pcapiClient.selectHeaderContentType(pclocalVarContentTypes);

    String[] pclocalVarAuthNames = new String[] { "PureCloud Auth" };

    return pcapiClient.invokeAPIVerbose(pclocalVarPath, "DELETE", pclocalVarQueryParams, pclocalVarPostBody, pclocalVarHeaderParams, pclocalVarFormParams, pclocalVarAccept, pclocalVarContentType, pclocalVarAuthNames, new TypeReference() {});
  }
  /**
   * Delete wrap-up code
   * 
   * @param codeId Wrapup Code ID (required)
   * @return String
   * @throws ApiException if fails to make API call
   */
  public String deleteWrapupcodesCodeId(String codeId) throws ApiException {
    return deleteWrapupcodesCodeIdWithHttpInfo(codeId).getResponseObject();
  }

  /**
   * Delete wrap-up code
   * 
   * @param codeId Wrapup Code ID (required)
   * @return String
   * @throws ApiException if fails to make API call
   */
  public ApiResponse deleteWrapupcodesCodeIdWithHttpInfo(String codeId) throws ApiException {
    Object pclocalVarPostBody = null;
    
    // verify the required parameter 'codeId' is set
    if (codeId == null) {
      throw new ApiException(400, "Missing the required parameter 'codeId' when calling deleteWrapupcodesCodeId");
    }
    
    // create path and map variables
    String pclocalVarPath = "/api/v2/routing/wrapupcodes/{codeId}".replaceAll("\\{format\\}","json")
      .replaceAll("\\{" + "codeId" + "\\}", pcapiClient.escapeString(codeId.toString()));

    // query params
    List pclocalVarQueryParams = new ArrayList();
    Map pclocalVarHeaderParams = new HashMap();
    Map pclocalVarFormParams = new HashMap();


    
    
    final String[] pclocalVarAccepts = {
      "application/json"
    };
    final String pclocalVarAccept = pcapiClient.selectHeaderAccept(pclocalVarAccepts);

    final String[] pclocalVarContentTypes = {
      "application/json"
    };
    final String pclocalVarContentType = pcapiClient.selectHeaderContentType(pclocalVarContentTypes);

    String[] pclocalVarAuthNames = new String[] { "PureCloud Auth" };

    return pcapiClient.invokeAPIVerbose(pclocalVarPath, "DELETE", pclocalVarQueryParams, pclocalVarPostBody, pclocalVarHeaderParams, pclocalVarFormParams, pclocalVarAccept, pclocalVarContentType, pclocalVarAuthNames, new TypeReference() {});
  }
  /**
   * Get domains
   * 
   * @return InboundDomainEntityListing
   * @throws ApiException if fails to make API call
   */
  public InboundDomainEntityListing getEmailDomains() throws ApiException {
    return getEmailDomainsWithHttpInfo().getResponseObject();
  }

  /**
   * Get domains
   * 
   * @return InboundDomainEntityListing
   * @throws ApiException if fails to make API call
   */
  public ApiResponse getEmailDomainsWithHttpInfo() throws ApiException {
    Object pclocalVarPostBody = null;
    
    // create path and map variables
    String pclocalVarPath = "/api/v2/routing/email/domains".replaceAll("\\{format\\}","json");

    // query params
    List pclocalVarQueryParams = new ArrayList();
    Map pclocalVarHeaderParams = new HashMap();
    Map pclocalVarFormParams = new HashMap();


    
    
    final String[] pclocalVarAccepts = {
      "application/json"
    };
    final String pclocalVarAccept = pcapiClient.selectHeaderAccept(pclocalVarAccepts);

    final String[] pclocalVarContentTypes = {
      "application/json"
    };
    final String pclocalVarContentType = pcapiClient.selectHeaderContentType(pclocalVarContentTypes);

    String[] pclocalVarAuthNames = new String[] { "PureCloud Auth" };

    return pcapiClient.invokeAPIVerbose(pclocalVarPath, "GET", pclocalVarQueryParams, pclocalVarPostBody, pclocalVarHeaderParams, pclocalVarFormParams, pclocalVarAccept, pclocalVarContentType, pclocalVarAuthNames, new TypeReference() {});
  }
  /**
   * Get domain
   * 
   * @param domainId domain ID (required)
   * @return InboundDomain
   * @throws ApiException if fails to make API call
   */
  public InboundDomain getEmailDomainsDomainId(String domainId) throws ApiException {
    return getEmailDomainsDomainIdWithHttpInfo(domainId).getResponseObject();
  }

  /**
   * Get domain
   * 
   * @param domainId domain ID (required)
   * @return InboundDomain
   * @throws ApiException if fails to make API call
   */
  public ApiResponse getEmailDomainsDomainIdWithHttpInfo(String domainId) throws ApiException {
    Object pclocalVarPostBody = null;
    
    // verify the required parameter 'domainId' is set
    if (domainId == null) {
      throw new ApiException(400, "Missing the required parameter 'domainId' when calling getEmailDomainsDomainId");
    }
    
    // create path and map variables
    String pclocalVarPath = "/api/v2/routing/email/domains/{domainId}".replaceAll("\\{format\\}","json")
      .replaceAll("\\{" + "domainId" + "\\}", pcapiClient.escapeString(domainId.toString()));

    // query params
    List pclocalVarQueryParams = new ArrayList();
    Map pclocalVarHeaderParams = new HashMap();
    Map pclocalVarFormParams = new HashMap();


    
    
    final String[] pclocalVarAccepts = {
      "application/json"
    };
    final String pclocalVarAccept = pcapiClient.selectHeaderAccept(pclocalVarAccepts);

    final String[] pclocalVarContentTypes = {
      "application/json"
    };
    final String pclocalVarContentType = pcapiClient.selectHeaderContentType(pclocalVarContentTypes);

    String[] pclocalVarAuthNames = new String[] { "PureCloud Auth" };

    return pcapiClient.invokeAPIVerbose(pclocalVarPath, "GET", pclocalVarQueryParams, pclocalVarPostBody, pclocalVarHeaderParams, pclocalVarFormParams, pclocalVarAccept, pclocalVarContentType, pclocalVarAuthNames, new TypeReference() {});
  }
  /**
   * Get routes
   * 
   * @param domainName email domain (required)
   * @param pageSize Page size (optional, default to 25)
   * @param pageNumber Page number (optional, default to 1)
   * @param pattern Filter routes by the route's pattern property (optional)
   * @return InboundRouteEntityListing
   * @throws ApiException if fails to make API call
   */
  public InboundRouteEntityListing getEmailDomainsDomainnameRoutes(String domainName, Integer pageSize, Integer pageNumber, String pattern) throws ApiException {
    return getEmailDomainsDomainnameRoutesWithHttpInfo(domainName, pageSize, pageNumber, pattern).getResponseObject();
  }

  /**
   * Get routes
   * 
   * @param domainName email domain (required)
   * @param pageSize Page size (optional, default to 25)
   * @param pageNumber Page number (optional, default to 1)
   * @param pattern Filter routes by the route's pattern property (optional)
   * @return InboundRouteEntityListing
   * @throws ApiException if fails to make API call
   */
  public ApiResponse getEmailDomainsDomainnameRoutesWithHttpInfo(String domainName, Integer pageSize, Integer pageNumber, String pattern) throws ApiException {
    Object pclocalVarPostBody = null;
    
    // verify the required parameter 'domainName' is set
    if (domainName == null) {
      throw new ApiException(400, "Missing the required parameter 'domainName' when calling getEmailDomainsDomainnameRoutes");
    }
    
    // create path and map variables
    String pclocalVarPath = "/api/v2/routing/email/domains/{domainName}/routes".replaceAll("\\{format\\}","json")
      .replaceAll("\\{" + "domainName" + "\\}", pcapiClient.escapeString(domainName.toString()));

    // query params
    List pclocalVarQueryParams = new ArrayList();
    Map pclocalVarHeaderParams = new HashMap();
    Map pclocalVarFormParams = new HashMap();

    pclocalVarQueryParams.addAll(pcapiClient.parameterToPairs("", "pageSize", pageSize));
    pclocalVarQueryParams.addAll(pcapiClient.parameterToPairs("", "pageNumber", pageNumber));
    pclocalVarQueryParams.addAll(pcapiClient.parameterToPairs("", "pattern", pattern));

    
    
    final String[] pclocalVarAccepts = {
      "application/json"
    };
    final String pclocalVarAccept = pcapiClient.selectHeaderAccept(pclocalVarAccepts);

    final String[] pclocalVarContentTypes = {
      "application/json"
    };
    final String pclocalVarContentType = pcapiClient.selectHeaderContentType(pclocalVarContentTypes);

    String[] pclocalVarAuthNames = new String[] { "PureCloud Auth" };

    return pcapiClient.invokeAPIVerbose(pclocalVarPath, "GET", pclocalVarQueryParams, pclocalVarPostBody, pclocalVarHeaderParams, pclocalVarFormParams, pclocalVarAccept, pclocalVarContentType, pclocalVarAuthNames, new TypeReference() {});
  }
  /**
   * Get a route
   * 
   * @param domainName email domain (required)
   * @param routeId route ID (required)
   * @return InboundRoute
   * @throws ApiException if fails to make API call
   */
  public InboundRoute getEmailDomainsDomainnameRoutesRouteId(String domainName, String routeId) throws ApiException {
    return getEmailDomainsDomainnameRoutesRouteIdWithHttpInfo(domainName, routeId).getResponseObject();
  }

  /**
   * Get a route
   * 
   * @param domainName email domain (required)
   * @param routeId route ID (required)
   * @return InboundRoute
   * @throws ApiException if fails to make API call
   */
  public ApiResponse getEmailDomainsDomainnameRoutesRouteIdWithHttpInfo(String domainName, String routeId) throws ApiException {
    Object pclocalVarPostBody = null;
    
    // verify the required parameter 'domainName' is set
    if (domainName == null) {
      throw new ApiException(400, "Missing the required parameter 'domainName' when calling getEmailDomainsDomainnameRoutesRouteId");
    }
    
    // verify the required parameter 'routeId' is set
    if (routeId == null) {
      throw new ApiException(400, "Missing the required parameter 'routeId' when calling getEmailDomainsDomainnameRoutesRouteId");
    }
    
    // create path and map variables
    String pclocalVarPath = "/api/v2/routing/email/domains/{domainName}/routes/{routeId}".replaceAll("\\{format\\}","json")
      .replaceAll("\\{" + "domainName" + "\\}", pcapiClient.escapeString(domainName.toString()))
      .replaceAll("\\{" + "routeId" + "\\}", pcapiClient.escapeString(routeId.toString()));

    // query params
    List pclocalVarQueryParams = new ArrayList();
    Map pclocalVarHeaderParams = new HashMap();
    Map pclocalVarFormParams = new HashMap();


    
    
    final String[] pclocalVarAccepts = {
      "application/json"
    };
    final String pclocalVarAccept = pcapiClient.selectHeaderAccept(pclocalVarAccepts);

    final String[] pclocalVarContentTypes = {
      "application/json"
    };
    final String pclocalVarContentType = pcapiClient.selectHeaderContentType(pclocalVarContentTypes);

    String[] pclocalVarAuthNames = new String[] { "PureCloud Auth" };

    return pcapiClient.invokeAPIVerbose(pclocalVarPath, "GET", pclocalVarQueryParams, pclocalVarPostBody, pclocalVarHeaderParams, pclocalVarFormParams, pclocalVarAccept, pclocalVarContentType, pclocalVarAuthNames, new TypeReference() {});
  }
  /**
   * Get email setup
   * 
   * @return EmailSetup
   * @throws ApiException if fails to make API call
   */
  public EmailSetup getEmailSetup() throws ApiException {
    return getEmailSetupWithHttpInfo().getResponseObject();
  }

  /**
   * Get email setup
   * 
   * @return EmailSetup
   * @throws ApiException if fails to make API call
   */
  public ApiResponse getEmailSetupWithHttpInfo() throws ApiException {
    Object pclocalVarPostBody = null;
    
    // create path and map variables
    String pclocalVarPath = "/api/v2/routing/email/setup".replaceAll("\\{format\\}","json");

    // query params
    List pclocalVarQueryParams = new ArrayList();
    Map pclocalVarHeaderParams = new HashMap();
    Map pclocalVarFormParams = new HashMap();


    
    
    final String[] pclocalVarAccepts = {
      "application/json"
    };
    final String pclocalVarAccept = pcapiClient.selectHeaderAccept(pclocalVarAccepts);

    final String[] pclocalVarContentTypes = {
      "application/json"
    };
    final String pclocalVarContentType = pcapiClient.selectHeaderContentType(pclocalVarContentTypes);

    String[] pclocalVarAuthNames = new String[] { "PureCloud Auth" };

    return pcapiClient.invokeAPIVerbose(pclocalVarPath, "GET", pclocalVarQueryParams, pclocalVarPostBody, pclocalVarHeaderParams, pclocalVarFormParams, pclocalVarAccept, pclocalVarContentType, pclocalVarAuthNames, new TypeReference() {});
  }
  /**
   * Get the list of supported languages.
   * 
   * @param pageSize Page size (optional, default to 25)
   * @param pageNumber Page number (optional, default to 1)
   * @param sortOrder Ascending or descending sort order (optional, default to ASC)
   * @param name Name (optional)
   * @return LanguageEntityListing
   * @throws ApiException if fails to make API call
   */
  public LanguageEntityListing getLanguages(Integer pageSize, Integer pageNumber, String sortOrder, String name) throws ApiException {
    return getLanguagesWithHttpInfo(pageSize, pageNumber, sortOrder, name).getResponseObject();
  }

  /**
   * Get the list of supported languages.
   * 
   * @param pageSize Page size (optional, default to 25)
   * @param pageNumber Page number (optional, default to 1)
   * @param sortOrder Ascending or descending sort order (optional, default to ASC)
   * @param name Name (optional)
   * @return LanguageEntityListing
   * @throws ApiException if fails to make API call
   */
  public ApiResponse getLanguagesWithHttpInfo(Integer pageSize, Integer pageNumber, String sortOrder, String name) throws ApiException {
    Object pclocalVarPostBody = null;
    
    // create path and map variables
    String pclocalVarPath = "/api/v2/routing/languages".replaceAll("\\{format\\}","json");

    // query params
    List pclocalVarQueryParams = new ArrayList();
    Map pclocalVarHeaderParams = new HashMap();
    Map pclocalVarFormParams = new HashMap();

    pclocalVarQueryParams.addAll(pcapiClient.parameterToPairs("", "pageSize", pageSize));
    pclocalVarQueryParams.addAll(pcapiClient.parameterToPairs("", "pageNumber", pageNumber));
    pclocalVarQueryParams.addAll(pcapiClient.parameterToPairs("", "sortOrder", sortOrder));
    pclocalVarQueryParams.addAll(pcapiClient.parameterToPairs("", "name", name));

    
    
    final String[] pclocalVarAccepts = {
      "application/json"
    };
    final String pclocalVarAccept = pcapiClient.selectHeaderAccept(pclocalVarAccepts);

    final String[] pclocalVarContentTypes = {
      "application/json"
    };
    final String pclocalVarContentType = pcapiClient.selectHeaderContentType(pclocalVarContentTypes);

    String[] pclocalVarAuthNames = new String[] { "PureCloud Auth" };

    return pcapiClient.invokeAPIVerbose(pclocalVarPath, "GET", pclocalVarQueryParams, pclocalVarPostBody, pclocalVarHeaderParams, pclocalVarFormParams, pclocalVarAccept, pclocalVarContentType, pclocalVarAuthNames, new TypeReference() {});
  }
  /**
   * Get list of queues.
   * 
   * @param pageSize Page size (optional, default to 25)
   * @param pageNumber Page number (optional, default to 1)
   * @param sortBy Sort by (optional, default to name)
   * @param name Name (optional)
   * @param active Active (optional)
   * @return QueueEntityListing
   * @throws ApiException if fails to make API call
   */
  public QueueEntityListing getQueues(Integer pageSize, Integer pageNumber, String sortBy, String name, Boolean active) throws ApiException {
    return getQueuesWithHttpInfo(pageSize, pageNumber, sortBy, name, active).getResponseObject();
  }

  /**
   * Get list of queues.
   * 
   * @param pageSize Page size (optional, default to 25)
   * @param pageNumber Page number (optional, default to 1)
   * @param sortBy Sort by (optional, default to name)
   * @param name Name (optional)
   * @param active Active (optional)
   * @return QueueEntityListing
   * @throws ApiException if fails to make API call
   */
  public ApiResponse getQueuesWithHttpInfo(Integer pageSize, Integer pageNumber, String sortBy, String name, Boolean active) throws ApiException {
    Object pclocalVarPostBody = null;
    
    // create path and map variables
    String pclocalVarPath = "/api/v2/routing/queues".replaceAll("\\{format\\}","json");

    // query params
    List pclocalVarQueryParams = new ArrayList();
    Map pclocalVarHeaderParams = new HashMap();
    Map pclocalVarFormParams = new HashMap();

    pclocalVarQueryParams.addAll(pcapiClient.parameterToPairs("", "pageSize", pageSize));
    pclocalVarQueryParams.addAll(pcapiClient.parameterToPairs("", "pageNumber", pageNumber));
    pclocalVarQueryParams.addAll(pcapiClient.parameterToPairs("", "sortBy", sortBy));
    pclocalVarQueryParams.addAll(pcapiClient.parameterToPairs("", "name", name));
    pclocalVarQueryParams.addAll(pcapiClient.parameterToPairs("", "active", active));

    
    
    final String[] pclocalVarAccepts = {
      "application/json"
    };
    final String pclocalVarAccept = pcapiClient.selectHeaderAccept(pclocalVarAccepts);

    final String[] pclocalVarContentTypes = {
      "application/json"
    };
    final String pclocalVarContentType = pcapiClient.selectHeaderContentType(pclocalVarContentTypes);

    String[] pclocalVarAuthNames = new String[] { "PureCloud Auth" };

    return pcapiClient.invokeAPIVerbose(pclocalVarPath, "GET", pclocalVarQueryParams, pclocalVarPostBody, pclocalVarHeaderParams, pclocalVarFormParams, pclocalVarAccept, pclocalVarContentType, pclocalVarAuthNames, new TypeReference() {});
  }
  /**
   * Get details about this queue.
   * 
   * @param queueId Queue ID (required)
   * @return Queue
   * @throws ApiException if fails to make API call
   */
  public Queue getQueuesQueueId(String queueId) throws ApiException {
    return getQueuesQueueIdWithHttpInfo(queueId).getResponseObject();
  }

  /**
   * Get details about this queue.
   * 
   * @param queueId Queue ID (required)
   * @return Queue
   * @throws ApiException if fails to make API call
   */
  public ApiResponse getQueuesQueueIdWithHttpInfo(String queueId) throws ApiException {
    Object pclocalVarPostBody = null;
    
    // verify the required parameter 'queueId' is set
    if (queueId == null) {
      throw new ApiException(400, "Missing the required parameter 'queueId' when calling getQueuesQueueId");
    }
    
    // create path and map variables
    String pclocalVarPath = "/api/v2/routing/queues/{queueId}".replaceAll("\\{format\\}","json")
      .replaceAll("\\{" + "queueId" + "\\}", pcapiClient.escapeString(queueId.toString()));

    // query params
    List pclocalVarQueryParams = new ArrayList();
    Map pclocalVarHeaderParams = new HashMap();
    Map pclocalVarFormParams = new HashMap();


    
    
    final String[] pclocalVarAccepts = {
      "application/json"
    };
    final String pclocalVarAccept = pcapiClient.selectHeaderAccept(pclocalVarAccepts);

    final String[] pclocalVarContentTypes = {
      "application/json"
    };
    final String pclocalVarContentType = pcapiClient.selectHeaderContentType(pclocalVarContentTypes);

    String[] pclocalVarAuthNames = new String[] { "PureCloud Auth" };

    return pcapiClient.invokeAPIVerbose(pclocalVarPath, "GET", pclocalVarQueryParams, pclocalVarPostBody, pclocalVarHeaderParams, pclocalVarFormParams, pclocalVarAccept, pclocalVarContentType, pclocalVarAuthNames, new TypeReference() {});
  }
  /**
   * Get Estimated Wait Time
   * 
   * @param queueId queueId (required)
   * @param conversationId conversationId (optional)
   * @return EstimatedWaitTimePredictions
   * @throws ApiException if fails to make API call
   */
  public EstimatedWaitTimePredictions getQueuesQueueIdEstimatedwaittime(String queueId, String conversationId) throws ApiException {
    return getQueuesQueueIdEstimatedwaittimeWithHttpInfo(queueId, conversationId).getResponseObject();
  }

  /**
   * Get Estimated Wait Time
   * 
   * @param queueId queueId (required)
   * @param conversationId conversationId (optional)
   * @return EstimatedWaitTimePredictions
   * @throws ApiException if fails to make API call
   */
  public ApiResponse getQueuesQueueIdEstimatedwaittimeWithHttpInfo(String queueId, String conversationId) throws ApiException {
    Object pclocalVarPostBody = null;
    
    // verify the required parameter 'queueId' is set
    if (queueId == null) {
      throw new ApiException(400, "Missing the required parameter 'queueId' when calling getQueuesQueueIdEstimatedwaittime");
    }
    
    // create path and map variables
    String pclocalVarPath = "/api/v2/routing/queues/{queueId}/estimatedwaittime".replaceAll("\\{format\\}","json")
      .replaceAll("\\{" + "queueId" + "\\}", pcapiClient.escapeString(queueId.toString()));

    // query params
    List pclocalVarQueryParams = new ArrayList();
    Map pclocalVarHeaderParams = new HashMap();
    Map pclocalVarFormParams = new HashMap();

    pclocalVarQueryParams.addAll(pcapiClient.parameterToPairs("", "conversationId", conversationId));

    
    
    final String[] pclocalVarAccepts = {
      "application/json"
    };
    final String pclocalVarAccept = pcapiClient.selectHeaderAccept(pclocalVarAccepts);

    final String[] pclocalVarContentTypes = {
      "application/json"
    };
    final String pclocalVarContentType = pcapiClient.selectHeaderContentType(pclocalVarContentTypes);

    String[] pclocalVarAuthNames = new String[] { "PureCloud Auth" };

    return pcapiClient.invokeAPIVerbose(pclocalVarPath, "GET", pclocalVarQueryParams, pclocalVarPostBody, pclocalVarHeaderParams, pclocalVarFormParams, pclocalVarAccept, pclocalVarContentType, pclocalVarAuthNames, new TypeReference() {});
  }
  /**
   * Get Estimated Wait Time
   * 
   * @param queueId queueId (required)
   * @param mediaType mediaType (required)
   * @return EstimatedWaitTimePredictions
   * @throws ApiException if fails to make API call
   */
  public EstimatedWaitTimePredictions getQueuesQueueIdMediatypesMediatypeEstimatedwaittime(String queueId, String mediaType) throws ApiException {
    return getQueuesQueueIdMediatypesMediatypeEstimatedwaittimeWithHttpInfo(queueId, mediaType).getResponseObject();
  }

  /**
   * Get Estimated Wait Time
   * 
   * @param queueId queueId (required)
   * @param mediaType mediaType (required)
   * @return EstimatedWaitTimePredictions
   * @throws ApiException if fails to make API call
   */
  public ApiResponse getQueuesQueueIdMediatypesMediatypeEstimatedwaittimeWithHttpInfo(String queueId, String mediaType) throws ApiException {
    Object pclocalVarPostBody = null;
    
    // verify the required parameter 'queueId' is set
    if (queueId == null) {
      throw new ApiException(400, "Missing the required parameter 'queueId' when calling getQueuesQueueIdMediatypesMediatypeEstimatedwaittime");
    }
    
    // verify the required parameter 'mediaType' is set
    if (mediaType == null) {
      throw new ApiException(400, "Missing the required parameter 'mediaType' when calling getQueuesQueueIdMediatypesMediatypeEstimatedwaittime");
    }
    
    // create path and map variables
    String pclocalVarPath = "/api/v2/routing/queues/{queueId}/mediatypes/{mediaType}/estimatedwaittime".replaceAll("\\{format\\}","json")
      .replaceAll("\\{" + "queueId" + "\\}", pcapiClient.escapeString(queueId.toString()))
      .replaceAll("\\{" + "mediaType" + "\\}", pcapiClient.escapeString(mediaType.toString()));

    // query params
    List pclocalVarQueryParams = new ArrayList();
    Map pclocalVarHeaderParams = new HashMap();
    Map pclocalVarFormParams = new HashMap();


    
    
    final String[] pclocalVarAccepts = {
      "application/json"
    };
    final String pclocalVarAccept = pcapiClient.selectHeaderAccept(pclocalVarAccepts);

    final String[] pclocalVarContentTypes = {
      "application/json"
    };
    final String pclocalVarContentType = pcapiClient.selectHeaderContentType(pclocalVarContentTypes);

    String[] pclocalVarAuthNames = new String[] { "PureCloud Auth" };

    return pcapiClient.invokeAPIVerbose(pclocalVarPath, "GET", pclocalVarQueryParams, pclocalVarPostBody, pclocalVarHeaderParams, pclocalVarFormParams, pclocalVarAccept, pclocalVarContentType, pclocalVarAuthNames, new TypeReference() {});
  }
  /**
   * Get the members of this queue
   * 
   * @param queueId Queue ID (required)
   * @param pageSize Page size (optional, default to 25)
   * @param pageNumber Page number (optional, default to 1)
   * @param sortBy Sort by (optional, default to name)
   * @param expand Which fields, if any, to expand. (optional)
   * @param joined Filter by joined status (optional)
   * @param name Filter by queue member name (optional)
   * @param profileSkills Filter by profile skill (optional)
   * @param skills Filter by skill (optional)
   * @param languages Filter by language (optional)
   * @param routingStatus Filter by routing status (optional)
   * @param presence Filter by presence (optional)
   * @return QueueMemberEntityListing
   * @throws ApiException if fails to make API call
   */
  public QueueMemberEntityListing getQueuesQueueIdUsers(String queueId, Integer pageSize, Integer pageNumber, String sortBy, List expand, Boolean joined, String name, List profileSkills, List skills, List languages, List routingStatus, List presence) throws ApiException {
    return getQueuesQueueIdUsersWithHttpInfo(queueId, pageSize, pageNumber, sortBy, expand, joined, name, profileSkills, skills, languages, routingStatus, presence).getResponseObject();
  }

  /**
   * Get the members of this queue
   * 
   * @param queueId Queue ID (required)
   * @param pageSize Page size (optional, default to 25)
   * @param pageNumber Page number (optional, default to 1)
   * @param sortBy Sort by (optional, default to name)
   * @param expand Which fields, if any, to expand. (optional)
   * @param joined Filter by joined status (optional)
   * @param name Filter by queue member name (optional)
   * @param profileSkills Filter by profile skill (optional)
   * @param skills Filter by skill (optional)
   * @param languages Filter by language (optional)
   * @param routingStatus Filter by routing status (optional)
   * @param presence Filter by presence (optional)
   * @return QueueMemberEntityListing
   * @throws ApiException if fails to make API call
   */
  public ApiResponse getQueuesQueueIdUsersWithHttpInfo(String queueId, Integer pageSize, Integer pageNumber, String sortBy, List expand, Boolean joined, String name, List profileSkills, List skills, List languages, List routingStatus, List presence) throws ApiException {
    Object pclocalVarPostBody = null;
    
    // verify the required parameter 'queueId' is set
    if (queueId == null) {
      throw new ApiException(400, "Missing the required parameter 'queueId' when calling getQueuesQueueIdUsers");
    }
    
    // create path and map variables
    String pclocalVarPath = "/api/v2/routing/queues/{queueId}/users".replaceAll("\\{format\\}","json")
      .replaceAll("\\{" + "queueId" + "\\}", pcapiClient.escapeString(queueId.toString()));

    // query params
    List pclocalVarQueryParams = new ArrayList();
    Map pclocalVarHeaderParams = new HashMap();
    Map pclocalVarFormParams = new HashMap();

    pclocalVarQueryParams.addAll(pcapiClient.parameterToPairs("", "pageSize", pageSize));
    pclocalVarQueryParams.addAll(pcapiClient.parameterToPairs("", "pageNumber", pageNumber));
    pclocalVarQueryParams.addAll(pcapiClient.parameterToPairs("", "sortBy", sortBy));
    pclocalVarQueryParams.addAll(pcapiClient.parameterToPairs("multi", "expand", expand));
    pclocalVarQueryParams.addAll(pcapiClient.parameterToPairs("", "joined", joined));
    pclocalVarQueryParams.addAll(pcapiClient.parameterToPairs("", "name", name));
    pclocalVarQueryParams.addAll(pcapiClient.parameterToPairs("multi", "profileSkills", profileSkills));
    pclocalVarQueryParams.addAll(pcapiClient.parameterToPairs("multi", "skills", skills));
    pclocalVarQueryParams.addAll(pcapiClient.parameterToPairs("multi", "languages", languages));
    pclocalVarQueryParams.addAll(pcapiClient.parameterToPairs("multi", "routingStatus", routingStatus));
    pclocalVarQueryParams.addAll(pcapiClient.parameterToPairs("multi", "presence", presence));

    
    
    final String[] pclocalVarAccepts = {
      "application/json"
    };
    final String pclocalVarAccept = pcapiClient.selectHeaderAccept(pclocalVarAccepts);

    final String[] pclocalVarContentTypes = {
      "application/json"
    };
    final String pclocalVarContentType = pcapiClient.selectHeaderContentType(pclocalVarContentTypes);

    String[] pclocalVarAuthNames = new String[] { "PureCloud Auth" };

    return pcapiClient.invokeAPIVerbose(pclocalVarPath, "GET", pclocalVarQueryParams, pclocalVarPostBody, pclocalVarHeaderParams, pclocalVarFormParams, pclocalVarAccept, pclocalVarContentType, pclocalVarAuthNames, new TypeReference() {});
  }
  /**
   * Get the wrap-up codes for a queue
   * 
   * @param queueId Queue ID (required)
   * @return WrapupCodeEntityListing
   * @throws ApiException if fails to make API call
   */
  public WrapupCodeEntityListing getQueuesQueueIdWrapupcodes(String queueId) throws ApiException {
    return getQueuesQueueIdWrapupcodesWithHttpInfo(queueId).getResponseObject();
  }

  /**
   * Get the wrap-up codes for a queue
   * 
   * @param queueId Queue ID (required)
   * @return WrapupCodeEntityListing
   * @throws ApiException if fails to make API call
   */
  public ApiResponse getQueuesQueueIdWrapupcodesWithHttpInfo(String queueId) throws ApiException {
    Object pclocalVarPostBody = null;
    
    // verify the required parameter 'queueId' is set
    if (queueId == null) {
      throw new ApiException(400, "Missing the required parameter 'queueId' when calling getQueuesQueueIdWrapupcodes");
    }
    
    // create path and map variables
    String pclocalVarPath = "/api/v2/routing/queues/{queueId}/wrapupcodes".replaceAll("\\{format\\}","json")
      .replaceAll("\\{" + "queueId" + "\\}", pcapiClient.escapeString(queueId.toString()));

    // query params
    List pclocalVarQueryParams = new ArrayList();
    Map pclocalVarHeaderParams = new HashMap();
    Map pclocalVarFormParams = new HashMap();


    
    
    final String[] pclocalVarAccepts = {
      "application/json"
    };
    final String pclocalVarAccept = pcapiClient.selectHeaderAccept(pclocalVarAccepts);

    final String[] pclocalVarContentTypes = {
      "application/json"
    };
    final String pclocalVarContentType = pcapiClient.selectHeaderContentType(pclocalVarContentTypes);

    String[] pclocalVarAuthNames = new String[] { "PureCloud Auth" };

    return pcapiClient.invokeAPIVerbose(pclocalVarPath, "GET", pclocalVarQueryParams, pclocalVarPostBody, pclocalVarHeaderParams, pclocalVarFormParams, pclocalVarAccept, pclocalVarContentType, pclocalVarAuthNames, new TypeReference() {});
  }
  /**
   * Get the list of routing skills.
   * 
   * @param pageSize Page size (optional, default to 25)
   * @param pageNumber Page number (optional, default to 1)
   * @param name Filter for results that start with this value (optional)
   * @return SkillEntityListing
   * @throws ApiException if fails to make API call
   */
  public SkillEntityListing getSkills(Integer pageSize, Integer pageNumber, String name) throws ApiException {
    return getSkillsWithHttpInfo(pageSize, pageNumber, name).getResponseObject();
  }

  /**
   * Get the list of routing skills.
   * 
   * @param pageSize Page size (optional, default to 25)
   * @param pageNumber Page number (optional, default to 1)
   * @param name Filter for results that start with this value (optional)
   * @return SkillEntityListing
   * @throws ApiException if fails to make API call
   */
  public ApiResponse getSkillsWithHttpInfo(Integer pageSize, Integer pageNumber, String name) throws ApiException {
    Object pclocalVarPostBody = null;
    
    // create path and map variables
    String pclocalVarPath = "/api/v2/routing/skills".replaceAll("\\{format\\}","json");

    // query params
    List pclocalVarQueryParams = new ArrayList();
    Map pclocalVarHeaderParams = new HashMap();
    Map pclocalVarFormParams = new HashMap();

    pclocalVarQueryParams.addAll(pcapiClient.parameterToPairs("", "pageSize", pageSize));
    pclocalVarQueryParams.addAll(pcapiClient.parameterToPairs("", "pageNumber", pageNumber));
    pclocalVarQueryParams.addAll(pcapiClient.parameterToPairs("", "name", name));

    
    
    final String[] pclocalVarAccepts = {
      "application/json"
    };
    final String pclocalVarAccept = pcapiClient.selectHeaderAccept(pclocalVarAccepts);

    final String[] pclocalVarContentTypes = {
      "application/json"
    };
    final String pclocalVarContentType = pcapiClient.selectHeaderContentType(pclocalVarContentTypes);

    String[] pclocalVarAuthNames = new String[] { "PureCloud Auth" };

    return pcapiClient.invokeAPIVerbose(pclocalVarPath, "GET", pclocalVarQueryParams, pclocalVarPostBody, pclocalVarHeaderParams, pclocalVarFormParams, pclocalVarAccept, pclocalVarContentType, pclocalVarAuthNames, new TypeReference() {});
  }
  /**
   * Get Routing Skill
   * 
   * @param skillId Skill ID (required)
   * @return RoutingSkill
   * @throws ApiException if fails to make API call
   */
  public RoutingSkill getSkillsSkillId(String skillId) throws ApiException {
    return getSkillsSkillIdWithHttpInfo(skillId).getResponseObject();
  }

  /**
   * Get Routing Skill
   * 
   * @param skillId Skill ID (required)
   * @return RoutingSkill
   * @throws ApiException if fails to make API call
   */
  public ApiResponse getSkillsSkillIdWithHttpInfo(String skillId) throws ApiException {
    Object pclocalVarPostBody = null;
    
    // verify the required parameter 'skillId' is set
    if (skillId == null) {
      throw new ApiException(400, "Missing the required parameter 'skillId' when calling getSkillsSkillId");
    }
    
    // create path and map variables
    String pclocalVarPath = "/api/v2/routing/skills/{skillId}".replaceAll("\\{format\\}","json")
      .replaceAll("\\{" + "skillId" + "\\}", pcapiClient.escapeString(skillId.toString()));

    // query params
    List pclocalVarQueryParams = new ArrayList();
    Map pclocalVarHeaderParams = new HashMap();
    Map pclocalVarFormParams = new HashMap();


    
    
    final String[] pclocalVarAccepts = {
      "application/json"
    };
    final String pclocalVarAccept = pcapiClient.selectHeaderAccept(pclocalVarAccepts);

    final String[] pclocalVarContentTypes = {
      "application/json"
    };
    final String pclocalVarContentType = pcapiClient.selectHeaderContentType(pclocalVarContentTypes);

    String[] pclocalVarAuthNames = new String[] { "PureCloud Auth" };

    return pcapiClient.invokeAPIVerbose(pclocalVarPath, "GET", pclocalVarQueryParams, pclocalVarPostBody, pclocalVarHeaderParams, pclocalVarFormParams, pclocalVarAccept, pclocalVarContentType, pclocalVarAuthNames, new TypeReference() {});
  }
  /**
   * List routing skills for user
   * 
   * @param userId User ID (required)
   * @param pageSize Page size (optional, default to 25)
   * @param pageNumber Page number (optional, default to 1)
   * @param sortOrder Ascending or descending sort order (optional, default to ASC)
   * @return UserSkillEntityListing
   * @throws ApiException if fails to make API call
   */
  public UserSkillEntityListing getUserIdRoutingskills(String userId, Integer pageSize, Integer pageNumber, String sortOrder) throws ApiException {
    return getUserIdRoutingskillsWithHttpInfo(userId, pageSize, pageNumber, sortOrder).getResponseObject();
  }

  /**
   * List routing skills for user
   * 
   * @param userId User ID (required)
   * @param pageSize Page size (optional, default to 25)
   * @param pageNumber Page number (optional, default to 1)
   * @param sortOrder Ascending or descending sort order (optional, default to ASC)
   * @return UserSkillEntityListing
   * @throws ApiException if fails to make API call
   */
  public ApiResponse getUserIdRoutingskillsWithHttpInfo(String userId, Integer pageSize, Integer pageNumber, String sortOrder) throws ApiException {
    Object pclocalVarPostBody = null;
    
    // verify the required parameter 'userId' is set
    if (userId == null) {
      throw new ApiException(400, "Missing the required parameter 'userId' when calling getUserIdRoutingskills");
    }
    
    // create path and map variables
    String pclocalVarPath = "/api/v2/users/{userId}/routingskills".replaceAll("\\{format\\}","json")
      .replaceAll("\\{" + "userId" + "\\}", pcapiClient.escapeString(userId.toString()));

    // query params
    List pclocalVarQueryParams = new ArrayList();
    Map pclocalVarHeaderParams = new HashMap();
    Map pclocalVarFormParams = new HashMap();

    pclocalVarQueryParams.addAll(pcapiClient.parameterToPairs("", "pageSize", pageSize));
    pclocalVarQueryParams.addAll(pcapiClient.parameterToPairs("", "pageNumber", pageNumber));
    pclocalVarQueryParams.addAll(pcapiClient.parameterToPairs("", "sortOrder", sortOrder));

    
    
    final String[] pclocalVarAccepts = {
      "application/json"
    };
    final String pclocalVarAccept = pcapiClient.selectHeaderAccept(pclocalVarAccepts);

    final String[] pclocalVarContentTypes = {
      "application/json"
    };
    final String pclocalVarContentType = pcapiClient.selectHeaderContentType(pclocalVarContentTypes);

    String[] pclocalVarAuthNames = new String[] { "PureCloud Auth" };

    return pcapiClient.invokeAPIVerbose(pclocalVarPath, "GET", pclocalVarQueryParams, pclocalVarPostBody, pclocalVarHeaderParams, pclocalVarFormParams, pclocalVarAccept, pclocalVarContentType, pclocalVarAuthNames, new TypeReference() {});
  }
  /**
   * Get the utilization settings.
   * 
   * @return Utilization
   * @throws ApiException if fails to make API call
   */
  public Utilization getUtilization() throws ApiException {
    return getUtilizationWithHttpInfo().getResponseObject();
  }

  /**
   * Get the utilization settings.
   * 
   * @return Utilization
   * @throws ApiException if fails to make API call
   */
  public ApiResponse getUtilizationWithHttpInfo() throws ApiException {
    Object pclocalVarPostBody = null;
    
    // create path and map variables
    String pclocalVarPath = "/api/v2/routing/utilization".replaceAll("\\{format\\}","json");

    // query params
    List pclocalVarQueryParams = new ArrayList();
    Map pclocalVarHeaderParams = new HashMap();
    Map pclocalVarFormParams = new HashMap();


    
    
    final String[] pclocalVarAccepts = {
      "application/json"
    };
    final String pclocalVarAccept = pcapiClient.selectHeaderAccept(pclocalVarAccepts);

    final String[] pclocalVarContentTypes = {
      "application/json"
    };
    final String pclocalVarContentType = pcapiClient.selectHeaderContentType(pclocalVarContentTypes);

    String[] pclocalVarAuthNames = new String[] { "PureCloud Auth" };

    return pcapiClient.invokeAPIVerbose(pclocalVarPath, "GET", pclocalVarQueryParams, pclocalVarPostBody, pclocalVarHeaderParams, pclocalVarFormParams, pclocalVarAccept, pclocalVarContentType, pclocalVarAuthNames, new TypeReference() {});
  }
  /**
   * Get list of wrapup codes.
   * 
   * @param pageSize Page size (optional, default to 25)
   * @param pageNumber Page number (optional, default to 1)
   * @param sortBy Sort by (optional, default to name)
   * @return WrapupCodeEntityListing
   * @throws ApiException if fails to make API call
   */
  public WrapupCodeEntityListing getWrapupcodes(Integer pageSize, Integer pageNumber, String sortBy) throws ApiException {
    return getWrapupcodesWithHttpInfo(pageSize, pageNumber, sortBy).getResponseObject();
  }

  /**
   * Get list of wrapup codes.
   * 
   * @param pageSize Page size (optional, default to 25)
   * @param pageNumber Page number (optional, default to 1)
   * @param sortBy Sort by (optional, default to name)
   * @return WrapupCodeEntityListing
   * @throws ApiException if fails to make API call
   */
  public ApiResponse getWrapupcodesWithHttpInfo(Integer pageSize, Integer pageNumber, String sortBy) throws ApiException {
    Object pclocalVarPostBody = null;
    
    // create path and map variables
    String pclocalVarPath = "/api/v2/routing/wrapupcodes".replaceAll("\\{format\\}","json");

    // query params
    List pclocalVarQueryParams = new ArrayList();
    Map pclocalVarHeaderParams = new HashMap();
    Map pclocalVarFormParams = new HashMap();

    pclocalVarQueryParams.addAll(pcapiClient.parameterToPairs("", "pageSize", pageSize));
    pclocalVarQueryParams.addAll(pcapiClient.parameterToPairs("", "pageNumber", pageNumber));
    pclocalVarQueryParams.addAll(pcapiClient.parameterToPairs("", "sortBy", sortBy));

    
    
    final String[] pclocalVarAccepts = {
      "application/json"
    };
    final String pclocalVarAccept = pcapiClient.selectHeaderAccept(pclocalVarAccepts);

    final String[] pclocalVarContentTypes = {
      "application/json"
    };
    final String pclocalVarContentType = pcapiClient.selectHeaderContentType(pclocalVarContentTypes);

    String[] pclocalVarAuthNames = new String[] { "PureCloud Auth" };

    return pcapiClient.invokeAPIVerbose(pclocalVarPath, "GET", pclocalVarQueryParams, pclocalVarPostBody, pclocalVarHeaderParams, pclocalVarFormParams, pclocalVarAccept, pclocalVarContentType, pclocalVarAuthNames, new TypeReference() {});
  }
  /**
   * Get details about this wrap-up code.
   * 
   * @param codeId Wrapup Code ID (required)
   * @return WrapupCode
   * @throws ApiException if fails to make API call
   */
  public WrapupCode getWrapupcodesCodeId(String codeId) throws ApiException {
    return getWrapupcodesCodeIdWithHttpInfo(codeId).getResponseObject();
  }

  /**
   * Get details about this wrap-up code.
   * 
   * @param codeId Wrapup Code ID (required)
   * @return WrapupCode
   * @throws ApiException if fails to make API call
   */
  public ApiResponse getWrapupcodesCodeIdWithHttpInfo(String codeId) throws ApiException {
    Object pclocalVarPostBody = null;
    
    // verify the required parameter 'codeId' is set
    if (codeId == null) {
      throw new ApiException(400, "Missing the required parameter 'codeId' when calling getWrapupcodesCodeId");
    }
    
    // create path and map variables
    String pclocalVarPath = "/api/v2/routing/wrapupcodes/{codeId}".replaceAll("\\{format\\}","json")
      .replaceAll("\\{" + "codeId" + "\\}", pcapiClient.escapeString(codeId.toString()));

    // query params
    List pclocalVarQueryParams = new ArrayList();
    Map pclocalVarHeaderParams = new HashMap();
    Map pclocalVarFormParams = new HashMap();


    
    
    final String[] pclocalVarAccepts = {
      "application/json"
    };
    final String pclocalVarAccept = pcapiClient.selectHeaderAccept(pclocalVarAccepts);

    final String[] pclocalVarContentTypes = {
      "application/json"
    };
    final String pclocalVarContentType = pcapiClient.selectHeaderContentType(pclocalVarContentTypes);

    String[] pclocalVarAuthNames = new String[] { "PureCloud Auth" };

    return pcapiClient.invokeAPIVerbose(pclocalVarPath, "GET", pclocalVarQueryParams, pclocalVarPostBody, pclocalVarHeaderParams, pclocalVarFormParams, pclocalVarAccept, pclocalVarContentType, pclocalVarAuthNames, new TypeReference() {});
  }
  /**
   * Join or unjoin a set of users for a queue
   * 
   * @param queueId Queue ID (required)
   * @param body Queue Members (required)
   * @return QueueMemberEntityListing
   * @throws ApiException if fails to make API call
   */
  public QueueMemberEntityListing patchQueuesQueueIdUsers(String queueId, List body) throws ApiException {
    return patchQueuesQueueIdUsersWithHttpInfo(queueId, body).getResponseObject();
  }

  /**
   * Join or unjoin a set of users for a queue
   * 
   * @param queueId Queue ID (required)
   * @param body Queue Members (required)
   * @return QueueMemberEntityListing
   * @throws ApiException if fails to make API call
   */
  public ApiResponse patchQueuesQueueIdUsersWithHttpInfo(String queueId, List body) throws ApiException {
    Object pclocalVarPostBody = body;
    
    // verify the required parameter 'queueId' is set
    if (queueId == null) {
      throw new ApiException(400, "Missing the required parameter 'queueId' when calling patchQueuesQueueIdUsers");
    }
    
    // verify the required parameter 'body' is set
    if (body == null) {
      throw new ApiException(400, "Missing the required parameter 'body' when calling patchQueuesQueueIdUsers");
    }
    
    // create path and map variables
    String pclocalVarPath = "/api/v2/routing/queues/{queueId}/users".replaceAll("\\{format\\}","json")
      .replaceAll("\\{" + "queueId" + "\\}", pcapiClient.escapeString(queueId.toString()));

    // query params
    List pclocalVarQueryParams = new ArrayList();
    Map pclocalVarHeaderParams = new HashMap();
    Map pclocalVarFormParams = new HashMap();


    
    
    final String[] pclocalVarAccepts = {
      "application/json"
    };
    final String pclocalVarAccept = pcapiClient.selectHeaderAccept(pclocalVarAccepts);

    final String[] pclocalVarContentTypes = {
      "application/json"
    };
    final String pclocalVarContentType = pcapiClient.selectHeaderContentType(pclocalVarContentTypes);

    String[] pclocalVarAuthNames = new String[] { "PureCloud Auth" };

    return pcapiClient.invokeAPIVerbose(pclocalVarPath, "PATCH", pclocalVarQueryParams, pclocalVarPostBody, pclocalVarHeaderParams, pclocalVarFormParams, pclocalVarAccept, pclocalVarContentType, pclocalVarAuthNames, new TypeReference() {});
  }
  /**
   * Update the ring number of joined status for a User in a Queue
   * 
   * @param queueId Queue ID (required)
   * @param memberId Member ID (required)
   * @param body Queue Member (required)
   * @return QueueMember
   * @throws ApiException if fails to make API call
   */
  public QueueMember patchQueuesQueueIdUsersMemberId(String queueId, String memberId, QueueMember body) throws ApiException {
    return patchQueuesQueueIdUsersMemberIdWithHttpInfo(queueId, memberId, body).getResponseObject();
  }

  /**
   * Update the ring number of joined status for a User in a Queue
   * 
   * @param queueId Queue ID (required)
   * @param memberId Member ID (required)
   * @param body Queue Member (required)
   * @return QueueMember
   * @throws ApiException if fails to make API call
   */
  public ApiResponse patchQueuesQueueIdUsersMemberIdWithHttpInfo(String queueId, String memberId, QueueMember body) throws ApiException {
    Object pclocalVarPostBody = body;
    
    // verify the required parameter 'queueId' is set
    if (queueId == null) {
      throw new ApiException(400, "Missing the required parameter 'queueId' when calling patchQueuesQueueIdUsersMemberId");
    }
    
    // verify the required parameter 'memberId' is set
    if (memberId == null) {
      throw new ApiException(400, "Missing the required parameter 'memberId' when calling patchQueuesQueueIdUsersMemberId");
    }
    
    // verify the required parameter 'body' is set
    if (body == null) {
      throw new ApiException(400, "Missing the required parameter 'body' when calling patchQueuesQueueIdUsersMemberId");
    }
    
    // create path and map variables
    String pclocalVarPath = "/api/v2/routing/queues/{queueId}/users/{memberId}".replaceAll("\\{format\\}","json")
      .replaceAll("\\{" + "queueId" + "\\}", pcapiClient.escapeString(queueId.toString()))
      .replaceAll("\\{" + "memberId" + "\\}", pcapiClient.escapeString(memberId.toString()));

    // query params
    List pclocalVarQueryParams = new ArrayList();
    Map pclocalVarHeaderParams = new HashMap();
    Map pclocalVarFormParams = new HashMap();


    
    
    final String[] pclocalVarAccepts = {
      "application/json"
    };
    final String pclocalVarAccept = pcapiClient.selectHeaderAccept(pclocalVarAccepts);

    final String[] pclocalVarContentTypes = {
      "application/json"
    };
    final String pclocalVarContentType = pcapiClient.selectHeaderContentType(pclocalVarContentTypes);

    String[] pclocalVarAuthNames = new String[] { "PureCloud Auth" };

    return pcapiClient.invokeAPIVerbose(pclocalVarPath, "PATCH", pclocalVarQueryParams, pclocalVarPostBody, pclocalVarHeaderParams, pclocalVarFormParams, pclocalVarAccept, pclocalVarContentType, pclocalVarAuthNames, new TypeReference() {});
  }
  /**
   * Create a domain
   * 
   * @param body Domain (required)
   * @return InboundDomain
   * @throws ApiException if fails to make API call
   */
  public InboundDomain postEmailDomains(InboundDomain body) throws ApiException {
    return postEmailDomainsWithHttpInfo(body).getResponseObject();
  }

  /**
   * Create a domain
   * 
   * @param body Domain (required)
   * @return InboundDomain
   * @throws ApiException if fails to make API call
   */
  public ApiResponse postEmailDomainsWithHttpInfo(InboundDomain body) throws ApiException {
    Object pclocalVarPostBody = body;
    
    // verify the required parameter 'body' is set
    if (body == null) {
      throw new ApiException(400, "Missing the required parameter 'body' when calling postEmailDomains");
    }
    
    // create path and map variables
    String pclocalVarPath = "/api/v2/routing/email/domains".replaceAll("\\{format\\}","json");

    // query params
    List pclocalVarQueryParams = new ArrayList();
    Map pclocalVarHeaderParams = new HashMap();
    Map pclocalVarFormParams = new HashMap();


    
    
    final String[] pclocalVarAccepts = {
      "application/json"
    };
    final String pclocalVarAccept = pcapiClient.selectHeaderAccept(pclocalVarAccepts);

    final String[] pclocalVarContentTypes = {
      "application/json"
    };
    final String pclocalVarContentType = pcapiClient.selectHeaderContentType(pclocalVarContentTypes);

    String[] pclocalVarAuthNames = new String[] { "PureCloud Auth" };

    return pcapiClient.invokeAPIVerbose(pclocalVarPath, "POST", pclocalVarQueryParams, pclocalVarPostBody, pclocalVarHeaderParams, pclocalVarFormParams, pclocalVarAccept, pclocalVarContentType, pclocalVarAuthNames, new TypeReference() {});
  }
  /**
   * Create a route
   * 
   * @param domainName email domain (required)
   * @param body Route (required)
   * @return InboundRoute
   * @throws ApiException if fails to make API call
   */
  public InboundRoute postEmailDomainsDomainnameRoutes(String domainName, InboundRoute body) throws ApiException {
    return postEmailDomainsDomainnameRoutesWithHttpInfo(domainName, body).getResponseObject();
  }

  /**
   * Create a route
   * 
   * @param domainName email domain (required)
   * @param body Route (required)
   * @return InboundRoute
   * @throws ApiException if fails to make API call
   */
  public ApiResponse postEmailDomainsDomainnameRoutesWithHttpInfo(String domainName, InboundRoute body) throws ApiException {
    Object pclocalVarPostBody = body;
    
    // verify the required parameter 'domainName' is set
    if (domainName == null) {
      throw new ApiException(400, "Missing the required parameter 'domainName' when calling postEmailDomainsDomainnameRoutes");
    }
    
    // verify the required parameter 'body' is set
    if (body == null) {
      throw new ApiException(400, "Missing the required parameter 'body' when calling postEmailDomainsDomainnameRoutes");
    }
    
    // create path and map variables
    String pclocalVarPath = "/api/v2/routing/email/domains/{domainName}/routes".replaceAll("\\{format\\}","json")
      .replaceAll("\\{" + "domainName" + "\\}", pcapiClient.escapeString(domainName.toString()));

    // query params
    List pclocalVarQueryParams = new ArrayList();
    Map pclocalVarHeaderParams = new HashMap();
    Map pclocalVarFormParams = new HashMap();


    
    
    final String[] pclocalVarAccepts = {
      "application/json"
    };
    final String pclocalVarAccept = pcapiClient.selectHeaderAccept(pclocalVarAccepts);

    final String[] pclocalVarContentTypes = {
      "application/json"
    };
    final String pclocalVarContentType = pcapiClient.selectHeaderContentType(pclocalVarContentTypes);

    String[] pclocalVarAuthNames = new String[] { "PureCloud Auth" };

    return pcapiClient.invokeAPIVerbose(pclocalVarPath, "POST", pclocalVarQueryParams, pclocalVarPostBody, pclocalVarHeaderParams, pclocalVarFormParams, pclocalVarAccept, pclocalVarContentType, pclocalVarAuthNames, new TypeReference() {});
  }
  /**
   * Create Language
   * 
   * @param body Language (required)
   * @return Language
   * @throws ApiException if fails to make API call
   */
  public Language postLanguages(Language body) throws ApiException {
    return postLanguagesWithHttpInfo(body).getResponseObject();
  }

  /**
   * Create Language
   * 
   * @param body Language (required)
   * @return Language
   * @throws ApiException if fails to make API call
   */
  public ApiResponse postLanguagesWithHttpInfo(Language body) throws ApiException {
    Object pclocalVarPostBody = body;
    
    // verify the required parameter 'body' is set
    if (body == null) {
      throw new ApiException(400, "Missing the required parameter 'body' when calling postLanguages");
    }
    
    // create path and map variables
    String pclocalVarPath = "/api/v2/routing/languages".replaceAll("\\{format\\}","json");

    // query params
    List pclocalVarQueryParams = new ArrayList();
    Map pclocalVarHeaderParams = new HashMap();
    Map pclocalVarFormParams = new HashMap();


    
    
    final String[] pclocalVarAccepts = {
      "application/json"
    };
    final String pclocalVarAccept = pcapiClient.selectHeaderAccept(pclocalVarAccepts);

    final String[] pclocalVarContentTypes = {
      "application/json"
    };
    final String pclocalVarContentType = pcapiClient.selectHeaderContentType(pclocalVarContentTypes);

    String[] pclocalVarAuthNames = new String[] { "PureCloud Auth" };

    return pcapiClient.invokeAPIVerbose(pclocalVarPath, "POST", pclocalVarQueryParams, pclocalVarPostBody, pclocalVarHeaderParams, pclocalVarFormParams, pclocalVarAccept, pclocalVarContentType, pclocalVarAuthNames, new TypeReference() {});
  }
  /**
   * Create queue
   * 
   * @param body Queue (required)
   * @return Queue
   * @throws ApiException if fails to make API call
   */
  public Queue postQueues(CreateQueueRequest body) throws ApiException {
    return postQueuesWithHttpInfo(body).getResponseObject();
  }

  /**
   * Create queue
   * 
   * @param body Queue (required)
   * @return Queue
   * @throws ApiException if fails to make API call
   */
  public ApiResponse postQueuesWithHttpInfo(CreateQueueRequest body) throws ApiException {
    Object pclocalVarPostBody = body;
    
    // verify the required parameter 'body' is set
    if (body == null) {
      throw new ApiException(400, "Missing the required parameter 'body' when calling postQueues");
    }
    
    // create path and map variables
    String pclocalVarPath = "/api/v2/routing/queues".replaceAll("\\{format\\}","json");

    // query params
    List pclocalVarQueryParams = new ArrayList();
    Map pclocalVarHeaderParams = new HashMap();
    Map pclocalVarFormParams = new HashMap();


    
    
    final String[] pclocalVarAccepts = {
      "application/json"
    };
    final String pclocalVarAccept = pcapiClient.selectHeaderAccept(pclocalVarAccepts);

    final String[] pclocalVarContentTypes = {
      "application/json"
    };
    final String pclocalVarContentType = pcapiClient.selectHeaderContentType(pclocalVarContentTypes);

    String[] pclocalVarAuthNames = new String[] { "PureCloud Auth" };

    return pcapiClient.invokeAPIVerbose(pclocalVarPath, "POST", pclocalVarQueryParams, pclocalVarPostBody, pclocalVarHeaderParams, pclocalVarFormParams, pclocalVarAccept, pclocalVarContentType, pclocalVarAuthNames, new TypeReference() {});
  }
  /**
   * Query for queue observations
   * 
   * @param body query (required)
   * @return QualifierMappingObservationQueryResponse
   * @throws ApiException if fails to make API call
   */
  public QualifierMappingObservationQueryResponse postQueuesObservationsQuery(ObservationQuery body) throws ApiException {
    return postQueuesObservationsQueryWithHttpInfo(body).getResponseObject();
  }

  /**
   * Query for queue observations
   * 
   * @param body query (required)
   * @return QualifierMappingObservationQueryResponse
   * @throws ApiException if fails to make API call
   */
  public ApiResponse postQueuesObservationsQueryWithHttpInfo(ObservationQuery body) throws ApiException {
    Object pclocalVarPostBody = body;
    
    // verify the required parameter 'body' is set
    if (body == null) {
      throw new ApiException(400, "Missing the required parameter 'body' when calling postQueuesObservationsQuery");
    }
    
    // create path and map variables
    String pclocalVarPath = "/api/v2/analytics/queues/observations/query".replaceAll("\\{format\\}","json");

    // query params
    List pclocalVarQueryParams = new ArrayList();
    Map pclocalVarHeaderParams = new HashMap();
    Map pclocalVarFormParams = new HashMap();


    
    
    final String[] pclocalVarAccepts = {
      "application/json"
    };
    final String pclocalVarAccept = pcapiClient.selectHeaderAccept(pclocalVarAccepts);

    final String[] pclocalVarContentTypes = {
      "application/json"
    };
    final String pclocalVarContentType = pcapiClient.selectHeaderContentType(pclocalVarContentTypes);

    String[] pclocalVarAuthNames = new String[] { "PureCloud Auth" };

    return pcapiClient.invokeAPIVerbose(pclocalVarPath, "POST", pclocalVarQueryParams, pclocalVarPostBody, pclocalVarHeaderParams, pclocalVarFormParams, pclocalVarAccept, pclocalVarContentType, pclocalVarAuthNames, new TypeReference() {});
  }
  /**
   * Bulk add or delete up to 100 queue members
   * 
   * @param queueId Queue ID (required)
   * @param body Queue Members (required)
   * @param delete True to delete queue members (optional, default to false)
   * @return String
   * @throws ApiException if fails to make API call
   */
  public String postQueuesQueueIdUsers(String queueId, List body, Boolean delete) throws ApiException {
    return postQueuesQueueIdUsersWithHttpInfo(queueId, body, delete).getResponseObject();
  }

  /**
   * Bulk add or delete up to 100 queue members
   * 
   * @param queueId Queue ID (required)
   * @param body Queue Members (required)
   * @param delete True to delete queue members (optional, default to false)
   * @return String
   * @throws ApiException if fails to make API call
   */
  public ApiResponse postQueuesQueueIdUsersWithHttpInfo(String queueId, List body, Boolean delete) throws ApiException {
    Object pclocalVarPostBody = body;
    
    // verify the required parameter 'queueId' is set
    if (queueId == null) {
      throw new ApiException(400, "Missing the required parameter 'queueId' when calling postQueuesQueueIdUsers");
    }
    
    // verify the required parameter 'body' is set
    if (body == null) {
      throw new ApiException(400, "Missing the required parameter 'body' when calling postQueuesQueueIdUsers");
    }
    
    // create path and map variables
    String pclocalVarPath = "/api/v2/routing/queues/{queueId}/users".replaceAll("\\{format\\}","json")
      .replaceAll("\\{" + "queueId" + "\\}", pcapiClient.escapeString(queueId.toString()));

    // query params
    List pclocalVarQueryParams = new ArrayList();
    Map pclocalVarHeaderParams = new HashMap();
    Map pclocalVarFormParams = new HashMap();

    pclocalVarQueryParams.addAll(pcapiClient.parameterToPairs("", "delete", delete));

    
    
    final String[] pclocalVarAccepts = {
      "application/json"
    };
    final String pclocalVarAccept = pcapiClient.selectHeaderAccept(pclocalVarAccepts);

    final String[] pclocalVarContentTypes = {
      "application/json"
    };
    final String pclocalVarContentType = pcapiClient.selectHeaderContentType(pclocalVarContentTypes);

    String[] pclocalVarAuthNames = new String[] { "PureCloud Auth" };

    return pcapiClient.invokeAPIVerbose(pclocalVarPath, "POST", pclocalVarQueryParams, pclocalVarPostBody, pclocalVarHeaderParams, pclocalVarFormParams, pclocalVarAccept, pclocalVarContentType, pclocalVarAuthNames, new TypeReference() {});
  }
  /**
   * Add up to 100 wrap-up codes to a queue
   * 
   * @param queueId Queue ID (required)
   * @param body List of wrapup codes (required)
   * @return List
   * @throws ApiException if fails to make API call
   */
  public List postQueuesQueueIdWrapupcodes(String queueId, List body) throws ApiException {
    return postQueuesQueueIdWrapupcodesWithHttpInfo(queueId, body).getResponseObject();
  }

  /**
   * Add up to 100 wrap-up codes to a queue
   * 
   * @param queueId Queue ID (required)
   * @param body List of wrapup codes (required)
   * @return List
   * @throws ApiException if fails to make API call
   */
  public ApiResponse> postQueuesQueueIdWrapupcodesWithHttpInfo(String queueId, List body) throws ApiException {
    Object pclocalVarPostBody = body;
    
    // verify the required parameter 'queueId' is set
    if (queueId == null) {
      throw new ApiException(400, "Missing the required parameter 'queueId' when calling postQueuesQueueIdWrapupcodes");
    }
    
    // verify the required parameter 'body' is set
    if (body == null) {
      throw new ApiException(400, "Missing the required parameter 'body' when calling postQueuesQueueIdWrapupcodes");
    }
    
    // create path and map variables
    String pclocalVarPath = "/api/v2/routing/queues/{queueId}/wrapupcodes".replaceAll("\\{format\\}","json")
      .replaceAll("\\{" + "queueId" + "\\}", pcapiClient.escapeString(queueId.toString()));

    // query params
    List pclocalVarQueryParams = new ArrayList();
    Map pclocalVarHeaderParams = new HashMap();
    Map pclocalVarFormParams = new HashMap();


    
    
    final String[] pclocalVarAccepts = {
      "application/json"
    };
    final String pclocalVarAccept = pcapiClient.selectHeaderAccept(pclocalVarAccepts);

    final String[] pclocalVarContentTypes = {
      "application/json"
    };
    final String pclocalVarContentType = pcapiClient.selectHeaderContentType(pclocalVarContentTypes);

    String[] pclocalVarAuthNames = new String[] { "PureCloud Auth" };

    return pcapiClient.invokeAPIVerbose(pclocalVarPath, "POST", pclocalVarQueryParams, pclocalVarPostBody, pclocalVarHeaderParams, pclocalVarFormParams, pclocalVarAccept, pclocalVarContentType, pclocalVarAuthNames, new TypeReference>() {});
  }
  /**
   * Create Skill
   * 
   * @param body Skill (required)
   * @return RoutingSkill
   * @throws ApiException if fails to make API call
   */
  public RoutingSkill postSkills(RoutingSkill body) throws ApiException {
    return postSkillsWithHttpInfo(body).getResponseObject();
  }

  /**
   * Create Skill
   * 
   * @param body Skill (required)
   * @return RoutingSkill
   * @throws ApiException if fails to make API call
   */
  public ApiResponse postSkillsWithHttpInfo(RoutingSkill body) throws ApiException {
    Object pclocalVarPostBody = body;
    
    // verify the required parameter 'body' is set
    if (body == null) {
      throw new ApiException(400, "Missing the required parameter 'body' when calling postSkills");
    }
    
    // create path and map variables
    String pclocalVarPath = "/api/v2/routing/skills".replaceAll("\\{format\\}","json");

    // query params
    List pclocalVarQueryParams = new ArrayList();
    Map pclocalVarHeaderParams = new HashMap();
    Map pclocalVarFormParams = new HashMap();


    
    
    final String[] pclocalVarAccepts = {
      "application/json"
    };
    final String pclocalVarAccept = pcapiClient.selectHeaderAccept(pclocalVarAccepts);

    final String[] pclocalVarContentTypes = {
      "application/json"
    };
    final String pclocalVarContentType = pcapiClient.selectHeaderContentType(pclocalVarContentTypes);

    String[] pclocalVarAuthNames = new String[] { "PureCloud Auth" };

    return pcapiClient.invokeAPIVerbose(pclocalVarPath, "POST", pclocalVarQueryParams, pclocalVarPostBody, pclocalVarHeaderParams, pclocalVarFormParams, pclocalVarAccept, pclocalVarContentType, pclocalVarAuthNames, new TypeReference() {});
  }
  /**
   * Add routing skill to user
   * 
   * @param userId User ID (required)
   * @param body Skill (required)
   * @return UserRoutingSkill
   * @throws ApiException if fails to make API call
   */
  public UserRoutingSkill postUserIdRoutingskills(String userId, UserRoutingSkillPost body) throws ApiException {
    return postUserIdRoutingskillsWithHttpInfo(userId, body).getResponseObject();
  }

  /**
   * Add routing skill to user
   * 
   * @param userId User ID (required)
   * @param body Skill (required)
   * @return UserRoutingSkill
   * @throws ApiException if fails to make API call
   */
  public ApiResponse postUserIdRoutingskillsWithHttpInfo(String userId, UserRoutingSkillPost body) throws ApiException {
    Object pclocalVarPostBody = body;
    
    // verify the required parameter 'userId' is set
    if (userId == null) {
      throw new ApiException(400, "Missing the required parameter 'userId' when calling postUserIdRoutingskills");
    }
    
    // verify the required parameter 'body' is set
    if (body == null) {
      throw new ApiException(400, "Missing the required parameter 'body' when calling postUserIdRoutingskills");
    }
    
    // create path and map variables
    String pclocalVarPath = "/api/v2/users/{userId}/routingskills".replaceAll("\\{format\\}","json")
      .replaceAll("\\{" + "userId" + "\\}", pcapiClient.escapeString(userId.toString()));

    // query params
    List pclocalVarQueryParams = new ArrayList();
    Map pclocalVarHeaderParams = new HashMap();
    Map pclocalVarFormParams = new HashMap();


    
    
    final String[] pclocalVarAccepts = {
      "application/json"
    };
    final String pclocalVarAccept = pcapiClient.selectHeaderAccept(pclocalVarAccepts);

    final String[] pclocalVarContentTypes = {
      "application/json"
    };
    final String pclocalVarContentType = pcapiClient.selectHeaderContentType(pclocalVarContentTypes);

    String[] pclocalVarAuthNames = new String[] { "PureCloud Auth" };

    return pcapiClient.invokeAPIVerbose(pclocalVarPath, "POST", pclocalVarQueryParams, pclocalVarPostBody, pclocalVarHeaderParams, pclocalVarFormParams, pclocalVarAccept, pclocalVarContentType, pclocalVarAuthNames, new TypeReference() {});
  }
  /**
   * Create a wrap-up code
   * 
   * @param body WrapupCode (required)
   * @return WrapupCode
   * @throws ApiException if fails to make API call
   */
  public WrapupCode postWrapupcodes(WrapupCode body) throws ApiException {
    return postWrapupcodesWithHttpInfo(body).getResponseObject();
  }

  /**
   * Create a wrap-up code
   * 
   * @param body WrapupCode (required)
   * @return WrapupCode
   * @throws ApiException if fails to make API call
   */
  public ApiResponse postWrapupcodesWithHttpInfo(WrapupCode body) throws ApiException {
    Object pclocalVarPostBody = body;
    
    // verify the required parameter 'body' is set
    if (body == null) {
      throw new ApiException(400, "Missing the required parameter 'body' when calling postWrapupcodes");
    }
    
    // create path and map variables
    String pclocalVarPath = "/api/v2/routing/wrapupcodes".replaceAll("\\{format\\}","json");

    // query params
    List pclocalVarQueryParams = new ArrayList();
    Map pclocalVarHeaderParams = new HashMap();
    Map pclocalVarFormParams = new HashMap();


    
    
    final String[] pclocalVarAccepts = {
      "application/json"
    };
    final String pclocalVarAccept = pcapiClient.selectHeaderAccept(pclocalVarAccepts);

    final String[] pclocalVarContentTypes = {
      "application/json"
    };
    final String pclocalVarContentType = pcapiClient.selectHeaderContentType(pclocalVarContentTypes);

    String[] pclocalVarAuthNames = new String[] { "PureCloud Auth" };

    return pcapiClient.invokeAPIVerbose(pclocalVarPath, "POST", pclocalVarQueryParams, pclocalVarPostBody, pclocalVarHeaderParams, pclocalVarFormParams, pclocalVarAccept, pclocalVarContentType, pclocalVarAuthNames, new TypeReference() {});
  }
  /**
   * Update a route
   * 
   * @param domainName email domain (required)
   * @param routeId route ID (required)
   * @param body Route (required)
   * @return InboundRoute
   * @throws ApiException if fails to make API call
   */
  public InboundRoute putEmailDomainsDomainnameRoutesRouteId(String domainName, String routeId, InboundRoute body) throws ApiException {
    return putEmailDomainsDomainnameRoutesRouteIdWithHttpInfo(domainName, routeId, body).getResponseObject();
  }

  /**
   * Update a route
   * 
   * @param domainName email domain (required)
   * @param routeId route ID (required)
   * @param body Route (required)
   * @return InboundRoute
   * @throws ApiException if fails to make API call
   */
  public ApiResponse putEmailDomainsDomainnameRoutesRouteIdWithHttpInfo(String domainName, String routeId, InboundRoute body) throws ApiException {
    Object pclocalVarPostBody = body;
    
    // verify the required parameter 'domainName' is set
    if (domainName == null) {
      throw new ApiException(400, "Missing the required parameter 'domainName' when calling putEmailDomainsDomainnameRoutesRouteId");
    }
    
    // verify the required parameter 'routeId' is set
    if (routeId == null) {
      throw new ApiException(400, "Missing the required parameter 'routeId' when calling putEmailDomainsDomainnameRoutesRouteId");
    }
    
    // verify the required parameter 'body' is set
    if (body == null) {
      throw new ApiException(400, "Missing the required parameter 'body' when calling putEmailDomainsDomainnameRoutesRouteId");
    }
    
    // create path and map variables
    String pclocalVarPath = "/api/v2/routing/email/domains/{domainName}/routes/{routeId}".replaceAll("\\{format\\}","json")
      .replaceAll("\\{" + "domainName" + "\\}", pcapiClient.escapeString(domainName.toString()))
      .replaceAll("\\{" + "routeId" + "\\}", pcapiClient.escapeString(routeId.toString()));

    // query params
    List pclocalVarQueryParams = new ArrayList();
    Map pclocalVarHeaderParams = new HashMap();
    Map pclocalVarFormParams = new HashMap();


    
    
    final String[] pclocalVarAccepts = {
      "application/json"
    };
    final String pclocalVarAccept = pcapiClient.selectHeaderAccept(pclocalVarAccepts);

    final String[] pclocalVarContentTypes = {
      "application/json"
    };
    final String pclocalVarContentType = pcapiClient.selectHeaderContentType(pclocalVarContentTypes);

    String[] pclocalVarAuthNames = new String[] { "PureCloud Auth" };

    return pcapiClient.invokeAPIVerbose(pclocalVarPath, "PUT", pclocalVarQueryParams, pclocalVarPostBody, pclocalVarHeaderParams, pclocalVarFormParams, pclocalVarAccept, pclocalVarContentType, pclocalVarAuthNames, new TypeReference() {});
  }
  /**
   * Update a queue
   * 
   * @param queueId Queue ID (required)
   * @param body Queue (required)
   * @return Queue
   * @throws ApiException if fails to make API call
   */
  public Queue putQueuesQueueId(String queueId, Queue body) throws ApiException {
    return putQueuesQueueIdWithHttpInfo(queueId, body).getResponseObject();
  }

  /**
   * Update a queue
   * 
   * @param queueId Queue ID (required)
   * @param body Queue (required)
   * @return Queue
   * @throws ApiException if fails to make API call
   */
  public ApiResponse putQueuesQueueIdWithHttpInfo(String queueId, Queue body) throws ApiException {
    Object pclocalVarPostBody = body;
    
    // verify the required parameter 'queueId' is set
    if (queueId == null) {
      throw new ApiException(400, "Missing the required parameter 'queueId' when calling putQueuesQueueId");
    }
    
    // verify the required parameter 'body' is set
    if (body == null) {
      throw new ApiException(400, "Missing the required parameter 'body' when calling putQueuesQueueId");
    }
    
    // create path and map variables
    String pclocalVarPath = "/api/v2/routing/queues/{queueId}".replaceAll("\\{format\\}","json")
      .replaceAll("\\{" + "queueId" + "\\}", pcapiClient.escapeString(queueId.toString()));

    // query params
    List pclocalVarQueryParams = new ArrayList();
    Map pclocalVarHeaderParams = new HashMap();
    Map pclocalVarFormParams = new HashMap();


    
    
    final String[] pclocalVarAccepts = {
      "application/json"
    };
    final String pclocalVarAccept = pcapiClient.selectHeaderAccept(pclocalVarAccepts);

    final String[] pclocalVarContentTypes = {
      "application/json"
    };
    final String pclocalVarContentType = pcapiClient.selectHeaderContentType(pclocalVarContentTypes);

    String[] pclocalVarAuthNames = new String[] { "PureCloud Auth" };

    return pcapiClient.invokeAPIVerbose(pclocalVarPath, "PUT", pclocalVarQueryParams, pclocalVarPostBody, pclocalVarHeaderParams, pclocalVarFormParams, pclocalVarAccept, pclocalVarContentType, pclocalVarAuthNames, new TypeReference() {});
  }
  /**
   * Update routing skill proficiency or state.
   * 
   * @param userId User ID (required)
   * @param skillId skillId (required)
   * @param body Skill (required)
   * @return UserRoutingSkill
   * @throws ApiException if fails to make API call
   */
  public UserRoutingSkill putUserIdRoutingskillsSkillId(String userId, String skillId, UserRoutingSkill body) throws ApiException {
    return putUserIdRoutingskillsSkillIdWithHttpInfo(userId, skillId, body).getResponseObject();
  }

  /**
   * Update routing skill proficiency or state.
   * 
   * @param userId User ID (required)
   * @param skillId skillId (required)
   * @param body Skill (required)
   * @return UserRoutingSkill
   * @throws ApiException if fails to make API call
   */
  public ApiResponse putUserIdRoutingskillsSkillIdWithHttpInfo(String userId, String skillId, UserRoutingSkill body) throws ApiException {
    Object pclocalVarPostBody = body;
    
    // verify the required parameter 'userId' is set
    if (userId == null) {
      throw new ApiException(400, "Missing the required parameter 'userId' when calling putUserIdRoutingskillsSkillId");
    }
    
    // verify the required parameter 'skillId' is set
    if (skillId == null) {
      throw new ApiException(400, "Missing the required parameter 'skillId' when calling putUserIdRoutingskillsSkillId");
    }
    
    // verify the required parameter 'body' is set
    if (body == null) {
      throw new ApiException(400, "Missing the required parameter 'body' when calling putUserIdRoutingskillsSkillId");
    }
    
    // create path and map variables
    String pclocalVarPath = "/api/v2/users/{userId}/routingskills/{skillId}".replaceAll("\\{format\\}","json")
      .replaceAll("\\{" + "userId" + "\\}", pcapiClient.escapeString(userId.toString()))
      .replaceAll("\\{" + "skillId" + "\\}", pcapiClient.escapeString(skillId.toString()));

    // query params
    List pclocalVarQueryParams = new ArrayList();
    Map pclocalVarHeaderParams = new HashMap();
    Map pclocalVarFormParams = new HashMap();


    
    
    final String[] pclocalVarAccepts = {
      "application/json"
    };
    final String pclocalVarAccept = pcapiClient.selectHeaderAccept(pclocalVarAccepts);

    final String[] pclocalVarContentTypes = {
      "application/json"
    };
    final String pclocalVarContentType = pcapiClient.selectHeaderContentType(pclocalVarContentTypes);

    String[] pclocalVarAuthNames = new String[] { "PureCloud Auth" };

    return pcapiClient.invokeAPIVerbose(pclocalVarPath, "PUT", pclocalVarQueryParams, pclocalVarPostBody, pclocalVarHeaderParams, pclocalVarFormParams, pclocalVarAccept, pclocalVarContentType, pclocalVarAuthNames, new TypeReference() {});
  }
  /**
   * Update the utilization settings.
   * 
   * @param body utilization (required)
   * @return Utilization
   * @throws ApiException if fails to make API call
   */
  public Utilization putUtilization(Utilization body) throws ApiException {
    return putUtilizationWithHttpInfo(body).getResponseObject();
  }

  /**
   * Update the utilization settings.
   * 
   * @param body utilization (required)
   * @return Utilization
   * @throws ApiException if fails to make API call
   */
  public ApiResponse putUtilizationWithHttpInfo(Utilization body) throws ApiException {
    Object pclocalVarPostBody = body;
    
    // verify the required parameter 'body' is set
    if (body == null) {
      throw new ApiException(400, "Missing the required parameter 'body' when calling putUtilization");
    }
    
    // create path and map variables
    String pclocalVarPath = "/api/v2/routing/utilization".replaceAll("\\{format\\}","json");

    // query params
    List pclocalVarQueryParams = new ArrayList();
    Map pclocalVarHeaderParams = new HashMap();
    Map pclocalVarFormParams = new HashMap();


    
    
    final String[] pclocalVarAccepts = {
      "application/json"
    };
    final String pclocalVarAccept = pcapiClient.selectHeaderAccept(pclocalVarAccepts);

    final String[] pclocalVarContentTypes = {
      "application/json"
    };
    final String pclocalVarContentType = pcapiClient.selectHeaderContentType(pclocalVarContentTypes);

    String[] pclocalVarAuthNames = new String[] { "PureCloud Auth" };

    return pcapiClient.invokeAPIVerbose(pclocalVarPath, "PUT", pclocalVarQueryParams, pclocalVarPostBody, pclocalVarHeaderParams, pclocalVarFormParams, pclocalVarAccept, pclocalVarContentType, pclocalVarAuthNames, new TypeReference() {});
  }
  /**
   * Update wrap-up code
   * 
   * @param codeId Wrapup Code ID (required)
   * @param body WrapupCode (required)
   * @return WrapupCode
   * @throws ApiException if fails to make API call
   */
  public WrapupCode putWrapupcodesCodeId(String codeId, WrapupCode body) throws ApiException {
    return putWrapupcodesCodeIdWithHttpInfo(codeId, body).getResponseObject();
  }

  /**
   * Update wrap-up code
   * 
   * @param codeId Wrapup Code ID (required)
   * @param body WrapupCode (required)
   * @return WrapupCode
   * @throws ApiException if fails to make API call
   */
  public ApiResponse putWrapupcodesCodeIdWithHttpInfo(String codeId, WrapupCode body) throws ApiException {
    Object pclocalVarPostBody = body;
    
    // verify the required parameter 'codeId' is set
    if (codeId == null) {
      throw new ApiException(400, "Missing the required parameter 'codeId' when calling putWrapupcodesCodeId");
    }
    
    // verify the required parameter 'body' is set
    if (body == null) {
      throw new ApiException(400, "Missing the required parameter 'body' when calling putWrapupcodesCodeId");
    }
    
    // create path and map variables
    String pclocalVarPath = "/api/v2/routing/wrapupcodes/{codeId}".replaceAll("\\{format\\}","json")
      .replaceAll("\\{" + "codeId" + "\\}", pcapiClient.escapeString(codeId.toString()));

    // query params
    List pclocalVarQueryParams = new ArrayList();
    Map pclocalVarHeaderParams = new HashMap();
    Map pclocalVarFormParams = new HashMap();


    
    
    final String[] pclocalVarAccepts = {
      "application/json"
    };
    final String pclocalVarAccept = pcapiClient.selectHeaderAccept(pclocalVarAccepts);

    final String[] pclocalVarContentTypes = {
      "application/json"
    };
    final String pclocalVarContentType = pcapiClient.selectHeaderContentType(pclocalVarContentTypes);

    String[] pclocalVarAuthNames = new String[] { "PureCloud Auth" };

    return pcapiClient.invokeAPIVerbose(pclocalVarPath, "PUT", pclocalVarQueryParams, pclocalVarPostBody, pclocalVarHeaderParams, pclocalVarFormParams, pclocalVarAccept, pclocalVarContentType, pclocalVarAuthNames, new TypeReference() {});
  }
}