require "uri"

module PureCloud
  class ConfigurationApi
    attr_accessor :api_client

    def initialize(api_client = ApiClient.default)
      @api_client = api_client
    end

    # Get a listing of DID Pools
    # 
    # @param [Hash] opts the optional parameters
    # @option opts [Integer] :page_size Page size
    # @option opts [Integer] :page_number Page number
    # @option opts [String] :sort_by Sort by
    # @return [DIDPoolEntityListing]
    def get_didpools(opts = {})
      data, status_code, headers = get_didpools_with_http_info(opts)
      return data
    end

    # Get a listing of DID Pools
    # 
    # @param [Hash] opts the optional parameters
    # @option opts [Integer] :page_size Page size
    # @option opts [Integer] :page_number Page number
    # @option opts [String] :sort_by Sort by
    # @return [Array<(DIDPoolEntityListing, Fixnum, Hash)>] DIDPoolEntityListing data, response status code and response headers
    def get_didpools_with_http_info(opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConfigurationApi#get_didpools ..."
      end
      
      # resource path
      path = "/api/v1/configuration/didpools".sub('{format}','json')

      # query parameters
      query_params = {}
      query_params[:'pageSize'] = opts[:'page_size'] if opts[:'page_size']
      query_params[:'pageNumber'] = opts[:'page_number'] if opts[:'page_number']
      query_params[:'sortBy'] = opts[:'sort_by'] if opts[:'sort_by']

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = nil
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:GET, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => 'DIDPoolEntityListing')
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConfigurationApi#get_didpools\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Create a new DID pool
    # 
    # @param [Hash] opts the optional parameters
    # @option opts [DIDPool] :body 
    # @return [DIDPool]
    def post_didpools(opts = {})
      data, status_code, headers = post_didpools_with_http_info(opts)
      return data
    end

    # Create a new DID pool
    # 
    # @param [Hash] opts the optional parameters
    # @option opts [DIDPool] :body 
    # @return [Array<(DIDPool, Fixnum, Hash)>] DIDPool data, response status code and response headers
    def post_didpools_with_http_info(opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConfigurationApi#post_didpools ..."
      end
      
      # resource path
      path = "/api/v1/configuration/didpools".sub('{format}','json')

      # query parameters
      query_params = {}

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = @api_client.object_to_http_body(opts[:'body'])
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:POST, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => 'DIDPool')
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConfigurationApi#post_didpools\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Get a DID Pool by ID.
    # 
    # @param did_pool_id DID pool ID
    # @param [Hash] opts the optional parameters
    # @return [DIDPool]
    def get_didpools_didpool_id(did_pool_id, opts = {})
      data, status_code, headers = get_didpools_didpool_id_with_http_info(did_pool_id, opts)
      return data
    end

    # Get a DID Pool by ID.
    # 
    # @param did_pool_id DID pool ID
    # @param [Hash] opts the optional parameters
    # @return [Array<(DIDPool, Fixnum, Hash)>] DIDPool data, response status code and response headers
    def get_didpools_didpool_id_with_http_info(did_pool_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConfigurationApi#get_didpools_didpool_id ..."
      end
      
      # verify the required parameter 'did_pool_id' is set
      fail "Missing the required parameter 'did_pool_id' when calling get_didpools_didpool_id" if did_pool_id.nil?
      
      # resource path
      path = "/api/v1/configuration/didpools/{didPoolId}".sub('{format}','json').sub('{' + 'didPoolId' + '}', did_pool_id.to_s)

      # query parameters
      query_params = {}

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = nil
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:GET, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => 'DIDPool')
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConfigurationApi#get_didpools_didpool_id\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Update a DID Pool by ID.
    # 
    # @param did_pool_id DID pool ID
    # @param [Hash] opts the optional parameters
    # @option opts [DIDPool] :body 
    # @return [DIDPool]
    def put_didpools_didpool_id(did_pool_id, opts = {})
      data, status_code, headers = put_didpools_didpool_id_with_http_info(did_pool_id, opts)
      return data
    end

    # Update a DID Pool by ID.
    # 
    # @param did_pool_id DID pool ID
    # @param [Hash] opts the optional parameters
    # @option opts [DIDPool] :body 
    # @return [Array<(DIDPool, Fixnum, Hash)>] DIDPool data, response status code and response headers
    def put_didpools_didpool_id_with_http_info(did_pool_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConfigurationApi#put_didpools_didpool_id ..."
      end
      
      # verify the required parameter 'did_pool_id' is set
      fail "Missing the required parameter 'did_pool_id' when calling put_didpools_didpool_id" if did_pool_id.nil?
      
      # resource path
      path = "/api/v1/configuration/didpools/{didPoolId}".sub('{format}','json').sub('{' + 'didPoolId' + '}', did_pool_id.to_s)

      # query parameters
      query_params = {}

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = @api_client.object_to_http_body(opts[:'body'])
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:PUT, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => 'DIDPool')
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConfigurationApi#put_didpools_didpool_id\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Delete a DID Pool by ID.
    # 
    # @param did_pool_id DID pool ID
    # @param [Hash] opts the optional parameters
    # @return [String]
    def delete_didpools_didpool_id(did_pool_id, opts = {})
      data, status_code, headers = delete_didpools_didpool_id_with_http_info(did_pool_id, opts)
      return data
    end

    # Delete a DID Pool by ID.
    # 
    # @param did_pool_id DID pool ID
    # @param [Hash] opts the optional parameters
    # @return [Array<(String, Fixnum, Hash)>] String data, response status code and response headers
    def delete_didpools_didpool_id_with_http_info(did_pool_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConfigurationApi#delete_didpools_didpool_id ..."
      end
      
      # verify the required parameter 'did_pool_id' is set
      fail "Missing the required parameter 'did_pool_id' when calling delete_didpools_didpool_id" if did_pool_id.nil?
      
      # resource path
      path = "/api/v1/configuration/didpools/{didPoolId}".sub('{format}','json').sub('{' + 'didPoolId' + '}', did_pool_id.to_s)

      # query parameters
      query_params = {}

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = nil
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:DELETE, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => 'String')
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConfigurationApi#delete_didpools_didpool_id\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Get a listing of DIDs
    # 
    # @param [Hash] opts the optional parameters
    # @option opts [Integer] :page_size Page size
    # @option opts [Integer] :page_number Page number
    # @option opts [String] :sort_by Sort by
    # @option opts [String] :sort_order Sort order
    # @option opts [String] :phone_number Filter by phoneNumber
    # @return [DIDEntityListing]
    def get_dids(opts = {})
      data, status_code, headers = get_dids_with_http_info(opts)
      return data
    end

    # Get a listing of DIDs
    # 
    # @param [Hash] opts the optional parameters
    # @option opts [Integer] :page_size Page size
    # @option opts [Integer] :page_number Page number
    # @option opts [String] :sort_by Sort by
    # @option opts [String] :sort_order Sort order
    # @option opts [String] :phone_number Filter by phoneNumber
    # @return [Array<(DIDEntityListing, Fixnum, Hash)>] DIDEntityListing data, response status code and response headers
    def get_dids_with_http_info(opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConfigurationApi#get_dids ..."
      end
      
      # resource path
      path = "/api/v1/configuration/dids".sub('{format}','json')

      # query parameters
      query_params = {}
      query_params[:'pageSize'] = opts[:'page_size'] if opts[:'page_size']
      query_params[:'pageNumber'] = opts[:'page_number'] if opts[:'page_number']
      query_params[:'sortBy'] = opts[:'sort_by'] if opts[:'sort_by']
      query_params[:'sortOrder'] = opts[:'sort_order'] if opts[:'sort_order']
      query_params[:'phoneNumber'] = opts[:'phone_number'] if opts[:'phone_number']

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = nil
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:GET, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => 'DIDEntityListing')
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConfigurationApi#get_dids\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Get a DID by ID.
    # 
    # @param did_id DID ID
    # @param [Hash] opts the optional parameters
    # @return [DID]
    def get_dids_did_id(did_id, opts = {})
      data, status_code, headers = get_dids_did_id_with_http_info(did_id, opts)
      return data
    end

    # Get a DID by ID.
    # 
    # @param did_id DID ID
    # @param [Hash] opts the optional parameters
    # @return [Array<(DID, Fixnum, Hash)>] DID data, response status code and response headers
    def get_dids_did_id_with_http_info(did_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConfigurationApi#get_dids_did_id ..."
      end
      
      # verify the required parameter 'did_id' is set
      fail "Missing the required parameter 'did_id' when calling get_dids_did_id" if did_id.nil?
      
      # resource path
      path = "/api/v1/configuration/dids/{didId}".sub('{format}','json').sub('{' + 'didId' + '}', did_id.to_s)

      # query parameters
      query_params = {}

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = nil
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:GET, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => 'DID')
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConfigurationApi#get_dids_did_id\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Update a DID by ID.
    # 
    # @param did_id DID ID
    # @param [Hash] opts the optional parameters
    # @option opts [DID] :body 
    # @return [DID]
    def put_dids_did_id(did_id, opts = {})
      data, status_code, headers = put_dids_did_id_with_http_info(did_id, opts)
      return data
    end

    # Update a DID by ID.
    # 
    # @param did_id DID ID
    # @param [Hash] opts the optional parameters
    # @option opts [DID] :body 
    # @return [Array<(DID, Fixnum, Hash)>] DID data, response status code and response headers
    def put_dids_did_id_with_http_info(did_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConfigurationApi#put_dids_did_id ..."
      end
      
      # verify the required parameter 'did_id' is set
      fail "Missing the required parameter 'did_id' when calling put_dids_did_id" if did_id.nil?
      
      # resource path
      path = "/api/v1/configuration/dids/{didId}".sub('{format}','json').sub('{' + 'didId' + '}', did_id.to_s)

      # query parameters
      query_params = {}

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = @api_client.object_to_http_body(opts[:'body'])
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:PUT, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => 'DID')
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConfigurationApi#put_dids_did_id\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Get the list of edges.
    # 
    # @param [Hash] opts the optional parameters
    # @option opts [Integer] :page_size Page size
    # @option opts [Integer] :page_number Page number
    # @option opts [String] :name Name
    # @option opts [String] :site_id Filter by site.id
    # @option opts [String] :edge_group_id Filter by edgeGroup.id
    # @option opts [String] :sort_by Sort by
    # @return [EdgeEntityListing]
    def get_edges(opts = {})
      data, status_code, headers = get_edges_with_http_info(opts)
      return data
    end

    # Get the list of edges.
    # 
    # @param [Hash] opts the optional parameters
    # @option opts [Integer] :page_size Page size
    # @option opts [Integer] :page_number Page number
    # @option opts [String] :name Name
    # @option opts [String] :site_id Filter by site.id
    # @option opts [String] :edge_group_id Filter by edgeGroup.id
    # @option opts [String] :sort_by Sort by
    # @return [Array<(EdgeEntityListing, Fixnum, Hash)>] EdgeEntityListing data, response status code and response headers
    def get_edges_with_http_info(opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConfigurationApi#get_edges ..."
      end
      
      # resource path
      path = "/api/v1/configuration/edges".sub('{format}','json')

      # query parameters
      query_params = {}
      query_params[:'pageSize'] = opts[:'page_size'] if opts[:'page_size']
      query_params[:'pageNumber'] = opts[:'page_number'] if opts[:'page_number']
      query_params[:'name'] = opts[:'name'] if opts[:'name']
      query_params[:'site.id'] = opts[:'site_id'] if opts[:'site_id']
      query_params[:'edgeGroup.id'] = opts[:'edge_group_id'] if opts[:'edge_group_id']
      query_params[:'sortBy'] = opts[:'sort_by'] if opts[:'sort_by']

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = nil
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:GET, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => 'EdgeEntityListing')
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConfigurationApi#get_edges\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Create a edge.
    # 
    # @param [Hash] opts the optional parameters
    # @option opts [Edge] :body Edge
    # @return [Edge]
    def post_edges(opts = {})
      data, status_code, headers = post_edges_with_http_info(opts)
      return data
    end

    # Create a edge.
    # 
    # @param [Hash] opts the optional parameters
    # @option opts [Edge] :body Edge
    # @return [Array<(Edge, Fixnum, Hash)>] Edge data, response status code and response headers
    def post_edges_with_http_info(opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConfigurationApi#post_edges ..."
      end
      
      # resource path
      path = "/api/v1/configuration/edges".sub('{format}','json')

      # query parameters
      query_params = {}

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = @api_client.object_to_http_body(opts[:'body'])
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:POST, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => 'Edge')
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConfigurationApi#post_edges\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Get the list of certificate authorities.
    # 
    # @param [Hash] opts the optional parameters
    # @return [CertificateAuthorityEntityListing]
    def get_edges_certificateauthorities(opts = {})
      data, status_code, headers = get_edges_certificateauthorities_with_http_info(opts)
      return data
    end

    # Get the list of certificate authorities.
    # 
    # @param [Hash] opts the optional parameters
    # @return [Array<(CertificateAuthorityEntityListing, Fixnum, Hash)>] CertificateAuthorityEntityListing data, response status code and response headers
    def get_edges_certificateauthorities_with_http_info(opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConfigurationApi#get_edges_certificateauthorities ..."
      end
      
      # resource path
      path = "/api/v1/configuration/edges/certificateauthorities".sub('{format}','json')

      # query parameters
      query_params = {}

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = nil
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:GET, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => 'CertificateAuthorityEntityListing')
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConfigurationApi#get_edges_certificateauthorities\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Create a certificate authority.
    # 
    # @param [Hash] opts the optional parameters
    # @option opts [DomainCertificateAuthority] :body CertificateAuthority
    # @return [DomainCertificateAuthority]
    def post_edges_certificateauthorities(opts = {})
      data, status_code, headers = post_edges_certificateauthorities_with_http_info(opts)
      return data
    end

    # Create a certificate authority.
    # 
    # @param [Hash] opts the optional parameters
    # @option opts [DomainCertificateAuthority] :body CertificateAuthority
    # @return [Array<(DomainCertificateAuthority, Fixnum, Hash)>] DomainCertificateAuthority data, response status code and response headers
    def post_edges_certificateauthorities_with_http_info(opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConfigurationApi#post_edges_certificateauthorities ..."
      end
      
      # resource path
      path = "/api/v1/configuration/edges/certificateauthorities".sub('{format}','json')

      # query parameters
      query_params = {}

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = @api_client.object_to_http_body(opts[:'body'])
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:POST, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => 'DomainCertificateAuthority')
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConfigurationApi#post_edges_certificateauthorities\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Get a certificate authority.
    # 
    # @param certificate_id Certificate ID
    # @param [Hash] opts the optional parameters
    # @return [DomainCertificateAuthority]
    def get_edges_certificateauthorities_certificate_id(certificate_id, opts = {})
      data, status_code, headers = get_edges_certificateauthorities_certificate_id_with_http_info(certificate_id, opts)
      return data
    end

    # Get a certificate authority.
    # 
    # @param certificate_id Certificate ID
    # @param [Hash] opts the optional parameters
    # @return [Array<(DomainCertificateAuthority, Fixnum, Hash)>] DomainCertificateAuthority data, response status code and response headers
    def get_edges_certificateauthorities_certificate_id_with_http_info(certificate_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConfigurationApi#get_edges_certificateauthorities_certificate_id ..."
      end
      
      # verify the required parameter 'certificate_id' is set
      fail "Missing the required parameter 'certificate_id' when calling get_edges_certificateauthorities_certificate_id" if certificate_id.nil?
      
      # resource path
      path = "/api/v1/configuration/edges/certificateauthorities/{certificateId}".sub('{format}','json').sub('{' + 'certificateId' + '}', certificate_id.to_s)

      # query parameters
      query_params = {}

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = nil
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:GET, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => 'DomainCertificateAuthority')
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConfigurationApi#get_edges_certificateauthorities_certificate_id\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Update a certificate authority.
    # 
    # @param certificate_id Certificate ID
    # @param [Hash] opts the optional parameters
    # @option opts [DomainCertificateAuthority] :body 
    # @return [DomainCertificateAuthority]
    def put_edges_certificateauthorities_certificate_id(certificate_id, opts = {})
      data, status_code, headers = put_edges_certificateauthorities_certificate_id_with_http_info(certificate_id, opts)
      return data
    end

    # Update a certificate authority.
    # 
    # @param certificate_id Certificate ID
    # @param [Hash] opts the optional parameters
    # @option opts [DomainCertificateAuthority] :body 
    # @return [Array<(DomainCertificateAuthority, Fixnum, Hash)>] DomainCertificateAuthority data, response status code and response headers
    def put_edges_certificateauthorities_certificate_id_with_http_info(certificate_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConfigurationApi#put_edges_certificateauthorities_certificate_id ..."
      end
      
      # verify the required parameter 'certificate_id' is set
      fail "Missing the required parameter 'certificate_id' when calling put_edges_certificateauthorities_certificate_id" if certificate_id.nil?
      
      # resource path
      path = "/api/v1/configuration/edges/certificateauthorities/{certificateId}".sub('{format}','json').sub('{' + 'certificateId' + '}', certificate_id.to_s)

      # query parameters
      query_params = {}

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = @api_client.object_to_http_body(opts[:'body'])
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:PUT, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => 'DomainCertificateAuthority')
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConfigurationApi#put_edges_certificateauthorities_certificate_id\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Delete a certificate authority.
    # 
    # @param certificate_id Certificate ID
    # @param [Hash] opts the optional parameters
    # @return [String]
    def delete_edges_certificateauthorities_certificate_id(certificate_id, opts = {})
      data, status_code, headers = delete_edges_certificateauthorities_certificate_id_with_http_info(certificate_id, opts)
      return data
    end

    # Delete a certificate authority.
    # 
    # @param certificate_id Certificate ID
    # @param [Hash] opts the optional parameters
    # @return [Array<(String, Fixnum, Hash)>] String data, response status code and response headers
    def delete_edges_certificateauthorities_certificate_id_with_http_info(certificate_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConfigurationApi#delete_edges_certificateauthorities_certificate_id ..."
      end
      
      # verify the required parameter 'certificate_id' is set
      fail "Missing the required parameter 'certificate_id' when calling delete_edges_certificateauthorities_certificate_id" if certificate_id.nil?
      
      # resource path
      path = "/api/v1/configuration/edges/certificateauthorities/{certificateId}".sub('{format}','json').sub('{' + 'certificateId' + '}', certificate_id.to_s)

      # query parameters
      query_params = {}

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = nil
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:DELETE, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => 'String')
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConfigurationApi#delete_edges_certificateauthorities_certificate_id\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Get edge.
    # 
    # @param edge_id Edge ID
    # @param [Hash] opts the optional parameters
    # @return [Edge]
    def get_edges_edge_id(edge_id, opts = {})
      data, status_code, headers = get_edges_edge_id_with_http_info(edge_id, opts)
      return data
    end

    # Get edge.
    # 
    # @param edge_id Edge ID
    # @param [Hash] opts the optional parameters
    # @return [Array<(Edge, Fixnum, Hash)>] Edge data, response status code and response headers
    def get_edges_edge_id_with_http_info(edge_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConfigurationApi#get_edges_edge_id ..."
      end
      
      # verify the required parameter 'edge_id' is set
      fail "Missing the required parameter 'edge_id' when calling get_edges_edge_id" if edge_id.nil?
      
      # resource path
      path = "/api/v1/configuration/edges/{edgeId}".sub('{format}','json').sub('{' + 'edgeId' + '}', edge_id.to_s)

      # query parameters
      query_params = {}

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = nil
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:GET, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => 'Edge')
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConfigurationApi#get_edges_edge_id\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Update a edge.
    # 
    # @param edge_id Edge ID
    # @param [Hash] opts the optional parameters
    # @option opts [Edge] :body Edge
    # @return [Edge]
    def put_edges_edge_id(edge_id, opts = {})
      data, status_code, headers = put_edges_edge_id_with_http_info(edge_id, opts)
      return data
    end

    # Update a edge.
    # 
    # @param edge_id Edge ID
    # @param [Hash] opts the optional parameters
    # @option opts [Edge] :body Edge
    # @return [Array<(Edge, Fixnum, Hash)>] Edge data, response status code and response headers
    def put_edges_edge_id_with_http_info(edge_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConfigurationApi#put_edges_edge_id ..."
      end
      
      # verify the required parameter 'edge_id' is set
      fail "Missing the required parameter 'edge_id' when calling put_edges_edge_id" if edge_id.nil?
      
      # resource path
      path = "/api/v1/configuration/edges/{edgeId}".sub('{format}','json').sub('{' + 'edgeId' + '}', edge_id.to_s)

      # query parameters
      query_params = {}

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = @api_client.object_to_http_body(opts[:'body'])
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:PUT, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => 'Edge')
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConfigurationApi#put_edges_edge_id\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Delete a edge.
    # 
    # @param edge_id Edge ID
    # @param [Hash] opts the optional parameters
    # @return [String]
    def delete_edges_edge_id(edge_id, opts = {})
      data, status_code, headers = delete_edges_edge_id_with_http_info(edge_id, opts)
      return data
    end

    # Delete a edge.
    # 
    # @param edge_id Edge ID
    # @param [Hash] opts the optional parameters
    # @return [Array<(String, Fixnum, Hash)>] String data, response status code and response headers
    def delete_edges_edge_id_with_http_info(edge_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConfigurationApi#delete_edges_edge_id ..."
      end
      
      # verify the required parameter 'edge_id' is set
      fail "Missing the required parameter 'edge_id' when calling delete_edges_edge_id" if edge_id.nil?
      
      # resource path
      path = "/api/v1/configuration/edges/{edgeId}".sub('{format}','json').sub('{' + 'edgeId' + '}', edge_id.to_s)

      # query parameters
      query_params = {}

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = nil
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:DELETE, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => 'String')
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConfigurationApi#delete_edges_edge_id\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Get the list of lines.
    # 
    # @param edge_id Edge ID
    # @param [Hash] opts the optional parameters
    # @option opts [Integer] :page_size Page size
    # @option opts [Integer] :page_number Page number
    # @return [EdgeLineEntityListing]
    def get_edges_edge_id_lines(edge_id, opts = {})
      data, status_code, headers = get_edges_edge_id_lines_with_http_info(edge_id, opts)
      return data
    end

    # Get the list of lines.
    # 
    # @param edge_id Edge ID
    # @param [Hash] opts the optional parameters
    # @option opts [Integer] :page_size Page size
    # @option opts [Integer] :page_number Page number
    # @return [Array<(EdgeLineEntityListing, Fixnum, Hash)>] EdgeLineEntityListing data, response status code and response headers
    def get_edges_edge_id_lines_with_http_info(edge_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConfigurationApi#get_edges_edge_id_lines ..."
      end
      
      # verify the required parameter 'edge_id' is set
      fail "Missing the required parameter 'edge_id' when calling get_edges_edge_id_lines" if edge_id.nil?
      
      # resource path
      path = "/api/v1/configuration/edges/{edgeId}/lines".sub('{format}','json').sub('{' + 'edgeId' + '}', edge_id.to_s)

      # query parameters
      query_params = {}
      query_params[:'pageSize'] = opts[:'page_size'] if opts[:'page_size']
      query_params[:'pageNumber'] = opts[:'page_number'] if opts[:'page_number']

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = nil
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:GET, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => 'EdgeLineEntityListing')
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConfigurationApi#get_edges_edge_id_lines\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Get line
    # 
    # @param edge_id Edge ID
    # @param line_id Line ID
    # @param [Hash] opts the optional parameters
    # @return [EdgeLine]
    def get_edges_edge_id_lines_line_id(edge_id, line_id, opts = {})
      data, status_code, headers = get_edges_edge_id_lines_line_id_with_http_info(edge_id, line_id, opts)
      return data
    end

    # Get line
    # 
    # @param edge_id Edge ID
    # @param line_id Line ID
    # @param [Hash] opts the optional parameters
    # @return [Array<(EdgeLine, Fixnum, Hash)>] EdgeLine data, response status code and response headers
    def get_edges_edge_id_lines_line_id_with_http_info(edge_id, line_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConfigurationApi#get_edges_edge_id_lines_line_id ..."
      end
      
      # verify the required parameter 'edge_id' is set
      fail "Missing the required parameter 'edge_id' when calling get_edges_edge_id_lines_line_id" if edge_id.nil?
      
      # verify the required parameter 'line_id' is set
      fail "Missing the required parameter 'line_id' when calling get_edges_edge_id_lines_line_id" if line_id.nil?
      
      # resource path
      path = "/api/v1/configuration/edges/{edgeId}/lines/{lineId}".sub('{format}','json').sub('{' + 'edgeId' + '}', edge_id.to_s).sub('{' + 'lineId' + '}', line_id.to_s)

      # query parameters
      query_params = {}

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = nil
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:GET, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => 'EdgeLine')
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConfigurationApi#get_edges_edge_id_lines_line_id\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Update a line.
    # 
    # @param edge_id Edge ID
    # @param line_id Line ID
    # @param [Hash] opts the optional parameters
    # @option opts [EdgeLine] :body Line
    # @return [EdgeLine]
    def put_edges_edge_id_lines_line_id(edge_id, line_id, opts = {})
      data, status_code, headers = put_edges_edge_id_lines_line_id_with_http_info(edge_id, line_id, opts)
      return data
    end

    # Update a line.
    # 
    # @param edge_id Edge ID
    # @param line_id Line ID
    # @param [Hash] opts the optional parameters
    # @option opts [EdgeLine] :body Line
    # @return [Array<(EdgeLine, Fixnum, Hash)>] EdgeLine data, response status code and response headers
    def put_edges_edge_id_lines_line_id_with_http_info(edge_id, line_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConfigurationApi#put_edges_edge_id_lines_line_id ..."
      end
      
      # verify the required parameter 'edge_id' is set
      fail "Missing the required parameter 'edge_id' when calling put_edges_edge_id_lines_line_id" if edge_id.nil?
      
      # verify the required parameter 'line_id' is set
      fail "Missing the required parameter 'line_id' when calling put_edges_edge_id_lines_line_id" if line_id.nil?
      
      # resource path
      path = "/api/v1/configuration/edges/{edgeId}/lines/{lineId}".sub('{format}','json').sub('{' + 'edgeId' + '}', edge_id.to_s).sub('{' + 'lineId' + '}', line_id.to_s)

      # query parameters
      query_params = {}

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = @api_client.object_to_http_body(opts[:'body'])
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:PUT, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => 'EdgeLine')
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConfigurationApi#put_edges_edge_id_lines_line_id\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Get edge logical interfaces.
    # Retrieve a list of all configured logical interfaces from a specific edge.
    # @param edge_id Edge ID
    # @param [Hash] opts the optional parameters
    # @return [LogicalInterfaceEntityListing]
    def get_edges_edge_id_logicalinterfaces(edge_id, opts = {})
      data, status_code, headers = get_edges_edge_id_logicalinterfaces_with_http_info(edge_id, opts)
      return data
    end

    # Get edge logical interfaces.
    # Retrieve a list of all configured logical interfaces from a specific edge.
    # @param edge_id Edge ID
    # @param [Hash] opts the optional parameters
    # @return [Array<(LogicalInterfaceEntityListing, Fixnum, Hash)>] LogicalInterfaceEntityListing data, response status code and response headers
    def get_edges_edge_id_logicalinterfaces_with_http_info(edge_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConfigurationApi#get_edges_edge_id_logicalinterfaces ..."
      end
      
      # verify the required parameter 'edge_id' is set
      fail "Missing the required parameter 'edge_id' when calling get_edges_edge_id_logicalinterfaces" if edge_id.nil?
      
      # resource path
      path = "/api/v1/configuration/edges/{edgeId}/logicalinterfaces".sub('{format}','json').sub('{' + 'edgeId' + '}', edge_id.to_s)

      # query parameters
      query_params = {}

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = nil
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:GET, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => 'LogicalInterfaceEntityListing')
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConfigurationApi#get_edges_edge_id_logicalinterfaces\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Create an edge logical interface.
    # Create
    # @param edge_id Edge ID
    # @param [Hash] opts the optional parameters
    # @option opts [DomainLogicalInterface] :body 
    # @return [DomainLogicalInterface]
    def post_edges_edge_id_logicalinterfaces(edge_id, opts = {})
      data, status_code, headers = post_edges_edge_id_logicalinterfaces_with_http_info(edge_id, opts)
      return data
    end

    # Create an edge logical interface.
    # Create
    # @param edge_id Edge ID
    # @param [Hash] opts the optional parameters
    # @option opts [DomainLogicalInterface] :body 
    # @return [Array<(DomainLogicalInterface, Fixnum, Hash)>] DomainLogicalInterface data, response status code and response headers
    def post_edges_edge_id_logicalinterfaces_with_http_info(edge_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConfigurationApi#post_edges_edge_id_logicalinterfaces ..."
      end
      
      # verify the required parameter 'edge_id' is set
      fail "Missing the required parameter 'edge_id' when calling post_edges_edge_id_logicalinterfaces" if edge_id.nil?
      
      # resource path
      path = "/api/v1/configuration/edges/{edgeId}/logicalinterfaces".sub('{format}','json').sub('{' + 'edgeId' + '}', edge_id.to_s)

      # query parameters
      query_params = {}

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = @api_client.object_to_http_body(opts[:'body'])
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:POST, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => 'DomainLogicalInterface')
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConfigurationApi#post_edges_edge_id_logicalinterfaces\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Get an edge logical interface
    # 
    # @param edge_id Edge ID
    # @param interface_id Interface ID
    # @param [Hash] opts the optional parameters
    # @return [DomainLogicalInterface]
    def get_edges_edge_id_logicalinterfaces_interface_id(edge_id, interface_id, opts = {})
      data, status_code, headers = get_edges_edge_id_logicalinterfaces_interface_id_with_http_info(edge_id, interface_id, opts)
      return data
    end

    # Get an edge logical interface
    # 
    # @param edge_id Edge ID
    # @param interface_id Interface ID
    # @param [Hash] opts the optional parameters
    # @return [Array<(DomainLogicalInterface, Fixnum, Hash)>] DomainLogicalInterface data, response status code and response headers
    def get_edges_edge_id_logicalinterfaces_interface_id_with_http_info(edge_id, interface_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConfigurationApi#get_edges_edge_id_logicalinterfaces_interface_id ..."
      end
      
      # verify the required parameter 'edge_id' is set
      fail "Missing the required parameter 'edge_id' when calling get_edges_edge_id_logicalinterfaces_interface_id" if edge_id.nil?
      
      # verify the required parameter 'interface_id' is set
      fail "Missing the required parameter 'interface_id' when calling get_edges_edge_id_logicalinterfaces_interface_id" if interface_id.nil?
      
      # resource path
      path = "/api/v1/configuration/edges/{edgeId}/logicalinterfaces/{interfaceId}".sub('{format}','json').sub('{' + 'edgeId' + '}', edge_id.to_s).sub('{' + 'interfaceId' + '}', interface_id.to_s)

      # query parameters
      query_params = {}

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = nil
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:GET, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => 'DomainLogicalInterface')
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConfigurationApi#get_edges_edge_id_logicalinterfaces_interface_id\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Update an edge logical interface.
    # 
    # @param edge_id Edge ID
    # @param interface_id Interface ID
    # @param [Hash] opts the optional parameters
    # @option opts [DomainLogicalInterface] :body 
    # @return [DomainLogicalInterface]
    def put_edges_edge_id_logicalinterfaces_interface_id(edge_id, interface_id, opts = {})
      data, status_code, headers = put_edges_edge_id_logicalinterfaces_interface_id_with_http_info(edge_id, interface_id, opts)
      return data
    end

    # Update an edge logical interface.
    # 
    # @param edge_id Edge ID
    # @param interface_id Interface ID
    # @param [Hash] opts the optional parameters
    # @option opts [DomainLogicalInterface] :body 
    # @return [Array<(DomainLogicalInterface, Fixnum, Hash)>] DomainLogicalInterface data, response status code and response headers
    def put_edges_edge_id_logicalinterfaces_interface_id_with_http_info(edge_id, interface_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConfigurationApi#put_edges_edge_id_logicalinterfaces_interface_id ..."
      end
      
      # verify the required parameter 'edge_id' is set
      fail "Missing the required parameter 'edge_id' when calling put_edges_edge_id_logicalinterfaces_interface_id" if edge_id.nil?
      
      # verify the required parameter 'interface_id' is set
      fail "Missing the required parameter 'interface_id' when calling put_edges_edge_id_logicalinterfaces_interface_id" if interface_id.nil?
      
      # resource path
      path = "/api/v1/configuration/edges/{edgeId}/logicalinterfaces/{interfaceId}".sub('{format}','json').sub('{' + 'edgeId' + '}', edge_id.to_s).sub('{' + 'interfaceId' + '}', interface_id.to_s)

      # query parameters
      query_params = {}

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = @api_client.object_to_http_body(opts[:'body'])
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:PUT, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => 'DomainLogicalInterface')
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConfigurationApi#put_edges_edge_id_logicalinterfaces_interface_id\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Delete an edge logical interface
    # 
    # @param edge_id Edge ID
    # @param interface_id Interface ID
    # @param [Hash] opts the optional parameters
    # @return [nil]
    def delete_edges_edge_id_logicalinterfaces_interface_id(edge_id, interface_id, opts = {})
      delete_edges_edge_id_logicalinterfaces_interface_id_with_http_info(edge_id, interface_id, opts)
      return nil
    end

    # Delete an edge logical interface
    # 
    # @param edge_id Edge ID
    # @param interface_id Interface ID
    # @param [Hash] opts the optional parameters
    # @return [Array<(nil, Fixnum, Hash)>] nil, response status code and response headers
    def delete_edges_edge_id_logicalinterfaces_interface_id_with_http_info(edge_id, interface_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConfigurationApi#delete_edges_edge_id_logicalinterfaces_interface_id ..."
      end
      
      # verify the required parameter 'edge_id' is set
      fail "Missing the required parameter 'edge_id' when calling delete_edges_edge_id_logicalinterfaces_interface_id" if edge_id.nil?
      
      # verify the required parameter 'interface_id' is set
      fail "Missing the required parameter 'interface_id' when calling delete_edges_edge_id_logicalinterfaces_interface_id" if interface_id.nil?
      
      # resource path
      path = "/api/v1/configuration/edges/{edgeId}/logicalinterfaces/{interfaceId}".sub('{format}','json').sub('{' + 'edgeId' + '}', edge_id.to_s).sub('{' + 'interfaceId' + '}', interface_id.to_s)

      # query parameters
      query_params = {}

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = nil
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:DELETE, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConfigurationApi#delete_edges_edge_id_logicalinterfaces_interface_id\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Create a job to upload a list of Edge logs.
    # 
    # @param edge_id Edge ID
    # @param [Hash] opts the optional parameters
    # @option opts [EdgeLogsJobRequest] :body EdgeLogsJobRequest
    # @return [EdgeLogsJobResponse]
    def post_edges_edge_id_logs_jobs(edge_id, opts = {})
      data, status_code, headers = post_edges_edge_id_logs_jobs_with_http_info(edge_id, opts)
      return data
    end

    # Create a job to upload a list of Edge logs.
    # 
    # @param edge_id Edge ID
    # @param [Hash] opts the optional parameters
    # @option opts [EdgeLogsJobRequest] :body EdgeLogsJobRequest
    # @return [Array<(EdgeLogsJobResponse, Fixnum, Hash)>] EdgeLogsJobResponse data, response status code and response headers
    def post_edges_edge_id_logs_jobs_with_http_info(edge_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConfigurationApi#post_edges_edge_id_logs_jobs ..."
      end
      
      # verify the required parameter 'edge_id' is set
      fail "Missing the required parameter 'edge_id' when calling post_edges_edge_id_logs_jobs" if edge_id.nil?
      
      # resource path
      path = "/api/v1/configuration/edges/{edgeId}/logs/jobs".sub('{format}','json').sub('{' + 'edgeId' + '}', edge_id.to_s)

      # query parameters
      query_params = {}

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = @api_client.object_to_http_body(opts[:'body'])
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:POST, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => 'EdgeLogsJobResponse')
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConfigurationApi#post_edges_edge_id_logs_jobs\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Get an Edge logs job.
    # 
    # @param edge_id Edge ID
    # @param job_id Job ID
    # @param [Hash] opts the optional parameters
    # @return [EdgeLogsJob]
    def get_edges_edge_id_logs_jobs_job_id(edge_id, job_id, opts = {})
      data, status_code, headers = get_edges_edge_id_logs_jobs_job_id_with_http_info(edge_id, job_id, opts)
      return data
    end

    # Get an Edge logs job.
    # 
    # @param edge_id Edge ID
    # @param job_id Job ID
    # @param [Hash] opts the optional parameters
    # @return [Array<(EdgeLogsJob, Fixnum, Hash)>] EdgeLogsJob data, response status code and response headers
    def get_edges_edge_id_logs_jobs_job_id_with_http_info(edge_id, job_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConfigurationApi#get_edges_edge_id_logs_jobs_job_id ..."
      end
      
      # verify the required parameter 'edge_id' is set
      fail "Missing the required parameter 'edge_id' when calling get_edges_edge_id_logs_jobs_job_id" if edge_id.nil?
      
      # verify the required parameter 'job_id' is set
      fail "Missing the required parameter 'job_id' when calling get_edges_edge_id_logs_jobs_job_id" if job_id.nil?
      
      # resource path
      path = "/api/v1/configuration/edges/{edgeId}/logs/jobs/{jobId}".sub('{format}','json').sub('{' + 'edgeId' + '}', edge_id.to_s).sub('{' + 'jobId' + '}', job_id.to_s)

      # query parameters
      query_params = {}

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = nil
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:GET, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => 'EdgeLogsJob')
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConfigurationApi#get_edges_edge_id_logs_jobs_job_id\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Request that the specified fileIds be uploaded from the Edge.
    # 
    # @param edge_id Edge ID
    # @param job_id Job ID
    # @param [Hash] opts the optional parameters
    # @option opts [EdgeLogsJobUploadRequest] :body 
    # @return [nil]
    def post_edges_edge_id_logs_jobs_job_id_upload(edge_id, job_id, opts = {})
      post_edges_edge_id_logs_jobs_job_id_upload_with_http_info(edge_id, job_id, opts)
      return nil
    end

    # Request that the specified fileIds be uploaded from the Edge.
    # 
    # @param edge_id Edge ID
    # @param job_id Job ID
    # @param [Hash] opts the optional parameters
    # @option opts [EdgeLogsJobUploadRequest] :body 
    # @return [Array<(nil, Fixnum, Hash)>] nil, response status code and response headers
    def post_edges_edge_id_logs_jobs_job_id_upload_with_http_info(edge_id, job_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConfigurationApi#post_edges_edge_id_logs_jobs_job_id_upload ..."
      end
      
      # verify the required parameter 'edge_id' is set
      fail "Missing the required parameter 'edge_id' when calling post_edges_edge_id_logs_jobs_job_id_upload" if edge_id.nil?
      
      # verify the required parameter 'job_id' is set
      fail "Missing the required parameter 'job_id' when calling post_edges_edge_id_logs_jobs_job_id_upload" if job_id.nil?
      
      # resource path
      path = "/api/v1/configuration/edges/{edgeId}/logs/jobs/{jobId}/upload".sub('{format}','json').sub('{' + 'edgeId' + '}', edge_id.to_s).sub('{' + 'jobId' + '}', job_id.to_s)

      # query parameters
      query_params = {}

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = @api_client.object_to_http_body(opts[:'body'])
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:POST, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConfigurationApi#post_edges_edge_id_logs_jobs_job_id_upload\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Retrieve a list of all configured physical interfaces from a specific edge.
    # 
    # @param edge_id Edge ID
    # @param [Hash] opts the optional parameters
    # @return [PhysicalInterfaceEntityListing]
    def get_edges_edge_id_physicalinterfaces(edge_id, opts = {})
      data, status_code, headers = get_edges_edge_id_physicalinterfaces_with_http_info(edge_id, opts)
      return data
    end

    # Retrieve a list of all configured physical interfaces from a specific edge.
    # 
    # @param edge_id Edge ID
    # @param [Hash] opts the optional parameters
    # @return [Array<(PhysicalInterfaceEntityListing, Fixnum, Hash)>] PhysicalInterfaceEntityListing data, response status code and response headers
    def get_edges_edge_id_physicalinterfaces_with_http_info(edge_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConfigurationApi#get_edges_edge_id_physicalinterfaces ..."
      end
      
      # verify the required parameter 'edge_id' is set
      fail "Missing the required parameter 'edge_id' when calling get_edges_edge_id_physicalinterfaces" if edge_id.nil?
      
      # resource path
      path = "/api/v1/configuration/edges/{edgeId}/physicalinterfaces".sub('{format}','json').sub('{' + 'edgeId' + '}', edge_id.to_s)

      # query parameters
      query_params = {}

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = nil
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:GET, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => 'PhysicalInterfaceEntityListing')
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConfigurationApi#get_edges_edge_id_physicalinterfaces\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Get edge physical interface.
    # Retrieve a physical interface from a specific edge.
    # @param edge_id Edge ID
    # @param interface_id Interface ID
    # @param [Hash] opts the optional parameters
    # @return [DomainPhysicalInterface]
    def get_edges_edge_id_physicalinterfaces_interface_id(edge_id, interface_id, opts = {})
      data, status_code, headers = get_edges_edge_id_physicalinterfaces_interface_id_with_http_info(edge_id, interface_id, opts)
      return data
    end

    # Get edge physical interface.
    # Retrieve a physical interface from a specific edge.
    # @param edge_id Edge ID
    # @param interface_id Interface ID
    # @param [Hash] opts the optional parameters
    # @return [Array<(DomainPhysicalInterface, Fixnum, Hash)>] DomainPhysicalInterface data, response status code and response headers
    def get_edges_edge_id_physicalinterfaces_interface_id_with_http_info(edge_id, interface_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConfigurationApi#get_edges_edge_id_physicalinterfaces_interface_id ..."
      end
      
      # verify the required parameter 'edge_id' is set
      fail "Missing the required parameter 'edge_id' when calling get_edges_edge_id_physicalinterfaces_interface_id" if edge_id.nil?
      
      # verify the required parameter 'interface_id' is set
      fail "Missing the required parameter 'interface_id' when calling get_edges_edge_id_physicalinterfaces_interface_id" if interface_id.nil?
      
      # resource path
      path = "/api/v1/configuration/edges/{edgeId}/physicalinterfaces/{interfaceId}".sub('{format}','json').sub('{' + 'edgeId' + '}', edge_id.to_s).sub('{' + 'interfaceId' + '}', interface_id.to_s)

      # query parameters
      query_params = {}

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = nil
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:GET, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => 'DomainPhysicalInterface')
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConfigurationApi#get_edges_edge_id_physicalinterfaces_interface_id\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Reboot an Edge
    # 
    # @param edge_id Edge ID
    # @param [Hash] opts the optional parameters
    # @return [String]
    def post_edges_edge_id_reboot(edge_id, opts = {})
      data, status_code, headers = post_edges_edge_id_reboot_with_http_info(edge_id, opts)
      return data
    end

    # Reboot an Edge
    # 
    # @param edge_id Edge ID
    # @param [Hash] opts the optional parameters
    # @return [Array<(String, Fixnum, Hash)>] String data, response status code and response headers
    def post_edges_edge_id_reboot_with_http_info(edge_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConfigurationApi#post_edges_edge_id_reboot ..."
      end
      
      # verify the required parameter 'edge_id' is set
      fail "Missing the required parameter 'edge_id' when calling post_edges_edge_id_reboot" if edge_id.nil?
      
      # resource path
      path = "/api/v1/configuration/edges/{edgeId}/reboot".sub('{format}','json').sub('{' + 'edgeId' + '}', edge_id.to_s)

      # query parameters
      query_params = {}

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = nil
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:POST, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => 'String')
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConfigurationApi#post_edges_edge_id_reboot\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Gets software update status information about any edge.
    # 
    # @param edge_id Edge ID
    # @param [Hash] opts the optional parameters
    # @return [DomainEdgeSoftwareUpdateDto]
    def get_edges_edge_id_softwareupdate(edge_id, opts = {})
      data, status_code, headers = get_edges_edge_id_softwareupdate_with_http_info(edge_id, opts)
      return data
    end

    # Gets software update status information about any edge.
    # 
    # @param edge_id Edge ID
    # @param [Hash] opts the optional parameters
    # @return [Array<(DomainEdgeSoftwareUpdateDto, Fixnum, Hash)>] DomainEdgeSoftwareUpdateDto data, response status code and response headers
    def get_edges_edge_id_softwareupdate_with_http_info(edge_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConfigurationApi#get_edges_edge_id_softwareupdate ..."
      end
      
      # verify the required parameter 'edge_id' is set
      fail "Missing the required parameter 'edge_id' when calling get_edges_edge_id_softwareupdate" if edge_id.nil?
      
      # resource path
      path = "/api/v1/configuration/edges/{edgeId}/softwareupdate".sub('{format}','json').sub('{' + 'edgeId' + '}', edge_id.to_s)

      # query parameters
      query_params = {}

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = nil
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:GET, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => 'DomainEdgeSoftwareUpdateDto')
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConfigurationApi#get_edges_edge_id_softwareupdate\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Starts a software update for this edge.
    # 
    # @param edge_id Edge ID
    # @param [Hash] opts the optional parameters
    # @option opts [DomainEdgeSoftwareUpdateDto] :body 
    # @return [DomainEdgeSoftwareUpdateDto]
    def post_edges_edge_id_softwareupdate(edge_id, opts = {})
      data, status_code, headers = post_edges_edge_id_softwareupdate_with_http_info(edge_id, opts)
      return data
    end

    # Starts a software update for this edge.
    # 
    # @param edge_id Edge ID
    # @param [Hash] opts the optional parameters
    # @option opts [DomainEdgeSoftwareUpdateDto] :body 
    # @return [Array<(DomainEdgeSoftwareUpdateDto, Fixnum, Hash)>] DomainEdgeSoftwareUpdateDto data, response status code and response headers
    def post_edges_edge_id_softwareupdate_with_http_info(edge_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConfigurationApi#post_edges_edge_id_softwareupdate ..."
      end
      
      # verify the required parameter 'edge_id' is set
      fail "Missing the required parameter 'edge_id' when calling post_edges_edge_id_softwareupdate" if edge_id.nil?
      
      # resource path
      path = "/api/v1/configuration/edges/{edgeId}/softwareupdate".sub('{format}','json').sub('{' + 'edgeId' + '}', edge_id.to_s)

      # query parameters
      query_params = {}

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = @api_client.object_to_http_body(opts[:'body'])
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:POST, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => 'DomainEdgeSoftwareUpdateDto')
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConfigurationApi#post_edges_edge_id_softwareupdate\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Cancels any in-progress update for this edge.
    # 
    # @param edge_id Edge ID
    # @param [Hash] opts the optional parameters
    # @return [String]
    def delete_edges_edge_id_softwareupdate(edge_id, opts = {})
      data, status_code, headers = delete_edges_edge_id_softwareupdate_with_http_info(edge_id, opts)
      return data
    end

    # Cancels any in-progress update for this edge.
    # 
    # @param edge_id Edge ID
    # @param [Hash] opts the optional parameters
    # @return [Array<(String, Fixnum, Hash)>] String data, response status code and response headers
    def delete_edges_edge_id_softwareupdate_with_http_info(edge_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConfigurationApi#delete_edges_edge_id_softwareupdate ..."
      end
      
      # verify the required parameter 'edge_id' is set
      fail "Missing the required parameter 'edge_id' when calling delete_edges_edge_id_softwareupdate" if edge_id.nil?
      
      # resource path
      path = "/api/v1/configuration/edges/{edgeId}/softwareupdate".sub('{format}','json').sub('{' + 'edgeId' + '}', edge_id.to_s)

      # query parameters
      query_params = {}

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = nil
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:DELETE, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => 'String')
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConfigurationApi#delete_edges_edge_id_softwareupdate\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Gets all the available software versions for this edge.
    # 
    # @param edge_id Edge ID
    # @param [Hash] opts the optional parameters
    # @return [DomainEdgeSoftwareVersionDto]
    def get_edges_edge_id_softwareversions(edge_id, opts = {})
      data, status_code, headers = get_edges_edge_id_softwareversions_with_http_info(edge_id, opts)
      return data
    end

    # Gets all the available software versions for this edge.
    # 
    # @param edge_id Edge ID
    # @param [Hash] opts the optional parameters
    # @return [Array<(DomainEdgeSoftwareVersionDto, Fixnum, Hash)>] DomainEdgeSoftwareVersionDto data, response status code and response headers
    def get_edges_edge_id_softwareversions_with_http_info(edge_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConfigurationApi#get_edges_edge_id_softwareversions ..."
      end
      
      # verify the required parameter 'edge_id' is set
      fail "Missing the required parameter 'edge_id' when calling get_edges_edge_id_softwareversions" if edge_id.nil?
      
      # resource path
      path = "/api/v1/configuration/edges/{edgeId}/softwareversions".sub('{format}','json').sub('{' + 'edgeId' + '}', edge_id.to_s)

      # query parameters
      query_params = {}

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = nil
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:GET, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => 'DomainEdgeSoftwareVersionDto')
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConfigurationApi#get_edges_edge_id_softwareversions\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Unpair an Edge
    # 
    # @param edge_id Edge Id
    # @param [Hash] opts the optional parameters
    # @return [String]
    def post_edges_edge_id_unpair(edge_id, opts = {})
      data, status_code, headers = post_edges_edge_id_unpair_with_http_info(edge_id, opts)
      return data
    end

    # Unpair an Edge
    # 
    # @param edge_id Edge Id
    # @param [Hash] opts the optional parameters
    # @return [Array<(String, Fixnum, Hash)>] String data, response status code and response headers
    def post_edges_edge_id_unpair_with_http_info(edge_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConfigurationApi#post_edges_edge_id_unpair ..."
      end
      
      # verify the required parameter 'edge_id' is set
      fail "Missing the required parameter 'edge_id' when calling post_edges_edge_id_unpair" if edge_id.nil?
      
      # resource path
      path = "/api/v1/configuration/edges/{edgeId}/unpair".sub('{format}','json').sub('{' + 'edgeId' + '}', edge_id.to_s)

      # query parameters
      query_params = {}

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = nil
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:POST, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => 'String')
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConfigurationApi#post_edges_edge_id_unpair\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Get the edge version report.
    # The report will not have consistent data about the edge version(s) until all edges have been reset.
    # @param [Hash] opts the optional parameters
    # @return [EdgeVersionReport]
    def get_edgeversionreport(opts = {})
      data, status_code, headers = get_edgeversionreport_with_http_info(opts)
      return data
    end

    # Get the edge version report.
    # The report will not have consistent data about the edge version(s) until all edges have been reset.
    # @param [Hash] opts the optional parameters
    # @return [Array<(EdgeVersionReport, Fixnum, Hash)>] EdgeVersionReport data, response status code and response headers
    def get_edgeversionreport_with_http_info(opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConfigurationApi#get_edgeversionreport ..."
      end
      
      # resource path
      path = "/api/v1/configuration/edgeversionreport".sub('{format}','json')

      # query parameters
      query_params = {}

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = nil
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:GET, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => 'EdgeVersionReport')
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConfigurationApi#get_edgeversionreport\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Get endpoints
    # 
    # @param [Hash] opts the optional parameters
    # @option opts [Integer] :page_size Page size
    # @option opts [Integer] :page_number Page number
    # @option opts [String] :name Name
    # @option opts [String] :sort_by Sort by
    # @return [EndpointEntityListing]
    def get_endpoints(opts = {})
      data, status_code, headers = get_endpoints_with_http_info(opts)
      return data
    end

    # Get endpoints
    # 
    # @param [Hash] opts the optional parameters
    # @option opts [Integer] :page_size Page size
    # @option opts [Integer] :page_number Page number
    # @option opts [String] :name Name
    # @option opts [String] :sort_by Sort by
    # @return [Array<(EndpointEntityListing, Fixnum, Hash)>] EndpointEntityListing data, response status code and response headers
    def get_endpoints_with_http_info(opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConfigurationApi#get_endpoints ..."
      end
      
      # resource path
      path = "/api/v1/configuration/endpoints".sub('{format}','json')

      # query parameters
      query_params = {}
      query_params[:'pageSize'] = opts[:'page_size'] if opts[:'page_size']
      query_params[:'pageNumber'] = opts[:'page_number'] if opts[:'page_number']
      query_params[:'name'] = opts[:'name'] if opts[:'name']
      query_params[:'sortBy'] = opts[:'sort_by'] if opts[:'sort_by']

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = nil
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:GET, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => 'EndpointEntityListing')
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConfigurationApi#get_endpoints\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Create endpoint
    # 
    # @param [Hash] opts the optional parameters
    # @option opts [Endpoint] :body EndpointTemplate
    # @return [Endpoint]
    def post_endpoints(opts = {})
      data, status_code, headers = post_endpoints_with_http_info(opts)
      return data
    end

    # Create endpoint
    # 
    # @param [Hash] opts the optional parameters
    # @option opts [Endpoint] :body EndpointTemplate
    # @return [Array<(Endpoint, Fixnum, Hash)>] Endpoint data, response status code and response headers
    def post_endpoints_with_http_info(opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConfigurationApi#post_endpoints ..."
      end
      
      # resource path
      path = "/api/v1/configuration/endpoints".sub('{format}','json')

      # query parameters
      query_params = {}

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = @api_client.object_to_http_body(opts[:'body'])
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:POST, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => 'Endpoint')
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConfigurationApi#post_endpoints\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Get endpoint
    # 
    # @param endpoint_id Endpoint ID
    # @param [Hash] opts the optional parameters
    # @return [Endpoint]
    def get_endpoints_endpoint_id(endpoint_id, opts = {})
      data, status_code, headers = get_endpoints_endpoint_id_with_http_info(endpoint_id, opts)
      return data
    end

    # Get endpoint
    # 
    # @param endpoint_id Endpoint ID
    # @param [Hash] opts the optional parameters
    # @return [Array<(Endpoint, Fixnum, Hash)>] Endpoint data, response status code and response headers
    def get_endpoints_endpoint_id_with_http_info(endpoint_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConfigurationApi#get_endpoints_endpoint_id ..."
      end
      
      # verify the required parameter 'endpoint_id' is set
      fail "Missing the required parameter 'endpoint_id' when calling get_endpoints_endpoint_id" if endpoint_id.nil?
      
      # resource path
      path = "/api/v1/configuration/endpoints/{endpointId}".sub('{format}','json').sub('{' + 'endpointId' + '}', endpoint_id.to_s)

      # query parameters
      query_params = {}

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = nil
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:GET, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => 'Endpoint')
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConfigurationApi#get_endpoints_endpoint_id\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Update endpoint
    # 
    # @param endpoint_id Endpoint ID
    # @param [Hash] opts the optional parameters
    # @option opts [Endpoint] :body EndpointTemplate
    # @return [Endpoint]
    def put_endpoints_endpoint_id(endpoint_id, opts = {})
      data, status_code, headers = put_endpoints_endpoint_id_with_http_info(endpoint_id, opts)
      return data
    end

    # Update endpoint
    # 
    # @param endpoint_id Endpoint ID
    # @param [Hash] opts the optional parameters
    # @option opts [Endpoint] :body EndpointTemplate
    # @return [Array<(Endpoint, Fixnum, Hash)>] Endpoint data, response status code and response headers
    def put_endpoints_endpoint_id_with_http_info(endpoint_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConfigurationApi#put_endpoints_endpoint_id ..."
      end
      
      # verify the required parameter 'endpoint_id' is set
      fail "Missing the required parameter 'endpoint_id' when calling put_endpoints_endpoint_id" if endpoint_id.nil?
      
      # resource path
      path = "/api/v1/configuration/endpoints/{endpointId}".sub('{format}','json').sub('{' + 'endpointId' + '}', endpoint_id.to_s)

      # query parameters
      query_params = {}

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = @api_client.object_to_http_body(opts[:'body'])
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:PUT, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => 'Endpoint')
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConfigurationApi#put_endpoints_endpoint_id\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Delete endpoint
    # 
    # @param endpoint_id Endpoint ID
    # @param [Hash] opts the optional parameters
    # @return [String]
    def delete_endpoints_endpoint_id(endpoint_id, opts = {})
      data, status_code, headers = delete_endpoints_endpoint_id_with_http_info(endpoint_id, opts)
      return data
    end

    # Delete endpoint
    # 
    # @param endpoint_id Endpoint ID
    # @param [Hash] opts the optional parameters
    # @return [Array<(String, Fixnum, Hash)>] String data, response status code and response headers
    def delete_endpoints_endpoint_id_with_http_info(endpoint_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConfigurationApi#delete_endpoints_endpoint_id ..."
      end
      
      # verify the required parameter 'endpoint_id' is set
      fail "Missing the required parameter 'endpoint_id' when calling delete_endpoints_endpoint_id" if endpoint_id.nil?
      
      # resource path
      path = "/api/v1/configuration/endpoints/{endpointId}".sub('{format}','json').sub('{' + 'endpointId' + '}', endpoint_id.to_s)

      # query parameters
      query_params = {}

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = nil
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:DELETE, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => 'String')
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConfigurationApi#delete_endpoints_endpoint_id\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Get a listing of extension pools
    # 
    # @param [Hash] opts the optional parameters
    # @option opts [Integer] :page_size Page size
    # @option opts [Integer] :page_number Page number
    # @option opts [String] :sort_by Sort by
    # @option opts [String] :number Number
    # @return [ExtensionPoolEntityListing]
    def get_extensionpools(opts = {})
      data, status_code, headers = get_extensionpools_with_http_info(opts)
      return data
    end

    # Get a listing of extension pools
    # 
    # @param [Hash] opts the optional parameters
    # @option opts [Integer] :page_size Page size
    # @option opts [Integer] :page_number Page number
    # @option opts [String] :sort_by Sort by
    # @option opts [String] :number Number
    # @return [Array<(ExtensionPoolEntityListing, Fixnum, Hash)>] ExtensionPoolEntityListing data, response status code and response headers
    def get_extensionpools_with_http_info(opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConfigurationApi#get_extensionpools ..."
      end
      
      # resource path
      path = "/api/v1/configuration/extensionpools".sub('{format}','json')

      # query parameters
      query_params = {}
      query_params[:'pageSize'] = opts[:'page_size'] if opts[:'page_size']
      query_params[:'pageNumber'] = opts[:'page_number'] if opts[:'page_number']
      query_params[:'sortBy'] = opts[:'sort_by'] if opts[:'sort_by']
      query_params[:'number'] = opts[:'number'] if opts[:'number']

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = nil
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:GET, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => 'ExtensionPoolEntityListing')
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConfigurationApi#get_extensionpools\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Create a new extension pool
    # 
    # @param [Hash] opts the optional parameters
    # @option opts [ExtensionPool] :body ExtensionPool
    # @return [Extension]
    def post_extensionpools(opts = {})
      data, status_code, headers = post_extensionpools_with_http_info(opts)
      return data
    end

    # Create a new extension pool
    # 
    # @param [Hash] opts the optional parameters
    # @option opts [ExtensionPool] :body ExtensionPool
    # @return [Array<(Extension, Fixnum, Hash)>] Extension data, response status code and response headers
    def post_extensionpools_with_http_info(opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConfigurationApi#post_extensionpools ..."
      end
      
      # resource path
      path = "/api/v1/configuration/extensionpools".sub('{format}','json')

      # query parameters
      query_params = {}

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = @api_client.object_to_http_body(opts[:'body'])
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:POST, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => 'Extension')
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConfigurationApi#post_extensionpools\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Get an extension pool by ID
    # 
    # @param extension_pool_id Extension pool ID
    # @param [Hash] opts the optional parameters
    # @return [ExtensionPool]
    def get_extensionpools_extensionpool_id(extension_pool_id, opts = {})
      data, status_code, headers = get_extensionpools_extensionpool_id_with_http_info(extension_pool_id, opts)
      return data
    end

    # Get an extension pool by ID
    # 
    # @param extension_pool_id Extension pool ID
    # @param [Hash] opts the optional parameters
    # @return [Array<(ExtensionPool, Fixnum, Hash)>] ExtensionPool data, response status code and response headers
    def get_extensionpools_extensionpool_id_with_http_info(extension_pool_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConfigurationApi#get_extensionpools_extensionpool_id ..."
      end
      
      # verify the required parameter 'extension_pool_id' is set
      fail "Missing the required parameter 'extension_pool_id' when calling get_extensionpools_extensionpool_id" if extension_pool_id.nil?
      
      # resource path
      path = "/api/v1/configuration/extensionpools/{extensionPoolId}".sub('{format}','json').sub('{' + 'extensionPoolId' + '}', extension_pool_id.to_s)

      # query parameters
      query_params = {}

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = nil
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:GET, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => 'ExtensionPool')
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConfigurationApi#get_extensionpools_extensionpool_id\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Update an extension pool by ID
    # 
    # @param extension_pool_id Extension pool ID
    # @param [Hash] opts the optional parameters
    # @option opts [ExtensionPool] :body ExtensionPool
    # @return [ExtensionPool]
    def put_extensionpools_extensionpool_id(extension_pool_id, opts = {})
      data, status_code, headers = put_extensionpools_extensionpool_id_with_http_info(extension_pool_id, opts)
      return data
    end

    # Update an extension pool by ID
    # 
    # @param extension_pool_id Extension pool ID
    # @param [Hash] opts the optional parameters
    # @option opts [ExtensionPool] :body ExtensionPool
    # @return [Array<(ExtensionPool, Fixnum, Hash)>] ExtensionPool data, response status code and response headers
    def put_extensionpools_extensionpool_id_with_http_info(extension_pool_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConfigurationApi#put_extensionpools_extensionpool_id ..."
      end
      
      # verify the required parameter 'extension_pool_id' is set
      fail "Missing the required parameter 'extension_pool_id' when calling put_extensionpools_extensionpool_id" if extension_pool_id.nil?
      
      # resource path
      path = "/api/v1/configuration/extensionpools/{extensionPoolId}".sub('{format}','json').sub('{' + 'extensionPoolId' + '}', extension_pool_id.to_s)

      # query parameters
      query_params = {}

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = @api_client.object_to_http_body(opts[:'body'])
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:PUT, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => 'ExtensionPool')
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConfigurationApi#put_extensionpools_extensionpool_id\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Delete an extension pool by ID
    # 
    # @param extension_pool_id Extension pool ID
    # @param [Hash] opts the optional parameters
    # @return [String]
    def delete_extensionpools_extensionpool_id(extension_pool_id, opts = {})
      data, status_code, headers = delete_extensionpools_extensionpool_id_with_http_info(extension_pool_id, opts)
      return data
    end

    # Delete an extension pool by ID
    # 
    # @param extension_pool_id Extension pool ID
    # @param [Hash] opts the optional parameters
    # @return [Array<(String, Fixnum, Hash)>] String data, response status code and response headers
    def delete_extensionpools_extensionpool_id_with_http_info(extension_pool_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConfigurationApi#delete_extensionpools_extensionpool_id ..."
      end
      
      # verify the required parameter 'extension_pool_id' is set
      fail "Missing the required parameter 'extension_pool_id' when calling delete_extensionpools_extensionpool_id" if extension_pool_id.nil?
      
      # resource path
      path = "/api/v1/configuration/extensionpools/{extensionPoolId}".sub('{format}','json').sub('{' + 'extensionPoolId' + '}', extension_pool_id.to_s)

      # query parameters
      query_params = {}

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = nil
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:DELETE, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => 'String')
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConfigurationApi#delete_extensionpools_extensionpool_id\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Get a listing of extensions
    # 
    # @param [Hash] opts the optional parameters
    # @option opts [Integer] :page_size Page size
    # @option opts [Integer] :page_number Page number
    # @option opts [String] :sort_by Sort by
    # @option opts [String] :sort_order Sort order
    # @option opts [String] :number Filter by number
    # @return [ExtensionEntityListing]
    def get_extensions(opts = {})
      data, status_code, headers = get_extensions_with_http_info(opts)
      return data
    end

    # Get a listing of extensions
    # 
    # @param [Hash] opts the optional parameters
    # @option opts [Integer] :page_size Page size
    # @option opts [Integer] :page_number Page number
    # @option opts [String] :sort_by Sort by
    # @option opts [String] :sort_order Sort order
    # @option opts [String] :number Filter by number
    # @return [Array<(ExtensionEntityListing, Fixnum, Hash)>] ExtensionEntityListing data, response status code and response headers
    def get_extensions_with_http_info(opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConfigurationApi#get_extensions ..."
      end
      
      # resource path
      path = "/api/v1/configuration/extensions".sub('{format}','json')

      # query parameters
      query_params = {}
      query_params[:'pageSize'] = opts[:'page_size'] if opts[:'page_size']
      query_params[:'pageNumber'] = opts[:'page_number'] if opts[:'page_number']
      query_params[:'sortBy'] = opts[:'sort_by'] if opts[:'sort_by']
      query_params[:'sortOrder'] = opts[:'sort_order'] if opts[:'sort_order']
      query_params[:'number'] = opts[:'number'] if opts[:'number']

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = nil
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:GET, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => 'ExtensionEntityListing')
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConfigurationApi#get_extensions\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Get an extension by ID.
    # 
    # @param extension_id Extension ID
    # @param [Hash] opts the optional parameters
    # @return [Extension]
    def get_extensions_extension_id(extension_id, opts = {})
      data, status_code, headers = get_extensions_extension_id_with_http_info(extension_id, opts)
      return data
    end

    # Get an extension by ID.
    # 
    # @param extension_id Extension ID
    # @param [Hash] opts the optional parameters
    # @return [Array<(Extension, Fixnum, Hash)>] Extension data, response status code and response headers
    def get_extensions_extension_id_with_http_info(extension_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConfigurationApi#get_extensions_extension_id ..."
      end
      
      # verify the required parameter 'extension_id' is set
      fail "Missing the required parameter 'extension_id' when calling get_extensions_extension_id" if extension_id.nil?
      
      # resource path
      path = "/api/v1/configuration/extensions/{extensionId}".sub('{format}','json').sub('{' + 'extensionId' + '}', extension_id.to_s)

      # query parameters
      query_params = {}

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = nil
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:GET, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => 'Extension')
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConfigurationApi#get_extensions_extension_id\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Update an extension by ID.
    # 
    # @param extension_id Extension ID
    # @param [Hash] opts the optional parameters
    # @option opts [Extension] :body 
    # @return [Extension]
    def put_extensions_extension_id(extension_id, opts = {})
      data, status_code, headers = put_extensions_extension_id_with_http_info(extension_id, opts)
      return data
    end

    # Update an extension by ID.
    # 
    # @param extension_id Extension ID
    # @param [Hash] opts the optional parameters
    # @option opts [Extension] :body 
    # @return [Array<(Extension, Fixnum, Hash)>] Extension data, response status code and response headers
    def put_extensions_extension_id_with_http_info(extension_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConfigurationApi#put_extensions_extension_id ..."
      end
      
      # verify the required parameter 'extension_id' is set
      fail "Missing the required parameter 'extension_id' when calling put_extensions_extension_id" if extension_id.nil?
      
      # resource path
      path = "/api/v1/configuration/extensions/{extensionId}".sub('{format}','json').sub('{' + 'extensionId' + '}', extension_id.to_s)

      # query parameters
      query_params = {}

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = @api_client.object_to_http_body(opts[:'body'])
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:PUT, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => 'Extension')
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConfigurationApi#put_extensions_extension_id\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Get context organization.
    # 
    # @param [Hash] opts the optional parameters
    # @return [Organization]
    def get_organization(opts = {})
      data, status_code, headers = get_organization_with_http_info(opts)
      return data
    end

    # Get context organization.
    # 
    # @param [Hash] opts the optional parameters
    # @return [Array<(Organization, Fixnum, Hash)>] Organization data, response status code and response headers
    def get_organization_with_http_info(opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConfigurationApi#get_organization ..."
      end
      
      # resource path
      path = "/api/v1/configuration/organization".sub('{format}','json')

      # query parameters
      query_params = {}

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = nil
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:GET, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => 'Organization')
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConfigurationApi#get_organization\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Update context organization.
    # 
    # @param [Hash] opts the optional parameters
    # @option opts [Organization] :body Organization
    # @return [Organization]
    def put_organization(opts = {})
      data, status_code, headers = put_organization_with_http_info(opts)
      return data
    end

    # Update context organization.
    # 
    # @param [Hash] opts the optional parameters
    # @option opts [Organization] :body Organization
    # @return [Array<(Organization, Fixnum, Hash)>] Organization data, response status code and response headers
    def put_organization_with_http_info(opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConfigurationApi#put_organization ..."
      end
      
      # resource path
      path = "/api/v1/configuration/organization".sub('{format}','json')

      # query parameters
      query_params = {}

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = @api_client.object_to_http_body(opts[:'body'])
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:PUT, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => 'Organization')
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConfigurationApi#put_organization\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Create organization.
    # 
    # @param [Hash] opts the optional parameters
    # @option opts [OrganizationCreate] :body Organization
    # @return [Organization]
    def post_organizations(opts = {})
      data, status_code, headers = post_organizations_with_http_info(opts)
      return data
    end

    # Create organization.
    # 
    # @param [Hash] opts the optional parameters
    # @option opts [OrganizationCreate] :body Organization
    # @return [Array<(Organization, Fixnum, Hash)>] Organization data, response status code and response headers
    def post_organizations_with_http_info(opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConfigurationApi#post_organizations ..."
      end
      
      # resource path
      path = "/api/v1/configuration/organizations".sub('{format}','json')

      # query parameters
      query_params = {}

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = @api_client.object_to_http_body(opts[:'body'])
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:POST, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => 'Organization')
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConfigurationApi#post_organizations\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Get organization.
    # 
    # @param org_id Organization ID
    # @param [Hash] opts the optional parameters
    # @return [Organization]
    def get_organizations_org_id(org_id, opts = {})
      data, status_code, headers = get_organizations_org_id_with_http_info(org_id, opts)
      return data
    end

    # Get organization.
    # 
    # @param org_id Organization ID
    # @param [Hash] opts the optional parameters
    # @return [Array<(Organization, Fixnum, Hash)>] Organization data, response status code and response headers
    def get_organizations_org_id_with_http_info(org_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConfigurationApi#get_organizations_org_id ..."
      end
      
      # verify the required parameter 'org_id' is set
      fail "Missing the required parameter 'org_id' when calling get_organizations_org_id" if org_id.nil?
      
      # resource path
      path = "/api/v1/configuration/organizations/{orgId}".sub('{format}','json').sub('{' + 'orgId' + '}', org_id.to_s)

      # query parameters
      query_params = {}

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = nil
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:GET, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => 'Organization')
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConfigurationApi#get_organizations_org_id\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Update organization.
    # 
    # @param org_id Organization ID
    # @param [Hash] opts the optional parameters
    # @option opts [Organization] :body Organization
    # @return [Organization]
    def put_organizations_org_id(org_id, opts = {})
      data, status_code, headers = put_organizations_org_id_with_http_info(org_id, opts)
      return data
    end

    # Update organization.
    # 
    # @param org_id Organization ID
    # @param [Hash] opts the optional parameters
    # @option opts [Organization] :body Organization
    # @return [Array<(Organization, Fixnum, Hash)>] Organization data, response status code and response headers
    def put_organizations_org_id_with_http_info(org_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConfigurationApi#put_organizations_org_id ..."
      end
      
      # verify the required parameter 'org_id' is set
      fail "Missing the required parameter 'org_id' when calling put_organizations_org_id" if org_id.nil?
      
      # resource path
      path = "/api/v1/configuration/organizations/{orgId}".sub('{format}','json').sub('{' + 'orgId' + '}', org_id.to_s)

      # query parameters
      query_params = {}

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = @api_client.object_to_http_body(opts[:'body'])
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:PUT, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => 'Organization')
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConfigurationApi#put_organizations_org_id\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Delete an organization.
    # 
    # @param org_id Organization ID
    # @param [Hash] opts the optional parameters
    # @return [String]
    def delete_organizations_org_id(org_id, opts = {})
      data, status_code, headers = delete_organizations_org_id_with_http_info(org_id, opts)
      return data
    end

    # Delete an organization.
    # 
    # @param org_id Organization ID
    # @param [Hash] opts the optional parameters
    # @return [Array<(String, Fixnum, Hash)>] String data, response status code and response headers
    def delete_organizations_org_id_with_http_info(org_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConfigurationApi#delete_organizations_org_id ..."
      end
      
      # verify the required parameter 'org_id' is set
      fail "Missing the required parameter 'org_id' when calling delete_organizations_org_id" if org_id.nil?
      
      # resource path
      path = "/api/v1/configuration/organizations/{orgId}".sub('{format}','json').sub('{' + 'orgId' + '}', org_id.to_s)

      # query parameters
      query_params = {}

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = nil
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:DELETE, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => 'String')
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConfigurationApi#delete_organizations_org_id\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Get encryption key list
    # 
    # @param [Hash] opts the optional parameters
    # @option opts [Integer] :page_size Page size
    # @option opts [Integer] :page_number Page number
    # @return [EncryptionKeyEntityListing]
    def get_recordingkeys(opts = {})
      data, status_code, headers = get_recordingkeys_with_http_info(opts)
      return data
    end

    # Get encryption key list
    # 
    # @param [Hash] opts the optional parameters
    # @option opts [Integer] :page_size Page size
    # @option opts [Integer] :page_number Page number
    # @return [Array<(EncryptionKeyEntityListing, Fixnum, Hash)>] EncryptionKeyEntityListing data, response status code and response headers
    def get_recordingkeys_with_http_info(opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConfigurationApi#get_recordingkeys ..."
      end
      
      # resource path
      path = "/api/v1/configuration/recordingkeys".sub('{format}','json')

      # query parameters
      query_params = {}
      query_params[:'pageSize'] = opts[:'page_size'] if opts[:'page_size']
      query_params[:'pageNumber'] = opts[:'page_number'] if opts[:'page_number']

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = nil
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:GET, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => 'EncryptionKeyEntityListing')
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConfigurationApi#get_recordingkeys\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Create encryption key
    # 
    # @param [Hash] opts the optional parameters
    # @return [EncryptionKey]
    def post_recordingkeys(opts = {})
      data, status_code, headers = post_recordingkeys_with_http_info(opts)
      return data
    end

    # Create encryption key
    # 
    # @param [Hash] opts the optional parameters
    # @return [Array<(EncryptionKey, Fixnum, Hash)>] EncryptionKey data, response status code and response headers
    def post_recordingkeys_with_http_info(opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConfigurationApi#post_recordingkeys ..."
      end
      
      # resource path
      path = "/api/v1/configuration/recordingkeys".sub('{format}','json')

      # query parameters
      query_params = {}

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = nil
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:POST, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => 'EncryptionKey')
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConfigurationApi#post_recordingkeys\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Get key rotation schedule
    # 
    # @param [Hash] opts the optional parameters
    # @return [KeyRotationSchedule]
    def get_recordingkeys_rotationschedule(opts = {})
      data, status_code, headers = get_recordingkeys_rotationschedule_with_http_info(opts)
      return data
    end

    # Get key rotation schedule
    # 
    # @param [Hash] opts the optional parameters
    # @return [Array<(KeyRotationSchedule, Fixnum, Hash)>] KeyRotationSchedule data, response status code and response headers
    def get_recordingkeys_rotationschedule_with_http_info(opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConfigurationApi#get_recordingkeys_rotationschedule ..."
      end
      
      # resource path
      path = "/api/v1/configuration/recordingkeys/rotationschedule".sub('{format}','json')

      # query parameters
      query_params = {}

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = nil
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:GET, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => 'KeyRotationSchedule')
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConfigurationApi#get_recordingkeys_rotationschedule\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Update key rotation schedule
    # 
    # @param [Hash] opts the optional parameters
    # @option opts [KeyRotationSchedule] :body KeyRotationSchedule
    # @return [KeyRotationSchedule]
    def put_recordingkeys_rotationschedule(opts = {})
      data, status_code, headers = put_recordingkeys_rotationschedule_with_http_info(opts)
      return data
    end

    # Update key rotation schedule
    # 
    # @param [Hash] opts the optional parameters
    # @option opts [KeyRotationSchedule] :body KeyRotationSchedule
    # @return [Array<(KeyRotationSchedule, Fixnum, Hash)>] KeyRotationSchedule data, response status code and response headers
    def put_recordingkeys_rotationschedule_with_http_info(opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConfigurationApi#put_recordingkeys_rotationschedule ..."
      end
      
      # resource path
      path = "/api/v1/configuration/recordingkeys/rotationschedule".sub('{format}','json')

      # query parameters
      query_params = {}

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = @api_client.object_to_http_body(opts[:'body'])
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:PUT, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => 'KeyRotationSchedule')
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConfigurationApi#put_recordingkeys_rotationschedule\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Gets retention policy list with query options to filter on name and enabled.
    # for a less verbose response, add summary=true to this endpoint
    # @param [Hash] opts the optional parameters
    # @option opts [Integer] :page_size The total page size requested
    # @option opts [Integer] :page_number The page number requested
    # @option opts [String] :sort_by variable name requested to sort by
    # @option opts [Array<String>] :expand variable name requested by expand list
    # @option opts [String] :name the policy name - used for filtering results in searches.
    # @option opts [BOOLEAN] :enabled checks to see if policy is enabled - use enabled = true or enabled = false
    # @option opts [BOOLEAN] :summary provides a less verbose response of policy lists.
    # @option opts [BOOLEAN] :has_errors provides a way to fetch all policies with errors or policies that do not have errors
    # @return [PolicyEntityListing]
    def get_retentionpolicies(opts = {})
      data, status_code, headers = get_retentionpolicies_with_http_info(opts)
      return data
    end

    # Gets retention policy list with query options to filter on name and enabled.
    # for a less verbose response, add summary=true to this endpoint
    # @param [Hash] opts the optional parameters
    # @option opts [Integer] :page_size The total page size requested
    # @option opts [Integer] :page_number The page number requested
    # @option opts [String] :sort_by variable name requested to sort by
    # @option opts [Array<String>] :expand variable name requested by expand list
    # @option opts [String] :name the policy name - used for filtering results in searches.
    # @option opts [BOOLEAN] :enabled checks to see if policy is enabled - use enabled = true or enabled = false
    # @option opts [BOOLEAN] :summary provides a less verbose response of policy lists.
    # @option opts [BOOLEAN] :has_errors provides a way to fetch all policies with errors or policies that do not have errors
    # @return [Array<(PolicyEntityListing, Fixnum, Hash)>] PolicyEntityListing data, response status code and response headers
    def get_retentionpolicies_with_http_info(opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConfigurationApi#get_retentionpolicies ..."
      end
      
      # resource path
      path = "/api/v1/configuration/retentionpolicies".sub('{format}','json')

      # query parameters
      query_params = {}
      query_params[:'pageSize'] = opts[:'page_size'] if opts[:'page_size']
      query_params[:'pageNumber'] = opts[:'page_number'] if opts[:'page_number']
      query_params[:'sortBy'] = opts[:'sort_by'] if opts[:'sort_by']
      query_params[:'expand'] = @api_client.build_collection_param(opts[:'expand'], :multi) if opts[:'expand']
      query_params[:'name'] = opts[:'name'] if opts[:'name']
      query_params[:'enabled'] = opts[:'enabled'] if opts[:'enabled']
      query_params[:'summary'] = opts[:'summary'] if opts[:'summary']
      query_params[:'hasErrors'] = opts[:'has_errors'] if opts[:'has_errors']

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = nil
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:GET, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => 'PolicyEntityListing')
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConfigurationApi#get_retentionpolicies\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Create retention policy
    # 
    # @param [Hash] opts the optional parameters
    # @option opts [Policy] :body Policy
    # @return [Policy]
    def post_retentionpolicies(opts = {})
      data, status_code, headers = post_retentionpolicies_with_http_info(opts)
      return data
    end

    # Create retention policy
    # 
    # @param [Hash] opts the optional parameters
    # @option opts [Policy] :body Policy
    # @return [Array<(Policy, Fixnum, Hash)>] Policy data, response status code and response headers
    def post_retentionpolicies_with_http_info(opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConfigurationApi#post_retentionpolicies ..."
      end
      
      # resource path
      path = "/api/v1/configuration/retentionpolicies".sub('{format}','json')

      # query parameters
      query_params = {}

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = @api_client.object_to_http_body(opts[:'body'])
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:POST, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => 'Policy')
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConfigurationApi#post_retentionpolicies\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Delete policies
    # Bulk delete of Rules from specified rule set, this will only delete the rules that match the ids specified in the query param.
    # @param ids 
    # @param [Hash] opts the optional parameters
    # @return [String]
    def delete_retentionpolicies(ids, opts = {})
      data, status_code, headers = delete_retentionpolicies_with_http_info(ids, opts)
      return data
    end

    # Delete policies
    # Bulk delete of Rules from specified rule set, this will only delete the rules that match the ids specified in the query param.
    # @param ids 
    # @param [Hash] opts the optional parameters
    # @return [Array<(String, Fixnum, Hash)>] String data, response status code and response headers
    def delete_retentionpolicies_with_http_info(ids, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConfigurationApi#delete_retentionpolicies ..."
      end
      
      # verify the required parameter 'ids' is set
      fail "Missing the required parameter 'ids' when calling delete_retentionpolicies" if ids.nil?
      
      # resource path
      path = "/api/v1/configuration/retentionpolicies".sub('{format}','json')

      # query parameters
      query_params = {}
      query_params[:'ids'] = ids

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = nil
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:DELETE, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => 'String')
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConfigurationApi#delete_retentionpolicies\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Get policy
    # 
    # @param policy_id Policy ID
    # @param [Hash] opts the optional parameters
    # @return [Policy]
    def get_retentionpolicies_policy_id(policy_id, opts = {})
      data, status_code, headers = get_retentionpolicies_policy_id_with_http_info(policy_id, opts)
      return data
    end

    # Get policy
    # 
    # @param policy_id Policy ID
    # @param [Hash] opts the optional parameters
    # @return [Array<(Policy, Fixnum, Hash)>] Policy data, response status code and response headers
    def get_retentionpolicies_policy_id_with_http_info(policy_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConfigurationApi#get_retentionpolicies_policy_id ..."
      end
      
      # verify the required parameter 'policy_id' is set
      fail "Missing the required parameter 'policy_id' when calling get_retentionpolicies_policy_id" if policy_id.nil?
      
      # resource path
      path = "/api/v1/configuration/retentionpolicies/{policyId}".sub('{format}','json').sub('{' + 'policyId' + '}', policy_id.to_s)

      # query parameters
      query_params = {}

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = nil
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:GET, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => 'Policy')
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConfigurationApi#get_retentionpolicies_policy_id\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Update policy
    # 
    # @param policy_id Policy ID
    # @param [Hash] opts the optional parameters
    # @option opts [Policy] :body Policy
    # @return [Policy]
    def put_retentionpolicies_policy_id(policy_id, opts = {})
      data, status_code, headers = put_retentionpolicies_policy_id_with_http_info(policy_id, opts)
      return data
    end

    # Update policy
    # 
    # @param policy_id Policy ID
    # @param [Hash] opts the optional parameters
    # @option opts [Policy] :body Policy
    # @return [Array<(Policy, Fixnum, Hash)>] Policy data, response status code and response headers
    def put_retentionpolicies_policy_id_with_http_info(policy_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConfigurationApi#put_retentionpolicies_policy_id ..."
      end
      
      # verify the required parameter 'policy_id' is set
      fail "Missing the required parameter 'policy_id' when calling put_retentionpolicies_policy_id" if policy_id.nil?
      
      # resource path
      path = "/api/v1/configuration/retentionpolicies/{policyId}".sub('{format}','json').sub('{' + 'policyId' + '}', policy_id.to_s)

      # query parameters
      query_params = {}

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = @api_client.object_to_http_body(opts[:'body'])
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:PUT, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => 'Policy')
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConfigurationApi#put_retentionpolicies_policy_id\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Delete policy
    # 
    # @param policy_id Policy ID
    # @param [Hash] opts the optional parameters
    # @return [String]
    def delete_retentionpolicies_policy_id(policy_id, opts = {})
      data, status_code, headers = delete_retentionpolicies_policy_id_with_http_info(policy_id, opts)
      return data
    end

    # Delete policy
    # 
    # @param policy_id Policy ID
    # @param [Hash] opts the optional parameters
    # @return [Array<(String, Fixnum, Hash)>] String data, response status code and response headers
    def delete_retentionpolicies_policy_id_with_http_info(policy_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConfigurationApi#delete_retentionpolicies_policy_id ..."
      end
      
      # verify the required parameter 'policy_id' is set
      fail "Missing the required parameter 'policy_id' when calling delete_retentionpolicies_policy_id" if policy_id.nil?
      
      # resource path
      path = "/api/v1/configuration/retentionpolicies/{policyId}".sub('{format}','json').sub('{' + 'policyId' + '}', policy_id.to_s)

      # query parameters
      query_params = {}

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = nil
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:DELETE, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => 'String')
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConfigurationApi#delete_retentionpolicies_policy_id\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Patch a retention policy
    # 
    # @param policy_id Policy ID
    # @param [Hash] opts the optional parameters
    # @option opts [Policy] :body Policy
    # @return [Policy]
    def patch_retentionpolicies_policy_id(policy_id, opts = {})
      data, status_code, headers = patch_retentionpolicies_policy_id_with_http_info(policy_id, opts)
      return data
    end

    # Patch a retention policy
    # 
    # @param policy_id Policy ID
    # @param [Hash] opts the optional parameters
    # @option opts [Policy] :body Policy
    # @return [Array<(Policy, Fixnum, Hash)>] Policy data, response status code and response headers
    def patch_retentionpolicies_policy_id_with_http_info(policy_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConfigurationApi#patch_retentionpolicies_policy_id ..."
      end
      
      # verify the required parameter 'policy_id' is set
      fail "Missing the required parameter 'policy_id' when calling patch_retentionpolicies_policy_id" if policy_id.nil?
      
      # resource path
      path = "/api/v1/configuration/retentionpolicies/{policyId}".sub('{format}','json').sub('{' + 'policyId' + '}', policy_id.to_s)

      # query parameters
      query_params = {}

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = @api_client.object_to_http_body(opts[:'body'])
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:PATCH, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => 'Policy')
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConfigurationApi#patch_retentionpolicies_policy_id\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Lists available schema categories
    # 
    # @param [Hash] opts the optional parameters
    # @option opts [Integer] :page_size Page size
    # @option opts [Integer] :page_number Page number
    # @return [SchemaCategoryEntityListing]
    def get_schemas_edges_vnext(opts = {})
      data, status_code, headers = get_schemas_edges_vnext_with_http_info(opts)
      return data
    end

    # Lists available schema categories
    # 
    # @param [Hash] opts the optional parameters
    # @option opts [Integer] :page_size Page size
    # @option opts [Integer] :page_number Page number
    # @return [Array<(SchemaCategoryEntityListing, Fixnum, Hash)>] SchemaCategoryEntityListing data, response status code and response headers
    def get_schemas_edges_vnext_with_http_info(opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConfigurationApi#get_schemas_edges_vnext ..."
      end
      
      # resource path
      path = "/api/v1/configuration/schemas/edges/vnext".sub('{format}','json')

      # query parameters
      query_params = {}
      query_params[:'pageSize'] = opts[:'page_size'] if opts[:'page_size']
      query_params[:'pageNumber'] = opts[:'page_number'] if opts[:'page_number']

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = nil
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:GET, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => 'SchemaCategoryEntityListing')
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConfigurationApi#get_schemas_edges_vnext\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # List schemas of a specific category
    # 
    # @param schema_category Schema category
    # @param [Hash] opts the optional parameters
    # @option opts [Integer] :page_size Page size
    # @option opts [Integer] :page_number Page number
    # @return [SchemaReferenceEntityListing]
    def get_schemas_edges_vnext_schemacategory(schema_category, opts = {})
      data, status_code, headers = get_schemas_edges_vnext_schemacategory_with_http_info(schema_category, opts)
      return data
    end

    # List schemas of a specific category
    # 
    # @param schema_category Schema category
    # @param [Hash] opts the optional parameters
    # @option opts [Integer] :page_size Page size
    # @option opts [Integer] :page_number Page number
    # @return [Array<(SchemaReferenceEntityListing, Fixnum, Hash)>] SchemaReferenceEntityListing data, response status code and response headers
    def get_schemas_edges_vnext_schemacategory_with_http_info(schema_category, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConfigurationApi#get_schemas_edges_vnext_schemacategory ..."
      end
      
      # verify the required parameter 'schema_category' is set
      fail "Missing the required parameter 'schema_category' when calling get_schemas_edges_vnext_schemacategory" if schema_category.nil?
      
      # resource path
      path = "/api/v1/configuration/schemas/edges/vnext/{schemaCategory}".sub('{format}','json').sub('{' + 'schemaCategory' + '}', schema_category.to_s)

      # query parameters
      query_params = {}
      query_params[:'pageSize'] = opts[:'page_size'] if opts[:'page_size']
      query_params[:'pageNumber'] = opts[:'page_number'] if opts[:'page_number']

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = nil
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:GET, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => 'SchemaReferenceEntityListing')
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConfigurationApi#get_schemas_edges_vnext_schemacategory\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # List schemas of a specific category
    # 
    # @param schema_category Schema category
    # @param schema_type Schema type
    # @param [Hash] opts the optional parameters
    # @option opts [Integer] :page_size Page size
    # @option opts [Integer] :page_number Page number
    # @return [SchemaReferenceEntityListing]
    def get_schemas_edges_vnext_schemacategory_schematype(schema_category, schema_type, opts = {})
      data, status_code, headers = get_schemas_edges_vnext_schemacategory_schematype_with_http_info(schema_category, schema_type, opts)
      return data
    end

    # List schemas of a specific category
    # 
    # @param schema_category Schema category
    # @param schema_type Schema type
    # @param [Hash] opts the optional parameters
    # @option opts [Integer] :page_size Page size
    # @option opts [Integer] :page_number Page number
    # @return [Array<(SchemaReferenceEntityListing, Fixnum, Hash)>] SchemaReferenceEntityListing data, response status code and response headers
    def get_schemas_edges_vnext_schemacategory_schematype_with_http_info(schema_category, schema_type, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConfigurationApi#get_schemas_edges_vnext_schemacategory_schematype ..."
      end
      
      # verify the required parameter 'schema_category' is set
      fail "Missing the required parameter 'schema_category' when calling get_schemas_edges_vnext_schemacategory_schematype" if schema_category.nil?
      
      # verify the required parameter 'schema_type' is set
      fail "Missing the required parameter 'schema_type' when calling get_schemas_edges_vnext_schemacategory_schematype" if schema_type.nil?
      
      # resource path
      path = "/api/v1/configuration/schemas/edges/vnext/{schemaCategory}/{schemaType}".sub('{format}','json').sub('{' + 'schemaCategory' + '}', schema_category.to_s).sub('{' + 'schemaType' + '}', schema_type.to_s)

      # query parameters
      query_params = {}
      query_params[:'pageSize'] = opts[:'page_size'] if opts[:'page_size']
      query_params[:'pageNumber'] = opts[:'page_number'] if opts[:'page_number']

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = nil
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:GET, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => 'SchemaReferenceEntityListing')
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConfigurationApi#get_schemas_edges_vnext_schemacategory_schematype\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Get a json schema
    # 
    # @param schema_category Schema category
    # @param schema_type Schema type
    # @param schema_id Schema ID
    # @param [Hash] opts the optional parameters
    # @return [Organization]
    def get_schemas_edges_vnext_schemacategory_schematype_schema_id(schema_category, schema_type, schema_id, opts = {})
      data, status_code, headers = get_schemas_edges_vnext_schemacategory_schematype_schema_id_with_http_info(schema_category, schema_type, schema_id, opts)
      return data
    end

    # Get a json schema
    # 
    # @param schema_category Schema category
    # @param schema_type Schema type
    # @param schema_id Schema ID
    # @param [Hash] opts the optional parameters
    # @return [Array<(Organization, Fixnum, Hash)>] Organization data, response status code and response headers
    def get_schemas_edges_vnext_schemacategory_schematype_schema_id_with_http_info(schema_category, schema_type, schema_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConfigurationApi#get_schemas_edges_vnext_schemacategory_schematype_schema_id ..."
      end
      
      # verify the required parameter 'schema_category' is set
      fail "Missing the required parameter 'schema_category' when calling get_schemas_edges_vnext_schemacategory_schematype_schema_id" if schema_category.nil?
      
      # verify the required parameter 'schema_type' is set
      fail "Missing the required parameter 'schema_type' when calling get_schemas_edges_vnext_schemacategory_schematype_schema_id" if schema_type.nil?
      
      # verify the required parameter 'schema_id' is set
      fail "Missing the required parameter 'schema_id' when calling get_schemas_edges_vnext_schemacategory_schematype_schema_id" if schema_id.nil?
      
      # resource path
      path = "/api/v1/configuration/schemas/edges/vnext/{schemaCategory}/{schemaType}/{schemaId}".sub('{format}','json').sub('{' + 'schemaCategory' + '}', schema_category.to_s).sub('{' + 'schemaType' + '}', schema_type.to_s).sub('{' + 'schemaId' + '}', schema_id.to_s)

      # query parameters
      query_params = {}

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = nil
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:GET, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => 'Organization')
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConfigurationApi#get_schemas_edges_vnext_schemacategory_schematype_schema_id\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Get metadata for a schema
    # 
    # @param schema_category Schema category
    # @param schema_type Schema type
    # @param schema_id Schema ID
    # @param extension extension
    # @param metadata_id Metadata ID
    # @param [Hash] opts the optional parameters
    # @option opts [String] :type Type
    # @return [Organization]
    def get_schemas_edges_vnext_schemacategory_schematype_schema_id_extension_metadata_id(schema_category, schema_type, schema_id, extension, metadata_id, opts = {})
      data, status_code, headers = get_schemas_edges_vnext_schemacategory_schematype_schema_id_extension_metadata_id_with_http_info(schema_category, schema_type, schema_id, extension, metadata_id, opts)
      return data
    end

    # Get metadata for a schema
    # 
    # @param schema_category Schema category
    # @param schema_type Schema type
    # @param schema_id Schema ID
    # @param extension extension
    # @param metadata_id Metadata ID
    # @param [Hash] opts the optional parameters
    # @option opts [String] :type Type
    # @return [Array<(Organization, Fixnum, Hash)>] Organization data, response status code and response headers
    def get_schemas_edges_vnext_schemacategory_schematype_schema_id_extension_metadata_id_with_http_info(schema_category, schema_type, schema_id, extension, metadata_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConfigurationApi#get_schemas_edges_vnext_schemacategory_schematype_schema_id_extension_metadata_id ..."
      end
      
      # verify the required parameter 'schema_category' is set
      fail "Missing the required parameter 'schema_category' when calling get_schemas_edges_vnext_schemacategory_schematype_schema_id_extension_metadata_id" if schema_category.nil?
      
      # verify the required parameter 'schema_type' is set
      fail "Missing the required parameter 'schema_type' when calling get_schemas_edges_vnext_schemacategory_schematype_schema_id_extension_metadata_id" if schema_type.nil?
      
      # verify the required parameter 'schema_id' is set
      fail "Missing the required parameter 'schema_id' when calling get_schemas_edges_vnext_schemacategory_schematype_schema_id_extension_metadata_id" if schema_id.nil?
      
      # verify the required parameter 'extension' is set
      fail "Missing the required parameter 'extension' when calling get_schemas_edges_vnext_schemacategory_schematype_schema_id_extension_metadata_id" if extension.nil?
      
      # verify the required parameter 'metadata_id' is set
      fail "Missing the required parameter 'metadata_id' when calling get_schemas_edges_vnext_schemacategory_schematype_schema_id_extension_metadata_id" if metadata_id.nil?
      
      # resource path
      path = "/api/v1/configuration/schemas/edges/vnext/{schemaCategory}/{schemaType}/{schemaId}/{extension}/{metadataId}".sub('{format}','json').sub('{' + 'schemaCategory' + '}', schema_category.to_s).sub('{' + 'schemaType' + '}', schema_type.to_s).sub('{' + 'schemaId' + '}', schema_id.to_s).sub('{' + 'extension' + '}', extension.to_s).sub('{' + 'metadataId' + '}', metadata_id.to_s)

      # query parameters
      query_params = {}
      query_params[:'type'] = opts[:'type'] if opts[:'type']

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = nil
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:GET, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => 'Organization')
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConfigurationApi#get_schemas_edges_vnext_schemacategory_schematype_schema_id_extension_metadata_id\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Get the list of sites.
    # 
    # @param [Hash] opts the optional parameters
    # @option opts [Integer] :page_size Page size
    # @option opts [Integer] :page_number Page number
    # @option opts [String] :sort_by Sort by
    # @option opts [String] :sort_order Sort order
    # @option opts [String] :name Name
    # @option opts [String] :location_id Location Id
    # @return [SiteEntityListing]
    def get_sites(opts = {})
      data, status_code, headers = get_sites_with_http_info(opts)
      return data
    end

    # Get the list of sites.
    # 
    # @param [Hash] opts the optional parameters
    # @option opts [Integer] :page_size Page size
    # @option opts [Integer] :page_number Page number
    # @option opts [String] :sort_by Sort by
    # @option opts [String] :sort_order Sort order
    # @option opts [String] :name Name
    # @option opts [String] :location_id Location Id
    # @return [Array<(SiteEntityListing, Fixnum, Hash)>] SiteEntityListing data, response status code and response headers
    def get_sites_with_http_info(opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConfigurationApi#get_sites ..."
      end
      
      # resource path
      path = "/api/v1/configuration/sites".sub('{format}','json')

      # query parameters
      query_params = {}
      query_params[:'pageSize'] = opts[:'page_size'] if opts[:'page_size']
      query_params[:'pageNumber'] = opts[:'page_number'] if opts[:'page_number']
      query_params[:'sortBy'] = opts[:'sort_by'] if opts[:'sort_by']
      query_params[:'sortOrder'] = opts[:'sort_order'] if opts[:'sort_order']
      query_params[:'name'] = opts[:'name'] if opts[:'name']
      query_params[:'location.id'] = opts[:'location_id'] if opts[:'location_id']

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = nil
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:GET, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => 'SiteEntityListing')
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConfigurationApi#get_sites\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Create a endpoint.
    # 
    # @param [Hash] opts the optional parameters
    # @option opts [Site] :body Site
    # @return [Site]
    def post_sites(opts = {})
      data, status_code, headers = post_sites_with_http_info(opts)
      return data
    end

    # Create a endpoint.
    # 
    # @param [Hash] opts the optional parameters
    # @option opts [Site] :body Site
    # @return [Array<(Site, Fixnum, Hash)>] Site data, response status code and response headers
    def post_sites_with_http_info(opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConfigurationApi#post_sites ..."
      end
      
      # resource path
      path = "/api/v1/configuration/sites".sub('{format}','json')

      # query parameters
      query_params = {}

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = @api_client.object_to_http_body(opts[:'body'])
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:POST, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => 'Site')
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConfigurationApi#post_sites\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Get endpoint.
    # 
    # @param site_id Site ID
    # @param [Hash] opts the optional parameters
    # @return [Site]
    def get_sites_site_id(site_id, opts = {})
      data, status_code, headers = get_sites_site_id_with_http_info(site_id, opts)
      return data
    end

    # Get endpoint.
    # 
    # @param site_id Site ID
    # @param [Hash] opts the optional parameters
    # @return [Array<(Site, Fixnum, Hash)>] Site data, response status code and response headers
    def get_sites_site_id_with_http_info(site_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConfigurationApi#get_sites_site_id ..."
      end
      
      # verify the required parameter 'site_id' is set
      fail "Missing the required parameter 'site_id' when calling get_sites_site_id" if site_id.nil?
      
      # resource path
      path = "/api/v1/configuration/sites/{siteId}".sub('{format}','json').sub('{' + 'siteId' + '}', site_id.to_s)

      # query parameters
      query_params = {}

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = nil
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:GET, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => 'Site')
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConfigurationApi#get_sites_site_id\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Update a endpoint.
    # 
    # @param site_id Site ID
    # @param [Hash] opts the optional parameters
    # @option opts [Site] :body Site
    # @return [Site]
    def put_sites_site_id(site_id, opts = {})
      data, status_code, headers = put_sites_site_id_with_http_info(site_id, opts)
      return data
    end

    # Update a endpoint.
    # 
    # @param site_id Site ID
    # @param [Hash] opts the optional parameters
    # @option opts [Site] :body Site
    # @return [Array<(Site, Fixnum, Hash)>] Site data, response status code and response headers
    def put_sites_site_id_with_http_info(site_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConfigurationApi#put_sites_site_id ..."
      end
      
      # verify the required parameter 'site_id' is set
      fail "Missing the required parameter 'site_id' when calling put_sites_site_id" if site_id.nil?
      
      # resource path
      path = "/api/v1/configuration/sites/{siteId}".sub('{format}','json').sub('{' + 'siteId' + '}', site_id.to_s)

      # query parameters
      query_params = {}

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = @api_client.object_to_http_body(opts[:'body'])
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:PUT, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => 'Site')
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConfigurationApi#put_sites_site_id\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Delete an ednpoint
    # 
    # @param site_id Site ID
    # @param [Hash] opts the optional parameters
    # @return [String]
    def delete_sites_site_id(site_id, opts = {})
      data, status_code, headers = delete_sites_site_id_with_http_info(site_id, opts)
      return data
    end

    # Delete an ednpoint
    # 
    # @param site_id Site ID
    # @param [Hash] opts the optional parameters
    # @return [Array<(String, Fixnum, Hash)>] String data, response status code and response headers
    def delete_sites_site_id_with_http_info(site_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConfigurationApi#delete_sites_site_id ..."
      end
      
      # verify the required parameter 'site_id' is set
      fail "Missing the required parameter 'site_id' when calling delete_sites_site_id" if site_id.nil?
      
      # resource path
      path = "/api/v1/configuration/sites/{siteId}".sub('{format}','json').sub('{' + 'siteId' + '}', site_id.to_s)

      # query parameters
      query_params = {}

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = nil
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:DELETE, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => 'String')
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConfigurationApi#delete_sites_site_id\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Get the list of Number Plans for this Site.
    # 
    # @param site_id Site ID
    # @param [Hash] opts the optional parameters
    # @return [Array<NumberPlan>]
    def get_sites_site_id_numberplans(site_id, opts = {})
      data, status_code, headers = get_sites_site_id_numberplans_with_http_info(site_id, opts)
      return data
    end

    # Get the list of Number Plans for this Site.
    # 
    # @param site_id Site ID
    # @param [Hash] opts the optional parameters
    # @return [Array<(Array<NumberPlan>, Fixnum, Hash)>] Array<NumberPlan> data, response status code and response headers
    def get_sites_site_id_numberplans_with_http_info(site_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConfigurationApi#get_sites_site_id_numberplans ..."
      end
      
      # verify the required parameter 'site_id' is set
      fail "Missing the required parameter 'site_id' when calling get_sites_site_id_numberplans" if site_id.nil?
      
      # resource path
      path = "/api/v1/configuration/sites/{siteId}/numberplans".sub('{format}','json').sub('{' + 'siteId' + '}', site_id.to_s)

      # query parameters
      query_params = {}

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = nil
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:GET, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => 'Array<NumberPlan>')
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConfigurationApi#get_sites_site_id_numberplans\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Update the list of Number Plans.
    # 
    # @param site_id Site ID
    # @param [Hash] opts the optional parameters
    # @option opts [Array<NumberPlan>] :body 
    # @return [Array<NumberPlan>]
    def put_sites_site_id_numberplans(site_id, opts = {})
      data, status_code, headers = put_sites_site_id_numberplans_with_http_info(site_id, opts)
      return data
    end

    # Update the list of Number Plans.
    # 
    # @param site_id Site ID
    # @param [Hash] opts the optional parameters
    # @option opts [Array<NumberPlan>] :body 
    # @return [Array<(Array<NumberPlan>, Fixnum, Hash)>] Array<NumberPlan> data, response status code and response headers
    def put_sites_site_id_numberplans_with_http_info(site_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConfigurationApi#put_sites_site_id_numberplans ..."
      end
      
      # verify the required parameter 'site_id' is set
      fail "Missing the required parameter 'site_id' when calling put_sites_site_id_numberplans" if site_id.nil?
      
      # resource path
      path = "/api/v1/configuration/sites/{siteId}/numberplans".sub('{format}','json').sub('{' + 'siteId' + '}', site_id.to_s)

      # query parameters
      query_params = {}

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = @api_client.object_to_http_body(opts[:'body'])
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:PUT, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => 'Array<NumberPlan>')
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConfigurationApi#put_sites_site_id_numberplans\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Get a list of Classifications for this Site
    # 
    # @param site_id Site ID
    # @param [Hash] opts the optional parameters
    # @option opts [String] :classification Classification
    # @return [Array<String>]
    def get_sites_site_id_numberplans_classifications(site_id, opts = {})
      data, status_code, headers = get_sites_site_id_numberplans_classifications_with_http_info(site_id, opts)
      return data
    end

    # Get a list of Classifications for this Site
    # 
    # @param site_id Site ID
    # @param [Hash] opts the optional parameters
    # @option opts [String] :classification Classification
    # @return [Array<(Array<String>, Fixnum, Hash)>] Array<String> data, response status code and response headers
    def get_sites_site_id_numberplans_classifications_with_http_info(site_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConfigurationApi#get_sites_site_id_numberplans_classifications ..."
      end
      
      # verify the required parameter 'site_id' is set
      fail "Missing the required parameter 'site_id' when calling get_sites_site_id_numberplans_classifications" if site_id.nil?
      
      # resource path
      path = "/api/v1/configuration/sites/{siteId}/numberplans/classifications".sub('{format}','json').sub('{' + 'siteId' + '}', site_id.to_s)

      # query parameters
      query_params = {}
      query_params[:'classification'] = opts[:'classification'] if opts[:'classification']

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = nil
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:GET, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => 'Array<String>')
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConfigurationApi#get_sites_site_id_numberplans_classifications\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Get a Number Plan by ID.
    # 
    # @param site_id Site ID
    # @param number_plan_id Number Plan ID
    # @param [Hash] opts the optional parameters
    # @return [NumberPlan]
    def get_sites_site_id_numberplans_numberplan_id(site_id, number_plan_id, opts = {})
      data, status_code, headers = get_sites_site_id_numberplans_numberplan_id_with_http_info(site_id, number_plan_id, opts)
      return data
    end

    # Get a Number Plan by ID.
    # 
    # @param site_id Site ID
    # @param number_plan_id Number Plan ID
    # @param [Hash] opts the optional parameters
    # @return [Array<(NumberPlan, Fixnum, Hash)>] NumberPlan data, response status code and response headers
    def get_sites_site_id_numberplans_numberplan_id_with_http_info(site_id, number_plan_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConfigurationApi#get_sites_site_id_numberplans_numberplan_id ..."
      end
      
      # verify the required parameter 'site_id' is set
      fail "Missing the required parameter 'site_id' when calling get_sites_site_id_numberplans_numberplan_id" if site_id.nil?
      
      # verify the required parameter 'number_plan_id' is set
      fail "Missing the required parameter 'number_plan_id' when calling get_sites_site_id_numberplans_numberplan_id" if number_plan_id.nil?
      
      # resource path
      path = "/api/v1/configuration/sites/{siteId}/numberplans/{numberPlanId}".sub('{format}','json').sub('{' + 'siteId' + '}', site_id.to_s).sub('{' + 'numberPlanId' + '}', number_plan_id.to_s)

      # query parameters
      query_params = {}

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = nil
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:GET, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => 'NumberPlan')
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConfigurationApi#get_sites_site_id_numberplans_numberplan_id\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Triggers the rebalance operation.
    # 
    # @param site_id Site ID
    # @param [Hash] opts the optional parameters
    # @return [nil]
    def post_sites_site_id_rebalance(site_id, opts = {})
      post_sites_site_id_rebalance_with_http_info(site_id, opts)
      return nil
    end

    # Triggers the rebalance operation.
    # 
    # @param site_id Site ID
    # @param [Hash] opts the optional parameters
    # @return [Array<(nil, Fixnum, Hash)>] nil, response status code and response headers
    def post_sites_site_id_rebalance_with_http_info(site_id, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug "Calling API: ConfigurationApi#post_sites_site_id_rebalance ..."
      end
      
      # verify the required parameter 'site_id' is set
      fail "Missing the required parameter 'site_id' when calling post_sites_site_id_rebalance" if site_id.nil?
      
      # resource path
      path = "/api/v1/configuration/sites/{siteId}/rebalance".sub('{format}','json').sub('{' + 'siteId' + '}', site_id.to_s)

      # query parameters
      query_params = {}

      # header parameters
      header_params = {}

      # HTTP header 'Accept' (if needed)
      _header_accept = ['application/json']
      _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result

      # HTTP header 'Content-Type'
      _header_content_type = ['application/json']
      header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)

      # form parameters
      form_params = {}

      # http body (model)
      post_body = nil
      

      auth_names = ['PureCloud Auth']
      data, status_code, headers = @api_client.call_api(:POST, path,
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: ConfigurationApi#post_sites_site_id_rebalance\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end
  end
end